Revise -mdisable-fpregs option and add new -msoft-mult option

[official-gcc.git] / gcc / config / darwin-driver.c

/* Additional functions for the GCC driver on Darwin native.
   Copyright (C) 2006-2021 Free Software Foundation, Inc.
   Contributed by Apple Computer Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

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/>.  */

#include "config.h"
#include "libiberty.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "opts.h"
#include "diagnostic-core.h"

/* Validate a version string (either given on the command line or, perhaps
   as MACOSX_DEPLOYMENT_TARGET).

   The specs %version-compare() function doesn't accept leading '0' on
   numbers so strip them out.  Do sanity checking here too.

   Return:
     * original string means it was OK and we didn't want to change it.
     * new string means it was OK but we rewrote it to avoid possible format
     problems.
     * NULL means we didn't like what we saw.
*/

static const char *
validate_macosx_version_min (const char *version_str)
{
  size_t version_len;
  unsigned long major, minor = 0, tiny = 0;
  char *end;
  const char *old_version = version_str;
  bool need_rewrite = false;

  version_len = strlen (version_str);
  if (version_len < 2) /* The minimum would be 11  */
    return NULL;

  /* Version string must consist of digits and periods only.  */
  if (strspn (version_str, "0123456789.") != version_len)
    return NULL;

  if (!ISDIGIT (version_str[0]) || !ISDIGIT (version_str[version_len - 1]))
    return NULL;

  if (version_str[0] == '0')
    need_rewrite = true;

  major = strtoul (version_str, &end, 10);

  if (major < 10 || major > 11 ) /* MacOS 10 and 11 are known. */
    return NULL;

  /* Skip a separating period, if there's one.  */
  version_str = end + ((*end == '.') ? 1 : 0);

  if (major == 11 && *end != '\0' && !ISDIGIT (version_str[0]))
     /* For MacOS 11, we allow just the major number, but if the minor is
        there it must be numeric.  */
    return NULL;
  else if (major == 11 && *end == '\0')
    /* We will rewrite 11 =>  11.0.0.  */
    need_rewrite = true;
  else if (major == 10 && (*end == '\0' || !ISDIGIT (version_str[0])))
    /* Otherwise, minor version components must be present and numeric.  */
    return NULL;

  /* If we have one or more leading zeros on a component, then rewrite the
     version string.  */
  if (*end != '\0' && version_str[0] == '0' && version_str[1] != '\0'
      && version_str[1] != '.')
    need_rewrite = true;

  minor = strtoul (version_str, &end, 10);
  version_str = end + ((*end == '.') ? 1 : 0);
  if (minor > 99)
    return NULL;

  /* If 'tiny' is present it must be numeric.  */
  if (*end != '\0' && !ISDIGIT (version_str[0]))
    return NULL;

  /* If we have one or more leading zeros on a component, then rewrite the
     version string.  */
  if (*end != '\0' && version_str[0] == '0'
      && version_str[1] != '\0')
    need_rewrite = true;

  tiny = strtoul (version_str, &end, 10);
  if (tiny > 99)
    return NULL;

  /* Version string must contain no more than three tokens.  */
  if (*end != '\0')
    return NULL;

  if (need_rewrite)
    {
      char *new_version;
      asprintf (&new_version, "%2lu.%lu.%lu", major, minor, tiny);
      return new_version;
    }

  return old_version;
}

#ifndef CROSS_DIRECTORY_STRUCTURE
#include <sys/sysctl.h>
#include "xregex.h"

/* Determine the version of the running OS.
   We only look at the first two components (ignoring the patch one) and
   report NN.MM.0 where NN is currently either 10 or 11 and MM is the OS
   minor release number.
   If we can't parse what the kernel gives us, warn the user, and do nothing.  */

static char *
darwin_find_version_from_kernel (void)
{
  char osversion[32];
  size_t osversion_len = sizeof (osversion) - 1;
  static int osversion_name[2] = { CTL_KERN, KERN_OSRELEASE };
  int major_vers;
  char * version_p;
  char * new_flag;

  if (sysctl (osversion_name, ARRAY_SIZE (osversion_name), osversion,
              &osversion_len, NULL, 0) == -1)
    {
      warning (0, "%<sysctl%> for %<kern.osversion%> failed: %m");
      return NULL;
    }

  /* Try to parse the first two parts of the OS version number.  Warn
     user and return if it doesn't make sense.  */
  if (! ISDIGIT (osversion[0]))
    goto parse_failed;
  major_vers = osversion[0] - '0';
  version_p = osversion + 1;
  if (ISDIGIT (*version_p))
    major_vers = major_vers * 10 + (*version_p++ - '0');
  if (*version_p++ != '.')
    goto parse_failed;

  /* Darwin20 sees a transition to macOS 11.  In this, it seems that the
     mapping to macOS minor version is now shifted to the kernel minor
     version - 1 (at least for the initial releases).  At this stage, we
     don't know what macOS version will correspond to Darwin21.  */
  if (major_vers >= 20)
    {
      int minor_vers = *version_p++ - '0';
      if (ISDIGIT (*version_p))
        minor_vers = minor_vers * 10 + (*version_p++ - '0');
      if (*version_p++ != '.')
        goto parse_failed;
      if (minor_vers > 0)
        minor_vers -= 1; /* Kernel 20.3 => macOS 11.2.  */
      /* It's not yet clear whether patch level will be considered.  */
      asprintf (&new_flag, "11.%02d.00", minor_vers);
    }
  else if (major_vers - 4 <= 4)
    /* On 10.4 and earlier, the old linker is used which does not
       support three-component system versions.
       FIXME: we should not assume this - a newer linker could be used.  */
    asprintf (&new_flag, "10.%d", major_vers - 4);
  else
    /* Although the newer linker supports three-component system
       versions, there's no guarantee that the minor version component
       of the kernel and the system are the same. Apple's clang always
       uses 0 as the minor version: do the same.  */
    asprintf (&new_flag, "10.%d.0", major_vers - 4);

  return new_flag;

 parse_failed:
  warning (0, "could not understand %<kern.osversion%> %q.*s",
           (int) osversion_len, osversion);
  return NULL;
}
#endif

/* When running on a Darwin system and using that system's headers and
   libraries, default the -mmacosx-version-min flag to be the version
   of the system on which the compiler is running.  
   
   When building cross or native cross compilers, default to the OSX
   version of the target (as provided by the most specific target header
   included in tm.h).  This may be overidden by setting the flag explicitly
   (or by the MACOSX_DEPLOYMENT_TARGET environment).  */

static const char *
darwin_default_min_version (void)
{
  /* Try to retrieve the deployment target from the environment.  */
  const char *new_flag = getenv ("MACOSX_DEPLOYMENT_TARGET");

  /* Apparently, an empty string for MACOSX_DEPLOYMENT_TARGET means
     "use the default".  Or, possibly "use 10.1".  We choose
     to ignore the environment variable, as if it was never set.  */
  if (new_flag == NULL || new_flag[0] == 0)
#ifndef CROSS_DIRECTORY_STRUCTURE
    /* Try to find the version from the kernel, if we fail - we print a
       message and give up.  */
    new_flag = darwin_find_version_from_kernel ();
#else
    /* For cross-compilers, default to a minimum version determined by
       the configuration. */
    new_flag = DEF_MIN_OSX_VERSION;
#endif /* CROSS_DIRECTORY_STRUCTURE */

  if (new_flag != NULL)
    {
      const char *checked = validate_macosx_version_min (new_flag);
      if (checked == NULL)
        {
          warning (0, "could not understand version %qs", new_flag);
          return NULL;
        }
      new_flag = xstrndup (checked, strlen (checked));
    }
  return new_flag;
}

/* See if we can find the sysroot from the SDKROOT environment variable.  */

static const char *
maybe_get_sysroot_from_sdkroot ()
{
  const char *maybe_sysroot = getenv ("SDKROOT");

  /* We'll use the same rules as the clang driver, for compatibility.
     1) The path must be absolute
     2) Ignore "/", that is the default anyway and we do not want the
        sysroot semantics to be applied to it.
     3) It must exist (actually, we'll check it's readable too).  */

   if (maybe_sysroot  == NULL
       || *maybe_sysroot != '/'
       || strlen (maybe_sysroot) == 1
       || access (maybe_sysroot, R_OK) == -1)
    return NULL;

  return xstrndup (maybe_sysroot, strlen (maybe_sysroot));
}

/* Handle the deduction of m32/m64 from -arch flags and the interactions
   between them (i.e. try to warn a user who thinks that they have a driver
   that can produce multi-slice "FAT" outputs with more than one arch).
   Default the -mmacosx-version-min flag, which requires a system call on
   native hosts.  */

void
darwin_driver_init (unsigned int *decoded_options_count,
                    struct cl_decoded_option **decoded_options)
{
  unsigned int i;
  bool seenX86 = false;
  bool seenX86_64 = false;
  bool seenPPC = false;
  bool seenPPC64 = false;
  bool seenM32 = false;
  bool seenM64 = false;
  bool appendM32 = false;
  bool appendM64 = false;
  const char *vers_string = NULL;
  bool seen_version_min = false;
  bool seen_sysroot_p = false;

  for (i = 1; i < *decoded_options_count; i++)
    {
      if ((*decoded_options)[i].errors & CL_ERR_MISSING_ARG)
        continue;

      switch ((*decoded_options)[i].opt_index)
        {
        case OPT_arch:
          /* Support provision of a single -arch xxxx flag as a means of
             specifying the sub-target/multi-lib.  Translate this into -m32/64
             as appropriate.  */  
          if (!strcmp ((*decoded_options)[i].arg, "i386"))
            seenX86 = true;
          else if (!strcmp ((*decoded_options)[i].arg, "x86_64"))
            seenX86_64 = true;
          else if (!strcmp ((*decoded_options)[i].arg, "ppc"))
            seenPPC = true;
          else if (!strcmp ((*decoded_options)[i].arg, "ppc64"))
            seenPPC64 = true;
          else
            error ("this compiler does not support %qs",
                   (*decoded_options)[i].arg);
          /* Now we've examined it, drop the -arch arg.  */
          if (*decoded_options_count > i) {
            memmove (*decoded_options + i,
                     *decoded_options + i + 1,
                     ((*decoded_options_count - i - 1)
                      * sizeof (struct cl_decoded_option)));
          }
          --i;
          --*decoded_options_count; 
          break;

        case OPT_m32:
          seenM32 = true;
          break;

        case OPT_m64:
          seenM64 = true;
          break;

        case OPT_mmacosx_version_min_:
          seen_version_min = true;
          vers_string =
            validate_macosx_version_min ((*decoded_options)[i].arg);
          if (vers_string == NULL)
            warning (0, "%qs is not valid for %<-mmacosx-version-min%>",
                     (*decoded_options)[i].arg);
          else if (vers_string == (*decoded_options)[i].arg)
            vers_string = xstrndup ((*decoded_options)[i].arg, 32);
          /* Now we've examined it, and verified/re-written, put it to
             one side and append later.  */
          if (*decoded_options_count > i) {
            memmove (*decoded_options + i,
                     *decoded_options + i + 1,
                     ((*decoded_options_count - i - 1)
                      * sizeof (struct cl_decoded_option)));
          }
          --i;
          --*decoded_options_count;
          break;

        case OPT__sysroot_:
        case OPT_isysroot:
          seen_sysroot_p = true;
          break;

        default:
          break;
        }
    }

  /* Turn -arch xxxx into the appropriate -m32/-m64 flag.
     If the User tried to specify multiple arch flags (which is possible with
     some Darwin compilers) warn that this mode is not supported by this
     compiler.  We take arch specifiers that agree with the default multilib
     as the first choice and reject others.  */
  /* TODO: determine if these warnings would better be errors.  */
#if DARWIN_X86
  if (seenPPC || seenPPC64)
    warning (0, "this compiler does not support PowerPC"
                " (%<-arch%> option ignored)");
  if (seenX86)
    {
      if (seenX86_64 || seenM64)
        {
          const char *op = (seenX86_64? "-arch x86_64": "-m64");
          warning (0, "%qs conflicts with %<-arch i386%> (%qs ignored)",
                   op, op);
        }
      if (! seenM32) /* Add -m32 if the User didn't. */
        appendM32 = true;
    }
  else if (seenX86_64)
    {
      if (seenM32)
        warning (0, "%<-m32%> conflicts with %<-arch x86_64%>"
                    " (%<-m32%> ignored)");
      if (! seenM64) /* Add -m64 if the User didn't. */
        appendM64 = true;
    }  
#elif DARWIN_PPC
  if (seenX86 || seenX86_64)
    warning (0, "this compiler does not support x86"
                " (%<-arch%> option ignored)");
  if (seenPPC)
    {
      if (seenPPC64 || seenM64)
        {
          const char *op = (seenPPC64? "-arch ppc64": "-m64");
          warning (0, "%qs conflicts with %<-arch ppc%> (%qs ignored)",
                   op, op);
        }
      if (! seenM32) /* Add -m32 if the User didn't. */
        appendM32 = true;
    }
  else if (seenPPC64)
    {
      if (seenM32)
        warning (0, "%<-m32%> conflicts with %<-arch ppc64%>"
                    " (%<-m32%> ignored)");
      if (! seenM64) /* Add -m64 if the User didn't. */
        appendM64 = true;
    }
#endif

  if (appendM32 || appendM64)
    {
      ++*decoded_options_count;
      *decoded_options = XRESIZEVEC (struct cl_decoded_option,
                                     *decoded_options,
                                     *decoded_options_count);
      generate_option (appendM32 ? OPT_m32 : OPT_m64, NULL, 1, CL_DRIVER,
                       &(*decoded_options)[*decoded_options_count - 1]);
    }

  if (! seen_sysroot_p)
    {
      /* We will pick up an SDKROOT if we didn't specify a sysroot and treat
         it as overriding any configure-time --with-sysroot.  */
       const char *sdkroot = maybe_get_sysroot_from_sdkroot ();
       if (sdkroot)
        {
          ++*decoded_options_count;
          *decoded_options = XRESIZEVEC (struct cl_decoded_option,
                                         *decoded_options,
                                         *decoded_options_count);
          generate_option (OPT__sysroot_, sdkroot, 1, CL_DRIVER,
                           &(*decoded_options)[*decoded_options_count - 1]);
        }
    }

  /* We will need to know the OS X version we're trying to build for here
     so that we can figure out the mechanism and source for the sysroot to
     be used.  */
  if (! seen_version_min && *decoded_options_count > 1)
    /* Not set by the User, try to figure it out.  */
    vers_string = darwin_default_min_version ();

  /* Create and push a cleaned up version, plus the major version for
     assemblers and other cases that need it.  */
  if (vers_string != NULL)
    {
       ++*decoded_options_count;
       *decoded_options = XRESIZEVEC (struct cl_decoded_option,
                                      *decoded_options,
                                      *decoded_options_count);
      generate_option (OPT_mmacosx_version_min_, vers_string, 1, CL_DRIVER,
                       &(*decoded_options)[*decoded_options_count - 1]);

      char *asm_major = NULL;
      const char *first_period = strchr(vers_string, '.');
      if (first_period != NULL)
        {
          const char *second_period = strchr(first_period+1, '.');
          if (second_period  != NULL)
            asm_major = xstrndup (vers_string, second_period-vers_string);
          else
            asm_major = xstrdup (vers_string);
        }
      /* Else we appear to have a weird macosx version with no major number.
         Punt on this for now.  */
      if (asm_major != NULL)
        {
          ++*decoded_options_count;
          *decoded_options = XRESIZEVEC (struct cl_decoded_option,
                                         *decoded_options,
                                         *decoded_options_count);
          generate_option (OPT_asm_macosx_version_min_, asm_major, 1, CL_DRIVER,
                          &(*decoded_options)[*decoded_options_count - 1]);
        }
    }
}