IBM Z: Handle unaligned symbols

The IBM Z ELF ABI mandates every symbol to reside on a 2 byte boundary
in order to be able to use the larl instruction. However, in some
situations it is difficult to enforce this, e.g. for common linker
scripts as used in the Linux kernel. This patch introduces the
-munaligned-symbols option. When that option is used, external symbols
without an explicit alignment are considered unaligned and its address
will be pushed into GOT or the literal pool.

If the symbol in the final linker step turns out end up on a 2 byte
boundary the linker is able to take this back and replace the indirect
reference with larl again. This should minimize the effect to symbols
which are actually unaligned in the end.

gcc/ChangeLog:

	* config/s390/s390.cc (s390_encode_section_info): Assume external
	symbols without explicit alignment to be unaligned if
	-munaligned-symbols has been specified.
	* config/s390/s390.opt (-munaligned-symbols): New option.

gcc/testsuite/ChangeLog:

	* gcc.target/s390/aligned-1.c: New test.
	* gcc.target/s390/unaligned-1.c: New test.

diff --git a/gcc/config/s390/s390.cc b/gcc/config/s390/s390.cc
index 13970edcb5e7d25edba06312a0b8d0428f46e147..89474fd487a5ec68863037fc499e9603b0d4e974 100644 (file)
--- a/gcc/config/s390/s390.cc
+++ b/gcc/config/s390/s390.cc
@@ -13709,8 +13709,13 @@ s390_encode_section_info (tree decl, rtx rtl, int first)
         a larl/load-relative instruction.  We only handle the cases
         that can go wrong (i.e. no FUNC_DECLs).
         All symbols without an explicit alignment are assumed to be 2
-        byte aligned as mandated by our ABI.  */
-      if (DECL_USER_ALIGN (decl) && DECL_ALIGN (decl) % 16)
+        byte aligned as mandated by our ABI.  This behavior can be
+        overridden for external symbols with the -munaligned-symbols
+        switch.  */
+      if (DECL_ALIGN (decl) % 16
+         && (DECL_USER_ALIGN (decl)
+             || (!SYMBOL_REF_LOCAL_P (XEXP (rtl, 0))
+                 && s390_unaligned_symbols_p)))
        SYMBOL_FLAG_SET_NOTALIGN2 (XEXP (rtl, 0));
       else if (DECL_ALIGN (decl) % 32)
        SYMBOL_FLAG_SET_NOTALIGN4 (XEXP (rtl, 0));

diff --git a/gcc/config/s390/s390.opt b/gcc/config/s390/s390.opt
index 344aa551f442e7bf4741a09e78651a431b8f247d..496572046f77f1b28e825d18f1421e5ef182ad7b 100644 (file)
--- a/gcc/config/s390/s390.opt
+++ b/gcc/config/s390/s390.opt
@@ -329,3 +329,10 @@ Target Undocumented Var(unroll_only_small_loops) Init(0) Save
 mpreserve-args
 Target Var(s390_preserve_args_p) Init(0)
 Store all argument registers on the stack.
+
+munaligned-symbols
+Target Var(s390_unaligned_symbols_p) Init(0)
+Assume external symbols to be potentially unaligned.  By default all
+symbols without explicit alignment are assumed to reside on a 2 byte
+boundary as mandated by the IBM Z ABI.
+

diff --git a/gcc/testsuite/gcc.target/s390/aligned-1.c b/gcc/testsuite/gcc.target/s390/aligned-1.c
new file mode 100644 (file)
index 0000000..2dc99cf
--- /dev/null
+++ b/gcc/testsuite/gcc.target/s390/aligned-1.c
@@ -0,0 +1,20 @@
+/* Even symbols without explicite alignment are assumed to reside on a
+   2 byte boundary, as mandated by the IBM Z ELF ABI, and therefore
+   can be accessed using the larl instruction.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O3 -march=z900 -fno-section-anchors" } */
+
+extern unsigned char extern_implicitly_aligned;
+extern unsigned char extern_explicitly_aligned __attribute__((aligned(2)));
+unsigned char aligned;
+
+unsigned char
+foo ()
+{
+  return extern_implicitly_aligned + extern_explicitly_aligned + aligned;
+}
+
+/* { dg-final { scan-assembler-times "larl\t%r\[0-9\]*,extern_implicitly_aligned\n" 1 } } */
+/* { dg-final { scan-assembler-times "larl\t%r\[0-9\]*,extern_explicitly_aligned\n" 1 } } */
+/* { dg-final { scan-assembler-times "larl\t%r\[0-9\]*,aligned\n" 1 } } */

diff --git a/gcc/testsuite/gcc.target/s390/unaligned-1.c b/gcc/testsuite/gcc.target/s390/unaligned-1.c
new file mode 100644 (file)
index 0000000..421330a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/s390/unaligned-1.c
@@ -0,0 +1,20 @@
+/* With the -munaligned-symbols option all external symbols without
+   explicite alignment are assumed to be potentially unaligned and
+   therefore cannot be accessed with larl.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O3 -march=z900 -fno-section-anchors -munaligned-symbols" } */
+
+extern unsigned char extern_unaligned;
+extern unsigned char extern_explicitly_aligned __attribute__((aligned(2)));
+unsigned char aligned;
+
+unsigned char
+foo ()
+{
+  return extern_unaligned + extern_explicitly_aligned + aligned;
+}
+
+/* { dg-final { scan-assembler-times "larl\t%r\[0-9\]*,extern_unaligned\n" 0 } } */
+/* { dg-final { scan-assembler-times "larl\t%r\[0-9\]*,extern_explicitly_aligned\n" 1 } } */
+/* { dg-final { scan-assembler-times "larl\t%r\[0-9\]*,aligned\n" 1 } } */