- ir_node *res = irn;
-
- /* If the architecture dependent optimizations were not initialized
- or this optimization was not enabled. */
- if (params == NULL || (opts & arch_dep_mod_by_const) == 0)
- return irn;
-
- if (get_irn_opcode(irn) == iro_Mod) {
- ir_node *c = get_Mod_right(irn);
- ir_node *block, *left;
- ir_mode *mode;
- tarval *tv, *ntv;
- dbg_info *dbg;
- int n, bits;
- int k;
-
- if (get_irn_op(c) != op_Const)
- return irn;
-
- left = get_Mod_left(irn);
- mode = get_irn_mode(left);
- block = get_nodes_block(irn);
- dbg = get_irn_dbg_info(irn);
- tv = get_Const_tarval(c);
-
- bits = get_mode_size_bits(mode);
- n = (bits + 7) / 8;
-
- k = -1;
- if (mode_is_signed(mode)) {
- /* for signed divisions, the algorithm works for a / -2^k by negating the result */
- ntv = tarval_neg(tv);
- k = tv_ld2(ntv, n);
- }
-
- if (k < 0) {
- k = tv_ld2(tv, n);
- }
-
- if (k >= 0) {
- /* division by 2^k or -2^k:
- * we use "modulus" here, so x % y == x % -y that's why is no difference between the case 2^k and -2^k
- */
- if (mode_is_signed(mode)) {
- ir_node *k_node;
- ir_node *curr = left;
-
- if (k != 1) {
- k_node = new_r_Const(current_ir_graph, block, mode_Iu, new_tarval_from_long(k - 1, mode_Iu));
- curr = new_rd_Shrs(dbg, current_ir_graph, block, left, k_node, mode);
- }
-
- k_node = new_r_Const(current_ir_graph, block, mode_Iu, new_tarval_from_long(bits - k, mode_Iu));
- curr = new_rd_Shr(dbg, current_ir_graph, block, curr, k_node, mode);
-
- curr = new_rd_Add(dbg, current_ir_graph, block, left, curr, mode);
-
- k_node = new_r_Const(current_ir_graph, block, mode, new_tarval_from_long((-1) << k, mode));
- curr = new_rd_And(dbg, current_ir_graph, block, curr, k_node, mode);
-
- res = new_rd_Sub(dbg, current_ir_graph, block, left, curr, mode);
- }
- else { /* unsigned case */
- ir_node *k_node;
-
- k_node = new_r_Const(current_ir_graph, block, mode, new_tarval_from_long((1 << k) - 1, mode));
- res = new_rd_And(dbg, current_ir_graph, block, left, k_node, mode);
- }
- }
- else {
- /* other constant */
- if ((mode_is_signed(mode) && params->allow_mulhs) ||
- (!mode_is_signed(mode) && params->allow_mulhu)) {
- res = replace_div_by_mulh(irn, tv);
-
- res = new_rd_Mul(dbg, current_ir_graph, block, res, c, mode);
-
- /* res = arch_dep_mul_to_shift(res); */
-
- res = new_rd_Sub(dbg, current_ir_graph, block, left, res, mode);
- }
- }
- }
-
- if (res != irn)
- stat_arch_dep_replace_mod_by_const(irn);
-
- return res;
-}
-
-void arch_dep_replace_divmod_by_const(ir_node **div, ir_node **mod, ir_node *irn)
-{
- *div = *mod = NULL;
-
- /* If the architecture dependent optimizations were not initialized
- or this optimization was not enabled. */
- if (params == NULL ||
- ((opts & (arch_dep_div_by_const|arch_dep_mod_by_const)) != (arch_dep_div_by_const|arch_dep_mod_by_const)))
- return;
-
- if (get_irn_opcode(irn) == iro_DivMod) {
- ir_node *c = get_DivMod_right(irn);
- ir_node *block, *left;
- ir_mode *mode;
- tarval *tv, *ntv;
- dbg_info *dbg;
- int n, bits;
- int k, n_flag;
-
- if (get_irn_op(c) != op_Const)
- return;
-
- left = get_DivMod_left(irn);
- mode = get_irn_mode(left);
- block = get_nodes_block(irn);
- dbg = get_irn_dbg_info(irn);
- tv = get_Const_tarval(c);
-
- bits = get_mode_size_bits(mode);
- n = (bits + 7) / 8;
-
- k = -1;
- if (mode_is_signed(mode)) {
- /* for signed divisions, the algorithm works for a / -2^k by negating the result */
- ntv = tarval_neg(tv);
- n_flag = 1;
- k = tv_ld2(ntv, n);
- }
-
- if (k < 0) {
- n_flag = 0;
- k = tv_ld2(tv, n);
- }
-
- if (k >= 0) { /* division by 2^k or -2^k */
- if (mode_is_signed(mode)) {
- ir_node *k_node, *c_k;
- ir_node *curr = left;
-
- if (k != 1) {
- k_node = new_r_Const(current_ir_graph, block, mode_Iu, new_tarval_from_long(k - 1, mode_Iu));
- curr = new_rd_Shrs(dbg, current_ir_graph, block, left, k_node, mode);
- }
-
- k_node = new_r_Const(current_ir_graph, block, mode_Iu, new_tarval_from_long(bits - k, mode_Iu));
- curr = new_rd_Shr(dbg, current_ir_graph, block, curr, k_node, mode);
-
- curr = new_rd_Add(dbg, current_ir_graph, block, left, curr, mode);
-
- c_k = new_r_Const(current_ir_graph, block, mode_Iu, new_tarval_from_long(k, mode_Iu));
-
- *div = new_rd_Shrs(dbg, current_ir_graph, block, curr, c_k, mode);
-
- if (n_flag) { /* negate the div result */
- ir_node *k_node;
-
- k_node = new_r_Const(current_ir_graph, block, mode, get_mode_null(mode));
- *div = new_rd_Sub(dbg, current_ir_graph, block, k_node, *div, mode);
- }
-
- k_node = new_r_Const(current_ir_graph, block, mode, new_tarval_from_long((-1) << k, mode));
- curr = new_rd_And(dbg, current_ir_graph, block, curr, k_node, mode);
-
- *mod = new_rd_Sub(dbg, current_ir_graph, block, left, curr, mode);
- }
- else { /* unsigned case */
- ir_node *k_node;
-
- k_node = new_r_Const(current_ir_graph, block, mode_Iu, new_tarval_from_long(k, mode_Iu));
- *div = new_rd_Shr(dbg, current_ir_graph, block, left, k_node, mode);
-
- k_node = new_r_Const(current_ir_graph, block, mode, new_tarval_from_long((1 << k) - 1, mode));
- *mod = new_rd_And(dbg, current_ir_graph, block, left, k_node, mode);
- }
- }
- else {
- /* other constant */
- if ((mode_is_signed(mode) && params->allow_mulhs) ||
- (!mode_is_signed(mode) && params->allow_mulhu)) {
- ir_node *t;
-
- *div = replace_div_by_mulh(irn, tv);
-
- t = new_rd_Mul(dbg, current_ir_graph, block, *div, c, mode);
-
- /* t = arch_dep_mul_to_shift(t); */
-
- *mod = new_rd_Sub(dbg, current_ir_graph, block, left, t, mode);
- }
- }
- }
-
- if (*div)
- stat_arch_dep_replace_DivMod_by_const(irn);
-}
-
-
-static const arch_dep_params_t default_params = {
- 1, /* also use subs */
- 4, /* maximum shifts */
- 31, /* maximum shift amount */
-
- 0, /* allow Mulhs */
- 0, /* allow Mulus */
- 32 /* Mulh allowed up to 32 bit */
-};
-
-const arch_dep_params_t *arch_dep_default_factory(void) {
- return &default_params;
+ const ir_settings_arch_dep_t *params = be_get_backend_param()->dep_param;
+ ir_node *res = irn;
+
+ /* If the architecture dependent optimizations were not initialized
+ or this optimization was not enabled. */
+ if (params == NULL || (opts & arch_dep_mod_by_const) == 0)
+ return irn;
+
+ if (is_Mod(irn)) {
+ ir_node *c = get_Mod_right(irn);
+ ir_node *block, *left;
+ ir_mode *mode;
+ ir_tarval *tv, *ntv;
+ dbg_info *dbg;
+ int n, bits;
+ int k;
+
+ if (! is_Const(c))
+ return irn;
+
+ tv = get_Const_tarval(c);
+
+ /* check for division by zero */
+ if (tarval_is_null(tv))
+ return irn;
+
+ left = get_Mod_left(irn);
+ mode = get_irn_mode(left);
+ block = get_irn_n(irn, -1);
+ dbg = get_irn_dbg_info(irn);
+ bits = get_mode_size_bits(mode);
+ n = (bits + 7) / 8;
+
+ k = -1;
+ if (mode_is_signed(mode)) {
+ /* for signed divisions, the algorithm works for a / -2^k by negating the result */
+ ntv = tarval_neg(tv);
+ k = tv_ld2(ntv, n);
+ }
+
+ if (k < 0) {
+ k = tv_ld2(tv, n);
+ }
+
+ if (k >= 0) {
+ ir_graph *irg = get_irn_irg(irn);
+ /* division by 2^k or -2^k:
+ * we use "modulus" here, so x % y == x % -y that's why is no difference between the case 2^k and -2^k
+ */
+ if (mode_is_signed(mode)) {
+ ir_node *k_node;
+ ir_node *curr = left;
+
+ if (k != 1) {
+ k_node = new_r_Const_long(irg, mode_Iu, k - 1);
+ curr = new_rd_Shrs(dbg, block, left, k_node, mode);
+ }
+
+ k_node = new_r_Const_long(irg, mode_Iu, bits - k);
+ curr = new_rd_Shr(dbg, block, curr, k_node, mode);
+
+ curr = new_rd_Add(dbg, block, left, curr, mode);
+
+ k_node = new_r_Const_long(irg, mode, (-1) << k);
+ curr = new_rd_And(dbg, block, curr, k_node, mode);
+
+ res = new_rd_Sub(dbg, block, left, curr, mode);
+ } else { /* unsigned case */
+ ir_node *k_node;
+
+ k_node = new_r_Const_long(irg, mode, (1 << k) - 1);
+ res = new_rd_And(dbg, block, left, k_node, mode);
+ }
+ } else {
+ /* other constant */
+ if (allow_Mulh(params, mode)) {
+ res = replace_div_by_mulh(irn, tv);
+
+ res = new_rd_Mul(dbg, block, res, c, mode);
+
+ /* res = arch_dep_mul_to_shift(res); */
+
+ res = new_rd_Sub(dbg, block, left, res, mode);
+ }
+ }
+ }
+
+ if (res != irn)
+ hook_arch_dep_replace_division_by_const(irn);
+
+ return res;