PR25413 - data alignment question

[Dorit Naishlos <DORIT at il dot ibm dot com>]

Given a pointer to type T - when can we assume that the data pointed to is
naturally aligned (aligned on the size of the type T)?

      The vectorizer currently works under the assumption that all data is
naturally aligned. At least one place where this may result in generation
of wrong code by the vectorizer is when we peel the first few iterations of
a loop in order to align a data-reference in the loop (this is what happens
in PR25413).

To fix this we can distinguish between two cases:

1. The misalignment of the dataref can be computed at compile time, in
which case it's possible to figure out at compile time if the data is not
naturally aligned (see testcase recently committed by Devang to apple-ppc
branch:
http://gcc.gnu.org/viewcvs/branches/apple-local-200502-branch/gcc/testsuite/gcc.dg/vect/vect-align-1.c?rev=108214&view=markup
). In this case, we can avoid using loop-peeling to force the dataref's
alignment.

2. The misalignment of the dataref cannot be computed at compile time
(e.g., a pointer is passed as an argument to a function). In this
situation, are there cases in which we can still assume/prove that the data
pointed-to is naturally aligned? Which (target dependent) API can be
consulted here? 'get_mode_alignment' on Pentium4 returns 64bit for
DFmode/DImode although data of these modes may reside on an address which
is only 32bit alignd (see testcase in PR25413). Same for TYPE_ALIGN.
BIGGEST_FIELD_ALIGNMENT seems to be the only relevant parameter that
returns 32bit on x86. Since we don't know if a given pointer points to a
field, should we always check for:
      MIN (BIGGEST_FIELD_ALIGNMENT, get_mode_alignment)?
Would that be safe?

In any case, if we can't prove whether data is naturally aligned we can
always (1) avoid peeling, or (2) peel the loop but control the number of
iterations that it will execute using a runtime test (i.e. have it iterate
the entire loop-count if the data is not naturally aligned).
I hope however that we won't have to be that conservative anytime we have a
pointer with unknown alignment (cause this is usually what happens in real
world applications).

So, in short - when can we assume that pointer types have the minimum
alignment required by their underlying type?

thanks,

dorit