gcc/config/darwin-driver.c

   1 /* Additional functions for the GCC driver on Darwin native.
   2    Copyright (C) 2006-2022 Free Software Foundation, Inc.
   3    Contributed by Apple Computer Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "libiberty.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "opts.h"
  27 #include "diagnostic-core.h"
  28
  29 /* Validate a version string (either given on the command line or, perhaps
  30    as MACOSX_DEPLOYMENT_TARGET).
  31
  32    The specs %version-compare() function doesn't accept leading '0' on
  33    numbers so strip them out.  Do sanity checking here too.
  34
  35    Return:
  36      * original string means it was OK and we didn't want to change it.
  37      * new string means it was OK but we rewrote it to avoid possible format
  38      problems.
  39      * NULL means we didn't like what we saw.
  40 */
  41
  42 static const char *
  43 validate_macosx_version_min (const char *version_str)
  44 {
  45   size_t version_len;
  46   unsigned long major, minor = 0, tiny = 0;
  47   char *end;
  48   const char *old_version = version_str;
  49   bool need_rewrite = false;
  50
  51   version_len = strlen (version_str);
  52   if (version_len < 2) /* The minimum would be 11  */
  53     return NULL;
  54
  55   /* Version string must consist of digits and periods only.  */
  56   if (strspn (version_str, "0123456789.") != version_len)
  57     return NULL;
  58
  59   if (!ISDIGIT (version_str[0]) || !ISDIGIT (version_str[version_len - 1]))
  60     return NULL;
  61
  62   if (version_str[0] == '0')
  63     need_rewrite = true;
  64
  65   major = strtoul (version_str, &end, 10);
  66
  67   /* macOS 10, 11, and 12 are known. clang accepts up to 99.  */
  68   if (major < 10 || major > 99)
  69     return NULL;
  70
  71   /* Skip a separating period, if there's one.  */
  72   version_str = end + ((*end == '.') ? 1 : 0);
  73
  74   if (major > 10 && *end != '\0' && !ISDIGIT (version_str[0]))
  75      /* For macOS 11+, we allow just the major number, but if the minor is
  76         there it must be numeric.  */
  77     return NULL;
  78   else if (major > 10 && *end == '\0')
  79     /* We will rewrite 11 =>  11.0.0.  */
  80     need_rewrite = true;
  81   else if (major == 10 && (*end == '\0' || !ISDIGIT (version_str[0])))
  82     /* Otherwise, minor version components must be present and numeric.  */
  83     return NULL;
  84
  85   /* If we have one or more leading zeros on a component, then rewrite the
  86      version string.  */
  87   if (*end != '\0' && version_str[0] == '0' && version_str[1] != '\0'
  88       && version_str[1] != '.')
  89     need_rewrite = true;
  90
  91   minor = strtoul (version_str, &end, 10);
  92   version_str = end + ((*end == '.') ? 1 : 0);
  93   if (minor > 99)
  94     return NULL;
  95
  96   /* If 'tiny' is present it must be numeric.  */
  97   if (*end != '\0' && !ISDIGIT (version_str[0]))
  98     return NULL;
  99
 100   /* If we have one or more leading zeros on a component, then rewrite the
 101      version string.  */
 102   if (*end != '\0' && version_str[0] == '0'
 103       && version_str[1] != '\0')
 104     need_rewrite = true;
 105
 106   tiny = strtoul (version_str, &end, 10);
 107   if (tiny > 99)
 108     return NULL;
 109
 110   /* Version string must contain no more than three tokens.  */
 111   if (*end != '\0')
 112     return NULL;
 113
 114   if (need_rewrite)
 115     {
 116       char *new_version;
 117       asprintf (&new_version, "%2lu.%lu.%lu", major, minor, tiny);
 118       return new_version;
 119     }
 120
 121   return old_version;
 122 }
 123
 124 #ifndef CROSS_DIRECTORY_STRUCTURE
 125 #include <sys/sysctl.h>
 126 #include "xregex.h"
 127
 128 /* Determine the version of the running OS.
 129    We only look at the first two components (ignoring the patch one) and
 130    report NN.MM.0 where NN is currently either 10 or 11 and MM is the OS
 131    minor release number.
 132    If we can't parse what the kernel gives us, warn the user, and do nothing.  */
 133
 134 static char *
 135 darwin_find_version_from_kernel (void)
 136 {
 137   char osversion[32];
 138   size_t osversion_len = sizeof (osversion) - 1;
 139   static int osversion_name[2] = { CTL_KERN, KERN_OSRELEASE };
 140   int major_vers;
 141   char * version_p;
 142   char * new_flag;
 143
 144   if (sysctl (osversion_name, ARRAY_SIZE (osversion_name), osversion,
 145               &osversion_len, NULL, 0) == -1)
 146     {
 147       warning (0, "%<sysctl%> for %<kern.osversion%> failed: %m");
 148       return NULL;
 149     }
 150
 151   /* Try to parse the first two parts of the OS version number.  Warn
 152      user and return if it doesn't make sense.  */
 153   if (! ISDIGIT (osversion[0]))
 154     goto parse_failed;
 155   major_vers = osversion[0] - '0';
 156   version_p = osversion + 1;
 157   if (ISDIGIT (*version_p))
 158     major_vers = major_vers * 10 + (*version_p++ - '0');
 159   if (*version_p++ != '.')
 160     goto parse_failed;
 161
 162   /* Darwin20 sees a transition to macOS 11.  In this, it seems that the
 163      mapping to macOS minor version is now shifted to the kernel minor
 164      version - 1 (at least for the initial releases).  */
 165   if (major_vers >= 20)
 166     {
 167       int minor_vers = *version_p++ - '0';
 168       if (ISDIGIT (*version_p))
 169         minor_vers = minor_vers * 10 + (*version_p++ - '0');
 170       if (*version_p++ != '.')
 171         goto parse_failed;
 172       if (minor_vers > 0)
 173         minor_vers -= 1; /* Kernel 20.3 => macOS 11.2.  */
 174       /* It's not yet clear whether patch level will be considered.  */
 175       asprintf (&new_flag, "%d.%02d.00", major_vers - 9, minor_vers);
 176     }
 177   else if (major_vers - 4 <= 4)
 178     /* On 10.4 and earlier, the old linker is used which does not
 179        support three-component system versions.
 180        FIXME: we should not assume this - a newer linker could be used.  */
 181     asprintf (&new_flag, "10.%d", major_vers - 4);
 182   else
 183     /* Although the newer linker supports three-component system
 184        versions, there's no guarantee that the minor version component
 185        of the kernel and the system are the same. Apple's clang always
 186        uses 0 as the minor version: do the same.  */
 187     asprintf (&new_flag, "10.%d.0", major_vers - 4);
 188
 189   return new_flag;
 190
 191  parse_failed:
 192   warning (0, "could not understand %<kern.osversion%> %q.*s",
 193            (int) osversion_len, osversion);
 194   return NULL;
 195 }
 196 #endif
 197
 198 /* When running on a Darwin system and using that system's headers and
 199    libraries, default the -mmacosx-version-min flag to be the version
 200    of the system on which the compiler is running.
 201
 202    When building cross or native cross compilers, default to the OSX
 203    version of the target (as provided by the most specific target header
 204    included in tm.h).  This may be overidden by setting the flag explicitly
 205    (or by the MACOSX_DEPLOYMENT_TARGET environment).  */
 206
 207 static const char *
 208 darwin_default_min_version (void)
 209 {
 210   /* Try to retrieve the deployment target from the environment.  */
 211   const char *new_flag = getenv ("MACOSX_DEPLOYMENT_TARGET");
 212
 213   /* Apparently, an empty string for MACOSX_DEPLOYMENT_TARGET means
 214      "use the default".  Or, possibly "use 10.1".  We choose
 215      to ignore the environment variable, as if it was never set.  */
 216   if (new_flag == NULL || new_flag[0] == 0)
 217 #ifndef CROSS_DIRECTORY_STRUCTURE
 218     /* Try to find the version from the kernel, if we fail - we print a
 219        message and give up.  */
 220     new_flag = darwin_find_version_from_kernel ();
 221 #else
 222     /* For cross-compilers, default to a minimum version determined by
 223        the configuration. */
 224     new_flag = DEF_MIN_OSX_VERSION;
 225 #endif /* CROSS_DIRECTORY_STRUCTURE */
 226
 227   if (new_flag != NULL)
 228     {
 229       const char *checked = validate_macosx_version_min (new_flag);
 230       if (checked == NULL)
 231         {
 232           warning (0, "could not understand version %qs", new_flag);
 233           return NULL;
 234         }
 235       new_flag = xstrndup (checked, strlen (checked));
 236     }
 237   return new_flag;
 238 }
 239
 240 /* See if we can find the sysroot from the SDKROOT environment variable.  */
 241
 242 static const char *
 243 maybe_get_sysroot_from_sdkroot ()
 244 {
 245   const char *maybe_sysroot = getenv ("SDKROOT");
 246
 247   /* We'll use the same rules as the clang driver, for compatibility.
 248      1) The path must be absolute
 249      2) Ignore "/", that is the default anyway and we do not want the
 250         sysroot semantics to be applied to it.
 251      3) It must exist (actually, we'll check it's readable too).  */
 252
 253    if (maybe_sysroot  == NULL
 254        || *maybe_sysroot != '/'
 255        || strlen (maybe_sysroot) == 1
 256        || access (maybe_sysroot, R_OK) == -1)
 257     return NULL;
 258
 259   return xstrndup (maybe_sysroot, strlen (maybe_sysroot));
 260 }
 261
 262 /* Handle the deduction of m32/m64 from -arch flags and the interactions
 263    between them (i.e. try to warn a user who thinks that they have a driver
 264    that can produce multi-slice "FAT" outputs with more than one arch).
 265    Default the -mmacosx-version-min flag, which requires a system call on
 266    native hosts.  */
 267
 268 void
 269 darwin_driver_init (unsigned int *decoded_options_count,
 270                     struct cl_decoded_option **decoded_options)
 271 {
 272   unsigned int i;
 273   bool seenX86 = false;
 274   bool seenX86_64 = false;
 275   bool seenPPC = false;
 276   bool seenPPC64 = false;
 277   bool seenM32 = false;
 278   bool seenM64 = false;
 279   bool appendM32 = false;
 280   bool appendM64 = false;
 281   const char *vers_string = NULL;
 282   bool seen_version_min = false;
 283   bool seen_sysroot_p = false;
 284   bool noexport_p = true;
 285
 286   for (i = 1; i < *decoded_options_count; i++)
 287     {
 288       if ((*decoded_options)[i].errors & CL_ERR_MISSING_ARG)
 289         continue;
 290
 291       switch ((*decoded_options)[i].opt_index)
 292         {
 293         case OPT_arch:
 294           /* Support provision of a single -arch xxxx flag as a means of
 295              specifying the sub-target/multi-lib.  Translate this into -m32/64
 296              as appropriate.  */
 297           if (!strcmp ((*decoded_options)[i].arg, "i386"))
 298             seenX86 = true;
 299           else if (!strcmp ((*decoded_options)[i].arg, "x86_64"))
 300             seenX86_64 = true;
 301           else if (!strcmp ((*decoded_options)[i].arg, "ppc"))
 302             seenPPC = true;
 303           else if (!strcmp ((*decoded_options)[i].arg, "ppc64"))
 304             seenPPC64 = true;
 305           else
 306             error ("this compiler does not support %qs",
 307                    (*decoded_options)[i].arg);
 308           /* Now we've examined it, drop the -arch arg.  */
 309           if (*decoded_options_count > i) {
 310             memmove (*decoded_options + i,
 311                      *decoded_options + i + 1,
 312                      ((*decoded_options_count - i - 1)
 313                       * sizeof (struct cl_decoded_option)));
 314           }
 315           --i;
 316           --*decoded_options_count;
 317           break;
 318
 319         case OPT_m32:
 320           seenM32 = true;
 321           break;
 322
 323         case OPT_m64:
 324           seenM64 = true;
 325           break;
 326
 327         case OPT_mmacosx_version_min_:
 328           seen_version_min = true;
 329           vers_string =
 330             validate_macosx_version_min ((*decoded_options)[i].arg);
 331           if (vers_string == NULL)
 332             warning (0, "%qs is not valid for %<-mmacosx-version-min%>",
 333                      (*decoded_options)[i].arg);
 334           else if (vers_string == (*decoded_options)[i].arg)
 335             vers_string = xstrndup ((*decoded_options)[i].arg, 32);
 336           /* Now we've examined it, and verified/re-written, put it to
 337              one side and append later.  */
 338           if (*decoded_options_count > i) {
 339             memmove (*decoded_options + i,
 340                      *decoded_options + i + 1,
 341                      ((*decoded_options_count - i - 1)
 342                       * sizeof (struct cl_decoded_option)));
 343           }
 344           --i;
 345           --*decoded_options_count;
 346           break;
 347
 348         case OPT__sysroot_:
 349         case OPT_isysroot:
 350           seen_sysroot_p = true;
 351           break;
 352
 353         case OPT_Xlinker:
 354         case OPT_Wl_:
 355           gcc_checking_assert ((*decoded_options)[i].arg);
 356           if (startswith ((*decoded_options)[i].arg, "-exported_symbol"))
 357             noexport_p = false;
 358           break;
 359
 360         default:
 361           break;
 362         }
 363     }
 364
 365   /* Turn -arch xxxx into the appropriate -m32/-m64 flag.
 366      If the User tried to specify multiple arch flags (which is possible with
 367      some Darwin compilers) warn that this mode is not supported by this
 368      compiler.  We take arch specifiers that agree with the default multilib
 369      as the first choice and reject others.  */
 370   /* TODO: determine if these warnings would better be errors.  */
 371 #if DARWIN_X86
 372   if (seenPPC || seenPPC64)
 373     warning (0, "this compiler does not support PowerPC"
 374                 " (%<-arch%> option ignored)");
 375   if (seenX86)
 376     {
 377       if (seenX86_64 || seenM64)
 378         {
 379           const char *op = (seenX86_64? "-arch x86_64": "-m64");
 380           warning (0, "%qs conflicts with %<-arch i386%> (%qs ignored)",
 381                    op, op);
 382         }
 383       if (! seenM32) /* Add -m32 if the User didn't. */
 384         appendM32 = true;
 385     }
 386   else if (seenX86_64)
 387     {
 388       if (seenM32)
 389         warning (0, "%<-m32%> conflicts with %<-arch x86_64%>"
 390                     " (%<-m32%> ignored)");
 391       if (! seenM64) /* Add -m64 if the User didn't. */
 392         appendM64 = true;
 393     }
 394 #elif DARWIN_PPC
 395   if (seenX86 || seenX86_64)
 396     warning (0, "this compiler does not support x86"
 397                 " (%<-arch%> option ignored)");
 398   if (seenPPC)
 399     {
 400       if (seenPPC64 || seenM64)
 401         {
 402           const char *op = (seenPPC64? "-arch ppc64": "-m64");
 403           warning (0, "%qs conflicts with %<-arch ppc%> (%qs ignored)",
 404                    op, op);
 405         }
 406       if (! seenM32) /* Add -m32 if the User didn't. */
 407         appendM32 = true;
 408     }
 409   else if (seenPPC64)
 410     {
 411       if (seenM32)
 412         warning (0, "%<-m32%> conflicts with %<-arch ppc64%>"
 413                     " (%<-m32%> ignored)");
 414       if (! seenM64) /* Add -m64 if the User didn't. */
 415         appendM64 = true;
 416     }
 417 #endif
 418
 419   /* If there is nothing else on the command line, do not add sysroot etc.  */
 420   if (*decoded_options_count <= 1)
 421     return;
 422
 423   if (appendM32 || appendM64)
 424     {
 425       ++*decoded_options_count;
 426       *decoded_options = XRESIZEVEC (struct cl_decoded_option,
 427                                      *decoded_options,
 428                                      *decoded_options_count);
 429       generate_option (appendM32 ? OPT_m32 : OPT_m64, NULL, 1, CL_DRIVER,
 430                        &(*decoded_options)[*decoded_options_count - 1]);
 431     }
 432
 433   if (!seen_sysroot_p)
 434     {
 435       /* We will pick up an SDKROOT if we didn't specify a sysroot and treat
 436          it as overriding any configure-time --with-sysroot.  */
 437        const char *sdkroot = maybe_get_sysroot_from_sdkroot ();
 438        if (sdkroot)
 439         {
 440           ++*decoded_options_count;
 441           *decoded_options = XRESIZEVEC (struct cl_decoded_option,
 442                                          *decoded_options,
 443                                          *decoded_options_count);
 444           generate_option (OPT__sysroot_, sdkroot, 1, CL_DRIVER,
 445                            &(*decoded_options)[*decoded_options_count - 1]);
 446         }
 447     }
 448
 449   /* We will need to know the OS X version we're trying to build for here
 450      so that we can figure out the mechanism and source for the sysroot to
 451      be used.  */
 452   if (!seen_version_min)
 453     /* Not set by the User, try to figure it out.  */
 454     vers_string = darwin_default_min_version ();
 455
 456   /* Create and push a cleaned up version, plus the major version for
 457      assemblers and other cases that need it.  */
 458   if (vers_string != NULL)
 459     {
 460        ++*decoded_options_count;
 461        *decoded_options = XRESIZEVEC (struct cl_decoded_option,
 462                                       *decoded_options,
 463                                       *decoded_options_count);
 464       generate_option (OPT_mmacosx_version_min_, vers_string, 1, CL_DRIVER,
 465                        &(*decoded_options)[*decoded_options_count - 1]);
 466
 467       char *asm_major = NULL;
 468       const char *first_period = strchr(vers_string, '.');
 469       if (first_period != NULL)
 470         {
 471           const char *second_period = strchr(first_period+1, '.');
 472           if (second_period  != NULL)
 473             asm_major = xstrndup (vers_string, second_period-vers_string);
 474           else
 475             asm_major = xstrdup (vers_string);
 476         }
 477       /* Else we appear to have a weird macosx version with no major number.
 478          Punt on this for now.  */
 479       if (asm_major != NULL)
 480         {
 481           ++*decoded_options_count;
 482           *decoded_options = XRESIZEVEC (struct cl_decoded_option,
 483                                          *decoded_options,
 484                                          *decoded_options_count);
 485           generate_option (OPT_asm_macosx_version_min_, asm_major, 1, CL_DRIVER,
 486                           &(*decoded_options)[*decoded_options_count - 1]);
 487         }
 488     }
 489
 490   if (noexport_p)
 491     {
 492       ++*decoded_options_count;
 493       *decoded_options = XRESIZEVEC (struct cl_decoded_option,
 494                                      *decoded_options,
 495                                      *decoded_options_count);
 496       generate_option (OPT_nodefaultexport, NULL, 1, CL_DRIVER,
 497                        &(*decoded_options)[*decoded_options_count - 1]);
 498     }
 499 }