+2016-10-09 Prathamesh Kulkarni <prathamesh.kulkarni@linaro.org>
+
+ * ipa-cp.c (ipcp_alignment_lattice): Remove.
+ (ipcp_param_lattices): Remove field alignment.
+ (print_all_lattices): Remove call to ipcp_alignment_lattice::print.
+ (set_all_contains_variable): Remove call to
+ ipcp_alignment_lattice::set_to_bottom.
+ (initialize_node_lattices): Likewise.
+ (propagate_alignment_accross_jump_function): Remove.
+ (propagate_constants_accross_call): Remove call to
+ propagate_alignment_accross_jump_function.
+ (ipcp_store_alignment_results): Remove.
+ (ipcp_driver): Remove call to ipcp_store_alignment_results.
+ (propagate_bits_accross_jump_function): Handle ancestor jump function.
+ * ipa-prop.c (ipa_print_node_jump_functions_for_edge): Remove
+ pretty-printing of alignment jump function.
+ (ipa_set_jf_unknown): Remove assignment to jfunc->alignment.known.
+ (ipa_compute_jump_functions_for_edge): Adjust ipa_bits jump function for
+ alignments and remove computing ipa_alignment jump function.
+ (ipa_node_params_t::duplicate): Remove copying of src_trans->alignments.
+ (ipa_write_jump_functions): Remove streaming for ipa_alignment.
+ (ipa_read_jump_function): Remove reading of ipa_alignment.
+ (write_ipcp_transformation_info): Remove streaming for alignment
+ propagation summary.
+ (read_ipcp_transformation_info): Remove reading of alignment
+ propagation summary.
+ (ipcp_update_alignments): Remove.
+ (ipcp_update_bits): Adjust to set alignment for parameters of pointer
+ type.
+ (ipcp_transform_function): Remove call to ipcp_update_alignments()
+ and remove assignment to (*ipcp_transformations)[node->uid].alignments.
+ * ipa-prop.h (ipa_alignment): Remove.
+ (ipa_jump_func): Remove field alignment.
+ (ipcp_transformation_summary): Remove field alignments.
+ * doc/invoke.texi: Mark fipa-cp-alignment as obsolete.
+ * opts.c (default_options_table): Remove entry for fipa-cp-alignment.
+ (enable_fdo_optimizations): Remove checking for fipa-cp-alignment.
+
2016-10-08 Eric Botcazou <ebotcazou@adacore.com>
* config/sparc/sparc.h (FIXED_REGISTERS): Add %icc.
This flag is enabled by default at @option{-O2} and @option{-Os}. It
requires that @option{-fipa-cp} is enabled.
+@option{-fipa-cp-alignment} is obsolete, use @option{-fipa-bit-cp} instead.
@item -fipa-bit-cp
@opindex -fipa-bit-cp
struct ipcp_agg_lattice *next;
};
-/* Lattice of pointer alignment. Unlike the previous types of lattices, this
- one is only capable of holding one value. */
-
-class ipcp_alignment_lattice
-{
-public:
- /* If bottom and top are both false, these two fields hold values as given by
- ptr_info_def and get_pointer_alignment_1. */
- unsigned align;
- unsigned misalign;
-
- inline bool bottom_p () const;
- inline bool top_p () const;
- inline bool set_to_bottom ();
- bool meet_with (unsigned new_align, unsigned new_misalign);
- bool meet_with (const ipcp_alignment_lattice &other, HOST_WIDE_INT offset);
- void print (FILE * f);
-private:
- /* If set, this lattice is bottom and all other fields should be
- disregarded. */
- bool bottom;
- /* If bottom and not_top are false, the lattice is TOP. If not_top is true,
- the known alignment is stored in the fields align and misalign. The field
- is negated so that memset to zero initializes the lattice to TOP
- state. */
- bool not_top;
-
- bool meet_with_1 (unsigned new_align, unsigned new_misalign);
-};
-
/* Lattice of known bits, only capable of holding one value.
Bitwise constant propagation propagates which bits of a
value are constant.
ipcp_lattice<ipa_polymorphic_call_context> ctxlat;
/* Lattices describing aggregate parts. */
ipcp_agg_lattice *aggs;
- /* Lattice describing known alignment. */
- ipcp_alignment_lattice alignment;
/* Lattice describing known bits. */
ipcp_bits_lattice bits_lattice;
/* Lattice describing value range. */
fprintf (f, "\n");
}
-/* Print alignment lattice to F. */
-
-void
-ipcp_alignment_lattice::print (FILE * f)
-{
- if (top_p ())
- fprintf (f, " Alignment unknown (TOP)\n");
- else if (bottom_p ())
- fprintf (f, " Alignment unusable (BOTTOM)\n");
- else
- fprintf (f, " Alignment %u, misalignment %u\n", align, misalign);
-}
-
void
ipcp_bits_lattice::print (FILE *f)
{
plats->itself.print (f, dump_sources, dump_benefits);
fprintf (f, " ctxs: ");
plats->ctxlat.print (f, dump_sources, dump_benefits);
- plats->alignment.print (f);
plats->bits_lattice.print (f);
fprintf (f, " ");
plats->m_value_range.print (f);
return ret;
}
-/* Return true if alignment information in the lattice is yet unknown. */
-
-bool
-ipcp_alignment_lattice::top_p () const
-{
- return !bottom && !not_top;
-}
-
-/* Return true if alignment information in the lattice is known to be
- unusable. */
-
-bool
-ipcp_alignment_lattice::bottom_p () const
-{
- return bottom;
-}
-
-/* Set alignment information in the lattice to bottom. Return true if it
- previously was in a different state. */
-
-bool
-ipcp_alignment_lattice::set_to_bottom ()
-{
- if (bottom_p ())
- return false;
- bottom = true;
- return true;
-}
-
-/* Meet the current value of the lattice with described by OTHER
- lattice. */
-
bool
ipcp_vr_lattice::meet_with (const ipcp_vr_lattice &other)
{
return true;
}
-/* Meet the current value of the lattice with alignment described by NEW_ALIGN
- and NEW_MISALIGN, assuming that we know the current value is neither TOP nor
- BOTTOM. Return true if the value of lattice has changed. */
-
-bool
-ipcp_alignment_lattice::meet_with_1 (unsigned new_align, unsigned new_misalign)
-{
- gcc_checking_assert (new_align != 0);
- if (align == new_align && misalign == new_misalign)
- return false;
-
- bool changed = false;
- if (align > new_align)
- {
- align = new_align;
- misalign = misalign % new_align;
- changed = true;
- }
- if (misalign != (new_misalign % align))
- {
- int diff = abs ((int) misalign - (int) (new_misalign % align));
- align = least_bit_hwi (diff);
- if (align)
- misalign = misalign % align;
- else
- set_to_bottom ();
- changed = true;
- }
- gcc_checking_assert (bottom_p () || align != 0);
- return changed;
-}
-
-/* Meet the current value of the lattice with alignment described by NEW_ALIGN
- and NEW_MISALIGN. Return true if the value of lattice has changed. */
-
-bool
-ipcp_alignment_lattice::meet_with (unsigned new_align, unsigned new_misalign)
-{
- gcc_assert (new_align != 0);
- if (bottom_p ())
- return false;
- if (top_p ())
- {
- not_top = true;
- align = new_align;
- misalign = new_misalign;
- return true;
- }
- return meet_with_1 (new_align, new_misalign);
-}
-
-/* Meet the current value of the lattice with OTHER, taking into account that
- OFFSET has been added to the pointer value. Return true if the value of
- lattice has changed. */
-
-bool
-ipcp_alignment_lattice::meet_with (const ipcp_alignment_lattice &other,
- HOST_WIDE_INT offset)
-{
- if (other.bottom_p ())
- return set_to_bottom ();
- if (bottom_p () || other.top_p ())
- return false;
-
- unsigned adjusted_misalign = (other.misalign + offset) % other.align;
- if (top_p ())
- {
- not_top = true;
- align = other.align;
- misalign = adjusted_misalign;
- return true;
- }
-
- return meet_with_1 (other.align, adjusted_misalign);
-}
-
/* Set lattice value to bottom, if it already isn't the case. */
bool
ret = plats->itself.set_contains_variable ();
ret |= plats->ctxlat.set_contains_variable ();
ret |= set_agg_lats_contain_variable (plats);
- ret |= plats->alignment.set_to_bottom ();
ret |= plats->bits_lattice.set_to_bottom ();
ret |= plats->m_value_range.set_to_bottom ();
return ret;
plats->itself.set_to_bottom ();
plats->ctxlat.set_to_bottom ();
set_agg_lats_to_bottom (plats);
- plats->alignment.set_to_bottom ();
plats->bits_lattice.set_to_bottom ();
plats->m_value_range.set_to_bottom ();
}
return ret;
}
-/* Propagate alignments across jump function JFUNC that is associated with
- edge CS and update DEST_LAT accordingly. */
-
-static bool
-propagate_alignment_accross_jump_function (cgraph_edge *cs,
- ipa_jump_func *jfunc,
- ipcp_alignment_lattice *dest_lat)
-{
- if (dest_lat->bottom_p ())
- return false;
-
- if (jfunc->type == IPA_JF_PASS_THROUGH
- || jfunc->type == IPA_JF_ANCESTOR)
- {
- struct ipa_node_params *caller_info = IPA_NODE_REF (cs->caller);
- HOST_WIDE_INT offset = 0;
- int src_idx;
-
- if (jfunc->type == IPA_JF_PASS_THROUGH)
- {
- enum tree_code op = ipa_get_jf_pass_through_operation (jfunc);
- if (op != NOP_EXPR)
- {
- if (op != POINTER_PLUS_EXPR
- && op != PLUS_EXPR)
- return dest_lat->set_to_bottom ();
- tree operand = ipa_get_jf_pass_through_operand (jfunc);
- if (!tree_fits_shwi_p (operand))
- return dest_lat->set_to_bottom ();
- offset = tree_to_shwi (operand);
- }
- src_idx = ipa_get_jf_pass_through_formal_id (jfunc);
- }
- else
- {
- src_idx = ipa_get_jf_ancestor_formal_id (jfunc);
- offset = ipa_get_jf_ancestor_offset (jfunc) / BITS_PER_UNIT;
- }
-
- struct ipcp_param_lattices *src_lats;
- src_lats = ipa_get_parm_lattices (caller_info, src_idx);
- return dest_lat->meet_with (src_lats->alignment, offset);
- }
- else
- {
- if (jfunc->alignment.known)
- return dest_lat->meet_with (jfunc->alignment.align,
- jfunc->alignment.misalign);
- else
- return dest_lat->set_to_bottom ();
- }
-}
-
/* Propagate bits across jfunc that is associated with
edge cs and update dest_lattice accordingly. */
unsigned precision = TYPE_PRECISION (parm_type);
signop sgn = TYPE_SIGN (parm_type);
- if (jfunc->type == IPA_JF_PASS_THROUGH)
+ if (jfunc->type == IPA_JF_PASS_THROUGH
+ || jfunc->type == IPA_JF_ANCESTOR)
{
struct ipa_node_params *caller_info = IPA_NODE_REF (cs->caller);
- enum tree_code code = ipa_get_jf_pass_through_operation (jfunc);
tree operand = NULL_TREE;
+ enum tree_code code;
+ unsigned src_idx;
- if (code != NOP_EXPR)
- operand = ipa_get_jf_pass_through_operand (jfunc);
+ if (jfunc->type == IPA_JF_PASS_THROUGH)
+ {
+ code = ipa_get_jf_pass_through_operation (jfunc);
+ src_idx = ipa_get_jf_pass_through_formal_id (jfunc);
+ if (code != NOP_EXPR)
+ operand = ipa_get_jf_pass_through_operand (jfunc);
+ }
+ else
+ {
+ code = POINTER_PLUS_EXPR;
+ src_idx = ipa_get_jf_ancestor_formal_id (jfunc);
+ unsigned HOST_WIDE_INT offset = ipa_get_jf_ancestor_offset (jfunc) / BITS_PER_UNIT;
+ operand = build_int_cstu (size_type_node, offset);
+ }
- int src_idx = ipa_get_jf_pass_through_formal_id (jfunc);
struct ipcp_param_lattices *src_lats
= ipa_get_parm_lattices (caller_info, src_idx);
&dest_plats->itself);
ret |= propagate_context_accross_jump_function (cs, jump_func, i,
&dest_plats->ctxlat);
- ret |= propagate_alignment_accross_jump_function (cs, jump_func,
- &dest_plats->alignment);
ret |= propagate_bits_accross_jump_function (cs, i, jump_func,
&dest_plats->bits_lattice);
ret |= propagate_aggs_accross_jump_function (cs, jump_func,
}
}
-/* Look up all alignment information that we have discovered and copy it over
- to the transformation summary. */
-
-static void
-ipcp_store_alignment_results (void)
-{
- cgraph_node *node;
-
- FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
- {
- ipa_node_params *info = IPA_NODE_REF (node);
- bool dumped_sth = false;
- bool found_useful_result = false;
-
- if (!opt_for_fn (node->decl, flag_ipa_cp_alignment))
- {
- if (dump_file)
- fprintf (dump_file, "Not considering %s for alignment discovery "
- "and propagate; -fipa-cp-alignment: disabled.\n",
- node->name ());
- continue;
- }
-
- if (info->ipcp_orig_node)
- info = IPA_NODE_REF (info->ipcp_orig_node);
-
- unsigned count = ipa_get_param_count (info);
- for (unsigned i = 0; i < count ; i++)
- {
- ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
- if (!plats->alignment.bottom_p ()
- && !plats->alignment.top_p ())
- {
- gcc_checking_assert (plats->alignment.align > 0);
- found_useful_result = true;
- break;
- }
- }
- if (!found_useful_result)
- continue;
-
- ipcp_grow_transformations_if_necessary ();
- ipcp_transformation_summary *ts = ipcp_get_transformation_summary (node);
- vec_safe_reserve_exact (ts->alignments, count);
-
- for (unsigned i = 0; i < count ; i++)
- {
- ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
- ipa_alignment al;
-
- if (!plats->alignment.bottom_p ()
- && !plats->alignment.top_p ())
- {
- al.known = true;
- al.align = plats->alignment.align;
- al.misalign = plats->alignment.misalign;
- }
- else
- al.known = false;
-
- ts->alignments->quick_push (al);
- if (!dump_file || !al.known)
- continue;
- if (!dumped_sth)
- {
- fprintf (dump_file, "Propagated alignment info for function %s/%i:\n",
- node->name (), node->order);
- dumped_sth = true;
- }
- fprintf (dump_file, " param %i: align: %u, misalign: %u\n",
- i, al.align, al.misalign);
- }
- }
-}
-
/* Look up all the bits information that we have discovered and copy it over
to the transformation summary. */
ipcp_propagate_stage (&topo);
/* Decide what constant propagation and cloning should be performed. */
ipcp_decision_stage (&topo);
- /* Store results of alignment propagation. */
- ipcp_store_alignment_results ();
/* Store results of bits propagation. */
ipcp_store_bits_results ();
/* Store results of value range propagation. */
ctx->dump (dump_file);
}
- if (jump_func->alignment.known)
- {
- fprintf (f, " Alignment: %u, misalignment: %u\n",
- jump_func->alignment.align,
- jump_func->alignment.misalign);
- }
- else
- fprintf (f, " Unknown alignment\n");
-
if (jump_func->bits.known)
{
fprintf (f, " value: "); print_hex (jump_func->bits.value, f);
ipa_set_jf_unknown (struct ipa_jump_func *jfunc)
{
jfunc->type = IPA_JF_UNKNOWN;
- jfunc->alignment.known = false;
jfunc->bits.known = false;
jfunc->vr_known = false;
}
useful_context = true;
}
- if (POINTER_TYPE_P (TREE_TYPE(arg)))
- {
- unsigned HOST_WIDE_INT hwi_bitpos;
- unsigned align;
-
- get_pointer_alignment_1 (arg, &align, &hwi_bitpos);
- if (align > BITS_PER_UNIT
- && align % BITS_PER_UNIT == 0
- && hwi_bitpos % BITS_PER_UNIT == 0)
- {
- jfunc->alignment.known = true;
- jfunc->alignment.align = align / BITS_PER_UNIT;
- jfunc->alignment.misalign = hwi_bitpos / BITS_PER_UNIT;
- }
- else
- gcc_assert (!jfunc->alignment.known);
- gcc_assert (!jfunc->vr_known);
- }
- else
+ if (!POINTER_TYPE_P (TREE_TYPE (arg)))
{
wide_int min, max;
value_range_type type;
}
else
gcc_assert (!jfunc->vr_known);
- gcc_assert (!jfunc->alignment.known);
}
if (INTEGRAL_TYPE_P (TREE_TYPE (arg))
jfunc->bits.mask = 0;
}
}
+ else if (POINTER_TYPE_P (TREE_TYPE (arg)))
+ {
+ unsigned HOST_WIDE_INT bitpos;
+ unsigned align;
+
+ jfunc->bits.known = true;
+ get_pointer_alignment_1 (arg, &align, &bitpos);
+ jfunc->bits.mask = wi::mask<widest_int>(TYPE_PRECISION (TREE_TYPE (arg)), false)
+ .and_not (align / BITS_PER_UNIT - 1);
+ jfunc->bits.value = bitpos / BITS_PER_UNIT;
+ }
else
gcc_assert (!jfunc->bits.known);
{
ipcp_grow_transformations_if_necessary ();
src_trans = ipcp_get_transformation_summary (src);
- const vec<ipa_alignment, va_gc> *src_alignments = src_trans->alignments;
const vec<ipa_vr, va_gc> *src_vr = src_trans->m_vr;
- vec<ipa_alignment, va_gc> *&dst_alignments
- = ipcp_get_transformation_summary (dst)->alignments;
vec<ipa_vr, va_gc> *&dst_vr
= ipcp_get_transformation_summary (dst)->m_vr;
- if (vec_safe_length (src_trans->alignments) > 0)
- {
- vec_safe_reserve_exact (dst_alignments, src_alignments->length ());
- for (unsigned i = 0; i < src_alignments->length (); ++i)
- dst_alignments->quick_push ((*src_alignments)[i]);
- }
if (vec_safe_length (src_trans->m_vr) > 0)
{
vec_safe_reserve_exact (dst_vr, src_vr->length ());
stream_write_tree (ob, item->value, true);
}
- bp = bitpack_create (ob->main_stream);
- bp_pack_value (&bp, jump_func->alignment.known, 1);
- streamer_write_bitpack (&bp);
- if (jump_func->alignment.known)
- {
- streamer_write_uhwi (ob, jump_func->alignment.align);
- streamer_write_uhwi (ob, jump_func->alignment.misalign);
- }
-
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, jump_func->bits.known, 1);
streamer_write_bitpack (&bp);
}
struct bitpack_d bp = streamer_read_bitpack (ib);
- bool alignment_known = bp_unpack_value (&bp, 1);
- if (alignment_known)
- {
- jump_func->alignment.known = true;
- jump_func->alignment.align = streamer_read_uhwi (ib);
- jump_func->alignment.misalign = streamer_read_uhwi (ib);
- }
- else
- jump_func->alignment.known = false;
-
- bp = streamer_read_bitpack (ib);
bool bits_known = bp_unpack_value (&bp, 1);
if (bits_known)
{
}
ipcp_transformation_summary *ts = ipcp_get_transformation_summary (node);
- if (ts && vec_safe_length (ts->alignments) > 0)
- {
- count = ts->alignments->length ();
-
- streamer_write_uhwi (ob, count);
- for (unsigned i = 0; i < count; ++i)
- {
- ipa_alignment *parm_al = &(*ts->alignments)[i];
-
- struct bitpack_d bp;
- bp = bitpack_create (ob->main_stream);
- bp_pack_value (&bp, parm_al->known, 1);
- streamer_write_bitpack (&bp);
- if (parm_al->known)
- {
- streamer_write_uhwi (ob, parm_al->align);
- streamer_write_hwi_in_range (ob->main_stream, 0, parm_al->align,
- parm_al->misalign);
- }
- }
- }
- else
- streamer_write_uhwi (ob, 0);
-
if (ts && vec_safe_length (ts->m_vr) > 0)
{
count = ts->m_vr->length ();
aggvals = av;
}
ipa_set_node_agg_value_chain (node, aggvals);
-
- count = streamer_read_uhwi (ib);
- if (count > 0)
- {
- ipcp_grow_transformations_if_necessary ();
-
- ipcp_transformation_summary *ts = ipcp_get_transformation_summary (node);
- vec_safe_grow_cleared (ts->alignments, count);
-
- for (i = 0; i < count; i++)
- {
- ipa_alignment *parm_al;
- parm_al = &(*ts->alignments)[i];
- struct bitpack_d bp;
- bp = streamer_read_bitpack (ib);
- parm_al->known = bp_unpack_value (&bp, 1);
- if (parm_al->known)
- {
- parm_al->align = streamer_read_uhwi (ib);
- parm_al->misalign
- = streamer_read_hwi_in_range (ib, "ipa-prop misalign",
- 0, parm_al->align);
- }
- }
- }
-
+
count = streamer_read_uhwi (ib);
if (count > 0)
{
return NULL;
}
-/* Update alignment of formal parameters as described in
- ipcp_transformation_summary. */
-
-static void
-ipcp_update_alignments (struct cgraph_node *node)
-{
- tree fndecl = node->decl;
- tree parm = DECL_ARGUMENTS (fndecl);
- tree next_parm = parm;
- ipcp_transformation_summary *ts = ipcp_get_transformation_summary (node);
- if (!ts || vec_safe_length (ts->alignments) == 0)
- return;
- const vec<ipa_alignment, va_gc> &alignments = *ts->alignments;
- unsigned count = alignments.length ();
-
- for (unsigned i = 0; i < count; ++i, parm = next_parm)
- {
- if (node->clone.combined_args_to_skip
- && bitmap_bit_p (node->clone.combined_args_to_skip, i))
- continue;
- gcc_checking_assert (parm);
- next_parm = DECL_CHAIN (parm);
-
- if (!alignments[i].known || !is_gimple_reg (parm))
- continue;
- tree ddef = ssa_default_def (DECL_STRUCT_FUNCTION (node->decl), parm);
- if (!ddef)
- continue;
-
- if (dump_file)
- fprintf (dump_file, " Adjusting alignment of param %u to %u, "
- "misalignment to %u\n", i, alignments[i].align,
- alignments[i].misalign);
-
- struct ptr_info_def *pi = get_ptr_info (ddef);
- gcc_checking_assert (pi);
- unsigned old_align;
- unsigned old_misalign;
- bool old_known = get_ptr_info_alignment (pi, &old_align, &old_misalign);
-
- if (old_known
- && old_align >= alignments[i].align)
- {
- if (dump_file)
- fprintf (dump_file, " But the alignment was already %u.\n",
- old_align);
- continue;
- }
- set_ptr_info_alignment (pi, alignments[i].align, alignments[i].misalign);
- }
-}
-
/* Update bits info of formal parameters as described in
ipcp_transformation_summary. */
next_parm = DECL_CHAIN (parm);
if (!bits[i].known
- || !INTEGRAL_TYPE_P (TREE_TYPE (parm))
+ || !(INTEGRAL_TYPE_P (TREE_TYPE (parm)) || POINTER_TYPE_P (TREE_TYPE (parm)))
|| !is_gimple_reg (parm))
continue;
fprintf (dump_file, "\n");
}
- unsigned prec = TYPE_PRECISION (TREE_TYPE (ddef));
- signop sgn = TYPE_SIGN (TREE_TYPE (ddef));
+ if (INTEGRAL_TYPE_P (TREE_TYPE (ddef)))
+ {
+ unsigned prec = TYPE_PRECISION (TREE_TYPE (ddef));
+ signop sgn = TYPE_SIGN (TREE_TYPE (ddef));
+
+ wide_int nonzero_bits = wide_int::from (bits[i].mask, prec, UNSIGNED)
+ | wide_int::from (bits[i].value, prec, sgn);
+ set_nonzero_bits (ddef, nonzero_bits);
+ }
+ else
+ {
+ unsigned tem = bits[i].mask.to_uhwi ();
+ unsigned HOST_WIDE_INT bitpos = bits[i].value.to_uhwi ();
+ unsigned align = tem & -tem;
+ unsigned misalign = bitpos & (align - 1);
- wide_int nonzero_bits = wide_int::from (bits[i].mask, prec, UNSIGNED)
- | wide_int::from (bits[i].value, prec, sgn);
- set_nonzero_bits (ddef, nonzero_bits);
+ if (align > 1)
+ {
+ if (dump_file)
+ fprintf (dump_file, "Adjusting align: %u, misalign: %u\n", align, misalign);
+
+ unsigned old_align, old_misalign;
+ struct ptr_info_def *pi = get_ptr_info (ddef);
+ bool old_known = get_ptr_info_alignment (pi, &old_align, &old_misalign);
+
+ if (old_known
+ && old_align > align)
+ {
+ if (dump_file)
+ {
+ fprintf (dump_file, "But alignment was already %u.\n", old_align);
+ if ((old_misalign & (align - 1)) != misalign)
+ fprintf (dump_file, "old_misalign (%u) and misalign (%u) mismatch\n",
+ old_misalign, misalign);
+ }
+ continue;
+ }
+
+ if (old_known
+ && ((misalign & (old_align - 1)) != old_misalign)
+ && dump_file)
+ fprintf (dump_file, "old_misalign (%u) and misalign (%u) mismatch\n",
+ old_misalign, misalign);
+
+ set_ptr_info_alignment (pi, align, misalign);
+ }
+ }
}
}
fprintf (dump_file, "Modification phase of node %s/%i\n",
node->name (), node->order);
- ipcp_update_alignments (node);
ipcp_update_bits (node);
ipcp_update_vr (node);
aggval = ipa_get_agg_replacements_for_node (node);
fbi.bb_infos.release ();
free_dominance_info (CDI_DOMINATORS);
(*ipcp_transformations)[node->uid].agg_values = NULL;
- (*ipcp_transformations)[node->uid].alignments = NULL;
descriptors.release ();
if (!something_changed)
typedef struct ipa_agg_jump_function *ipa_agg_jump_function_p;
-/* Info about pointer alignments. */
-struct GTY(()) ipa_alignment
-{
- /* The data fields below are valid only if known is true. */
- bool known;
- /* See ptr_info_def and get_pointer_alignment_1 for description of these
- two. */
- unsigned align;
- unsigned misalign;
-};
-
/* Information about zero/non-zero bits. */
struct GTY(()) ipa_bits
{
description. */
struct ipa_agg_jump_function agg;
- /* Information about alignment of pointers. */
- struct ipa_alignment alignment;
-
/* Information about zero/non-zero bits. */
struct ipa_bits bits;
{
/* Linked list of known aggregate values. */
ipa_agg_replacement_value *agg_values;
- /* Alignment information for pointers. */
- vec<ipa_alignment, va_gc> *alignments;
/* Known bits information. */
vec<ipa_bits, va_gc> *bits;
/* Value range information. */
{ OPT_LEVELS_2_PLUS, OPT_ftree_pre, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_ftree_switch_conversion, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
- { OPT_LEVELS_2_PLUS, OPT_fipa_cp_alignment, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fipa_bit_cp, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fipa_vrp, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fdevirtualize, NULL, 1 },
if (!opts_set->x_flag_ipa_cp_clone
&& value && opts->x_flag_ipa_cp)
opts->x_flag_ipa_cp_clone = value;
- if (!opts_set->x_flag_ipa_cp_alignment
- && value && opts->x_flag_ipa_cp)
- opts->x_flag_ipa_cp_alignment = value;
if (!opts_set->x_flag_ipa_bit_cp
&& value && opts->x_flag_ipa_cp)
opts->x_flag_ipa_bit_cp = value;
+2016-10-09 Prathamesh Kulkarni <prathamesh.kulkarni@linaro.org>
+
+ * gcc.dg/ipa/propalign-1.c: Adjust scan-ipa-dump.
+ * gcc.dg/ipa/propalign-2.c: Likewise
+ * gcc.dg/ipa/propalign-3.c: Likewise.
+ * gcc.dg/ipa/propalign-4.c: Likewise.
+ * gcc.dg/ipa/propalign-5.c: Likewise.
+
2016-10-08 Jakub Jelinek <jakub@redhat.com>
* c-c++-common/Wimplicit-fallthrough-23.c (foo): Add further tests.
}
-/* { dg-final { scan-ipa-dump "Adjusting alignment of param" "cp" } } */
+/* { dg-final { scan-ipa-dump "Adjusting align" "cp" } } */
/* { dg-final { scan-tree-dump-not "fail_the_test" "optimized" } } */
through (c.buf);
}
-/* { dg-final { scan-ipa-dump "Adjusting alignment of param" "cp" } } */
+/* { dg-final { scan-ipa-dump "Adjusting align" "cp" } } */
/* { dg-final { scan-tree-dump-not "fail_the_test" "optimized" } } */
/* { dg-do compile } */
-/* { dg-options "-O2 -fno-ipa-cp-alignment -fno-early-inlining -fdump-ipa-cp -fdump-tree-optimized" } */
+/* { dg-options "-O2 -fno-ipa-bit-cp -fno-early-inlining -fdump-ipa-cp -fdump-tree-optimized" } */
/* { dg-skip-if "No alignment restrictions" { { ! natural_alignment_32 } && { ! natural_alignment_64 } } } */
#include <stdint.h>
through (c.buf);
}
-/* { dg-final { scan-ipa-dump-not "Adjusting alignment of param" "cp" } } */
+/* { dg-final { scan-ipa-dump-not "align:" "cp" } } */
/* { dg-final { scan-tree-dump "fail_the_test" "optimized" } } */
test (&aa[3]);
return 0;
}
-/* { dg-final { scan-ipa-dump "Alignment 8, misalignment 4" "cp" } } */
+/* { dg-final { scan-ipa-dump "align: 8, misalign: 4" "cp" } } */
test (&bb);
return 0;
}
-/* { dg-final { scan-ipa-dump "Alignment 2" "cp" } } */
+/* { dg-final { scan-ipa-dump "align: 2" "cp" } } */
projects / gcc.git / commitdiff