unaligned memory access support for ARMv7

enabled the support for unaligned memory access for ARMv7.
Previous ARM ISA implementations didn't support unaligned access, however ARMv7 ISA implementations made it mandatory to support so. In ARMv7 when SCTLR (system control register) has A=0, unaligned access is allowed for LDR, STR, LDRH, STRH instructions. 
SCTLT.A = 0 is also the default setting for ARMv7. 
Also, Linux and all modern Operating systems on ARMv7 always sets SCTLR.A = 0 to support unaligned access, so does many applications on ARMv7 assumes it and uses unaligned access. Hence, it is most efficient to turn on through the Macros defines in global.h, rather than using any kind of runtime detection, as done in this Issue for review.
Support has been added to enable unaligned access also in the ARM specific implementation of the regular expression engine.

[Erik Corry, 2010-04-28 09:07:58]

This is definitely a good idea.  It is unfortunate that we are duplicating the
ARMv7-detection code in more than one place, but I can't think of a good
solution right now.

http://codereview.chromium.org/1731013/diff/1/2
File src/globals.h (right):

http://codereview.chromium.org/1731013/diff/1/2#newcode54
src/globals.h:54: defined(__ARM_ARCH_7__)
You should probably add the CAN_USE_ARMV7_INSTRUCTIONS flag to this list.

http://codereview.chromium.org/1731013/diff/1/2#newcode87
src/globals.h:87: #if defined(__ARM_ARCH_7A__) || \
This won't work because __ARM_ARCH_7A__ and the others are defined by gcc, but
in this case the gcc is for the host architecture, ie it is an Intel gcc which
doesn't define these macros.  You need to use CAN_USE_ARMV7_INSTRUCTIONS which
is the way the build system signals to V8 that it will be running on an ARMv7. 
Then you need to change the simulator so that it doesn't complain about
unaligned accesses in this case.  That way we can allow the simulator (and
therefore the code in the snapshot, which is typically generated on the
simulator at the build stage) to use unaligned accesses.

[subratokde, 2010-04-30 00:49:57]

On 2010/04/28 09:07:58, Erik Corry wrote:

Thanks for the comments. I am making changes accordingly and testing them out
both for the actual ARMv7 hardware and for the simulator version (with the
unaligned check disabled when we assume the simulator is supporting ARMv7). Once
testing is done properly, I will upload the changes. 

Meanwhile some discussion:

It appears even if we define CAN_USE_ARMV7_INSTRUCTIONS in globals.h (and that
being used to define V8_TARGET_CAN_READ_UNALIGNED), it's not visible to the
simulator-arm.cc. For the arm simulator it's visible only through the
definitions in constants-arm.h

So I am also defining CAN_USE_ARMV7_INSTRUCTIONS and based on that defining the
macro V8_TARGET_CAN_READ_UNALIGNED for the simulator mode, i.e.,  #if
!defined(__arm__), in constants-arm.h, and use CAN_USE_ARMV7_INSTRUCTIONS to
bypass unaligned access checks in the simulator.

[subratokde, 2010-04-30 18:24:59]

On 2010/04/30 00:49:57, subratokde wrote:

Uploaded the recommended changes.

[Erik Corry, 2010-05-03 12:07:00]

In the light of Rodolpho's comments I think the best way forward for this change
is to make it a compile-time ifdef-controlled parameter.  eg
CAN_USE_UNALIGNED_ACCESSES.  The builder can then choose to set that flag in
their build process if they know the destination system allows unaligned
accesses.

[subratokde, 2010-05-04 06:22:44]

modified to use a build time flag CAN_USE_UNALIGNED_ACCESSES.
If -DCAN_USE_UNALIGNED_ACCESSES=1 then unaligned access is activated for ARM
backend both for the simulator build and for the actual target build that runs
on ARM hardware.

[Erik Corry, 2010-05-04 07:25:00]

LGTM with minor comments, below.

Does this change ensure that the code in objects.cc (string copy I think) also
takes advantage of unaligned accesses?

http://codereview.chromium.org/1731013/diff/24001/25004
File src/arm/simulator-arm.cc (right):

http://codereview.chromium.org/1731013/diff/24001/25004#newcode880
src/arm/simulator-arm.cc:880: // Linux and modern OS on ARMv7 enable unaligned
accesses,
This 3 line comment, repeated many times, doesn't really explain the situation
right.  I suggest this comment be removed (the #if speaks for itself) and
instead the comment above be edited to reflect the current situation on ARM (all
ARMv7 chips allow unaligned accesses, but not all operating systems allow it).

http://codereview.chromium.org/1731013/diff/24001/25001
File src/globals.h (right):

http://codereview.chromium.org/1731013/diff/24001/25001#newcode51
src/globals.h:51: // So it is safe to use unaligned access for ARMv7 backend in
v8
I suggest instead of this text:
"Some CPU-OS combinations allow unaligned access on ARM.  We
assume that unaligned accesses are not allowed unless the
build system defines the CAN_USE_UNALIGNED_ACCESSES macro to
be non-zero."

http://codereview.chromium.org/1731013/diff/24001/25001#newcode84
src/globals.h:84: // So it is safe to use unaligned access for ARMv7 backend in
v8
And here.

[subratokde, 2010-05-04 21:16:08]

Uploaded patch set 6 with the above recommended changes.

>> Does this change ensure that the code in objects.cc (string copy I think)
also takes advantage of unaligned accesses?

Yes. 

The CAN_USE_UNALIGNED_ACCESSES macro is also used to set
V8_HOST_CAN_READ_UNALIGNED in globals.h, which in turn enables unaligned
read/writes usage for:
(i) CopyChars & CompareChars in utils.h
(ii) CompareRawStringContents in objects.cc

The CopyChars() in (i) are in-turn used to implement String::WriteToFlat() in
objects.cc