i386: Cleanup i386/i386elf.h and align it's return convention with the SVR4 ABI

While i386elf.h was originally derived from sysv4.h it has not been kept
up to date with the development of the compiler. Two changes are made:

* The return convention now follows the i386 and x86_64 SVR4 ABIs again.

* The more efficient default version of ASM_OUTPUT_ASCII in elfos.h is used.

2020-11-04  Pat Bernardi  <bernardi@adacore.com>

gcc/ChangeLog

	* config/i386/i386elf.h (SUBTARGET_RETURN_IN_MEMORY): Remove.
	(ASM_OUTPUT_ASCII): Likewise.
	(DEFAULT_PCC_STRUCT_RETURN): Define.
	* config/i386/i386.c (ix86_return_in_memory): Remove
	SUBTARGET_RETURN_IN_MEMORY.

diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index ddd1c71..6fc6228 100644 (file)
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -4092,9 +4092,6 @@ ix86_libcall_value (machine_mode mode)
 static bool
 ix86_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
 {
-#ifdef SUBTARGET_RETURN_IN_MEMORY
-  return SUBTARGET_RETURN_IN_MEMORY (type, fntype);
-#else
   const machine_mode mode = type_natural_mode (type, NULL, true);
   HOST_WIDE_INT size;
 
@@ -4175,7 +4172,6 @@ ix86_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
 
       return false;
     }
-#endif
 }
 
 \f

diff --git a/gcc/config/i386/i386elf.h b/gcc/config/i386/i386elf.h
index eb2203c..05cee89 100644 (file)
--- a/gcc/config/i386/i386elf.h
+++ b/gcc/config/i386/i386elf.h
@@ -19,12 +19,12 @@ You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 
-/* The ELF ABI for the i386 says that records and unions are returned
-   in memory.  */
-
-#define SUBTARGET_RETURN_IN_MEMORY(TYPE, FNTYPE) \
-       (TYPE_MODE (TYPE) == BLKmode \
-        || (VECTOR_MODE_P (TYPE_MODE (TYPE)) && int_size_in_bytes (TYPE) == 8))
+/* Define DEFAULT_PCC_STRUCT_RETURN to 1 because the i386 SVR4 ABI returns
+   records and unions in memory. ix86_option_override_internal will overide
+   this flag when compiling 64-bit code as we never do pcc_struct_return
+   scheme on x86-64.  */
+#undef DEFAULT_PCC_STRUCT_RETURN
+#define DEFAULT_PCC_STRUCT_RETURN 1
 
 #undef CPP_SPEC
 #define CPP_SPEC ""
@@ -40,56 +40,6 @@ along with GCC; see the file COPYING3.  If not see
 #define DBX_REGISTER_NUMBER(n) \
   (TARGET_64BIT ? dbx64_register_map[n] : svr4_dbx_register_map[n])
 
-/* The routine used to output sequences of byte values.  We use a special
-   version of this for most svr4 targets because doing so makes the
-   generated assembly code more compact (and thus faster to assemble)
-   as well as more readable.  Note that if we find subparts of the
-   character sequence which end with NUL (and which are shorter than
-   ELF_STRING_LIMIT) we output those using ASM_OUTPUT_LIMITED_STRING.  */
-
-#undef ASM_OUTPUT_ASCII
-#define ASM_OUTPUT_ASCII(FILE, STR, LENGTH)                            \
-  do                                                                   \
-    {                                                                  \
-      const unsigned char *_ascii_bytes =                              \
-        (const unsigned char *) (STR);                                 \
-      const unsigned char *limit = _ascii_bytes + (LENGTH);            \
-      unsigned bytes_in_chunk = 0;                                     \
-      for (; _ascii_bytes < limit; _ascii_bytes++)                     \
-       {                                                               \
-         const unsigned char *p;                                       \
-         if (bytes_in_chunk >= 64)                                     \
-           {                                                           \
-             fputc ('\n', (FILE));                                     \
-             bytes_in_chunk = 0;                                       \
-           }                                                           \
-         for (p = _ascii_bytes; p < limit && *p != '\0'; p++)          \
-           continue;                                                   \
-         if (p < limit && (p - _ascii_bytes) <= (long) ELF_STRING_LIMIT) \
-           {                                                           \
-             if (bytes_in_chunk > 0)                                   \
-               {                                                       \
-                 fputc ('\n', (FILE));                                 \
-                 bytes_in_chunk = 0;                                   \
-               }                                                       \
-             ASM_OUTPUT_LIMITED_STRING ((FILE), (const char *) _ascii_bytes); \
-             _ascii_bytes = p;                                         \
-           }                                                           \
-         else                                                          \
-           {                                                           \
-             if (bytes_in_chunk == 0)                                  \
-               fputs (ASM_BYTE, (FILE));                               \
-             else                                                      \
-               fputc (',', (FILE));                                    \
-             fprintf ((FILE), "0x%02x", *_ascii_bytes);                        \
-             bytes_in_chunk += 5;                                      \
-           }                                                           \
-       }                                                               \
-      if (bytes_in_chunk > 0)                                          \
-       fputc ('\n', (FILE));                                           \
-    }                                                                  \
-  while (0)
-
 #define LOCAL_LABEL_PREFIX     "."
 
 /* Switch into a generic section.  */