gcc/go/gospec.c

   1 /* gospec.c -- Specific flags and argument handling of the gcc Go front end.
   2    Copyright (C) 2009-2018 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "tm.h"
  24 #include "opts.h"
  25
  26 /* This bit is set if we saw a `-xfoo' language specification.  */
  27 #define LANGSPEC        (1<<1)
  28 /* This bit is set if they did `-lm' or `-lmath'.  */
  29 #define MATHLIB         (1<<2)
  30 /* This bit is set if they did `-lpthread'.  */
  31 #define THREADLIB       (1<<3)
  32 /* This bit is set if they did `-lc'.  */
  33 #define WITHLIBC        (1<<4)
  34 /* Skip this option.  */
  35 #define SKIPOPT         (1<<5)
  36
  37 #ifndef MATH_LIBRARY
  38 #define MATH_LIBRARY "m"
  39 #endif
  40 #ifndef MATH_LIBRARY_PROFILE
  41 #define MATH_LIBRARY_PROFILE MATH_LIBRARY
  42 #endif
  43
  44 #define THREAD_LIBRARY "pthread"
  45 #define THREAD_LIBRARY_PROFILE THREAD_LIBRARY
  46
  47 #define LIBGO "go"
  48 #define LIBGO_PROFILE LIBGO
  49 #define LIBGOBEGIN "gobegin"
  50
  51 void
  52 lang_specific_driver (struct cl_decoded_option **in_decoded_options,
  53                       unsigned int *in_decoded_options_count,
  54                       int *in_added_libraries)
  55 {
  56   unsigned int i, j;
  57
  58   /* If true, the user gave us the `-p' or `-pg' flag.  */
  59   bool saw_profile_flag = false;
  60
  61   /* This is a tristate:
  62      -1 means we should not link in libgo
  63      0  means we should link in libgo if it is needed
  64      1  means libgo is needed and should be linked in.
  65      2  means libgo is needed and should be linked statically.  */
  66   int library = 0;
  67
  68   /* The new argument list will be contained in this.  */
  69   struct cl_decoded_option *new_decoded_options;
  70
  71   /* "-lm" or "-lmath" if it appears on the command line.  */
  72   const struct cl_decoded_option *saw_math = 0;
  73
  74   /* "-lpthread" if it appears on the command line.  */
  75   const struct cl_decoded_option *saw_thread = 0;
  76
  77   /* "-lc" if it appears on the command line.  */
  78   const struct cl_decoded_option *saw_libc = 0;
  79
  80   /* An array used to flag each argument that needs a bit set for
  81      LANGSPEC, MATHLIB, or WITHLIBC.  */
  82   int *args;
  83
  84   /* Whether we need the thread library.  */
  85   int need_thread = 0;
  86
  87   /* By default, we throw on the math library if we have one.  */
  88   int need_math = (MATH_LIBRARY[0] != '\0');
  89
  90   /* True if we saw -static.  */
  91   int static_link = 0;
  92
  93   /* True if we should add -shared-libgcc to the command-line.  */
  94   int shared_libgcc = 1;
  95
  96   /* The total number of arguments with the new stuff.  */
  97   unsigned int argc;
  98
  99   /* The argument list.  */
 100   struct cl_decoded_option *decoded_options;
 101
 102   /* The number of libraries added in.  */
 103   int added_libraries;
 104
 105   /* The total number of arguments with the new stuff.  */
 106   int num_args = 1;
 107
 108   /* Supports split stack */
 109   int supports_split_stack = 0;
 110
 111   /* Whether the -o option was used.  */
 112   bool saw_opt_o = false;
 113
 114   /* Whether the -c option was used.  Also used for -E, -fsyntax-only,
 115      in general anything which implies only compilation and not
 116      linking.  */
 117   bool saw_opt_c = false;
 118
 119   /* Whether the -S option was used.  */
 120   bool saw_opt_S = false;
 121
 122 #ifdef TARGET_CAN_SPLIT_STACK_64BIT
 123   /* Whether the -m64 option is in force. */
 124   bool is_m64 = TARGET_CAN_SPLIT_STACK_64BIT;
 125 #endif
 126
 127   /* The first input file with an extension of .go.  */
 128   const char *first_go_file = NULL;
 129
 130   argc = *in_decoded_options_count;
 131   decoded_options = *in_decoded_options;
 132   added_libraries = *in_added_libraries;
 133
 134   args = XCNEWVEC (int, argc);
 135
 136   for (i = 1; i < argc; i++)
 137     {
 138       const char *arg = decoded_options[i].arg;
 139
 140       switch (decoded_options[i].opt_index)
 141         {
 142         case OPT_nostdlib:
 143         case OPT_nodefaultlibs:
 144           library = -1;
 145           break;
 146
 147         case OPT_l:
 148           if (strcmp (arg, MATH_LIBRARY) == 0)
 149             {
 150               args[i] |= MATHLIB;
 151               need_math = 0;
 152             }
 153           else if (strcmp (arg, THREAD_LIBRARY) == 0)
 154             args[i] |= THREADLIB;
 155           else if (strcmp (arg, "c") == 0)
 156             args[i] |= WITHLIBC;
 157           else
 158             /* Unrecognized libraries (e.g. -lfoo) may require libgo.  */
 159             library = (library == 0) ? 1 : library;
 160           break;
 161
 162 #ifdef TARGET_CAN_SPLIT_STACK_64BIT
 163         case OPT_m32:
 164           is_m64 = false;
 165           break;
 166
 167         case OPT_m64:
 168           is_m64 = true;
 169           break;
 170 #endif
 171
 172         case OPT_pg:
 173         case OPT_p:
 174           saw_profile_flag = true;
 175           break;
 176
 177         case OPT_x:
 178           if (library == 0 && strcmp (arg, "go") == 0)
 179             library = 1;
 180           break;
 181
 182         case OPT_Xlinker:
 183         case OPT_Wl_:
 184           /* Arguments that go directly to the linker might be .o files,
 185              or something, and so might cause libgo to be needed.  */
 186           if (library == 0)
 187             library = 1;
 188           break;
 189
 190         case OPT_c:
 191         case OPT_E:
 192         case OPT_M:
 193         case OPT_MM:
 194         case OPT_fsyntax_only:
 195           /* Don't specify libraries if we won't link, since that would
 196              cause a warning.  */
 197           saw_opt_c = true;
 198           library = -1;
 199           break;
 200
 201         case OPT_S:
 202           saw_opt_S = true;
 203           library = -1;
 204           break;
 205
 206         case OPT_o:
 207           saw_opt_o = true;
 208           break;
 209
 210         case OPT_static:
 211           static_link = 1;
 212           break;
 213
 214         case OPT_static_libgcc:
 215           shared_libgcc = 0;
 216           break;
 217
 218         case OPT_static_libgo:
 219           library = library >= 0 ? 2 : library;
 220           args[i] |= SKIPOPT;
 221           break;
 222
 223         case OPT_SPECIAL_input_file:
 224           if (library == 0)
 225             library = 1;
 226
 227           if (first_go_file == NULL)
 228             {
 229               int len;
 230
 231               len = strlen (arg);
 232               if (len > 3 && strcmp (arg + len - 3, ".go") == 0)
 233                 first_go_file = arg;
 234             }
 235
 236           break;
 237         }
 238     }
 239
 240   /* There's no point adding -shared-libgcc if we don't have a shared
 241      libgcc.  */
 242 #ifndef ENABLE_SHARED_LIBGCC
 243   shared_libgcc = 0;
 244 #endif
 245
 246   /* Make sure to have room for the trailing NULL argument.  */
 247   num_args = argc + need_math + shared_libgcc + (library > 0) * 5 + 10;
 248   new_decoded_options = XNEWVEC (struct cl_decoded_option, num_args);
 249
 250   i = 0;
 251   j = 0;
 252
 253   /* Copy the 0th argument, i.e., the name of the program itself.  */
 254   new_decoded_options[j++] = decoded_options[i++];
 255
 256 #ifdef TARGET_CAN_SPLIT_STACK
 257   supports_split_stack = 1;
 258 #endif
 259
 260 #ifdef TARGET_CAN_SPLIT_STACK_64BIT
 261   if (is_m64)
 262     supports_split_stack = 1;
 263 #endif
 264
 265   /* If we are linking, pass -fsplit-stack if it is supported.  */
 266   if ((library >= 0) && supports_split_stack)
 267     {
 268       generate_option (OPT_fsplit_stack, NULL, 1, CL_DRIVER,
 269                        &new_decoded_options[j]);
 270       j++;
 271     }
 272
 273   /* NOTE: We start at 1 now, not 0.  */
 274   while (i < argc)
 275     {
 276       new_decoded_options[j] = decoded_options[i];
 277
 278       /* Make sure -lgo is before the math library, since libgo itself
 279          uses those math routines.  */
 280       if (!saw_math && (args[i] & MATHLIB) && library > 0)
 281         {
 282           --j;
 283           saw_math = &decoded_options[i];
 284         }
 285
 286       if (!saw_thread && (args[i] & THREADLIB) && library > 0)
 287         {
 288           --j;
 289           saw_thread = &decoded_options[i];
 290         }
 291
 292       if (!saw_libc && (args[i] & WITHLIBC) && library > 0)
 293         {
 294           --j;
 295           saw_libc = &decoded_options[i];
 296         }
 297
 298       if ((args[i] & SKIPOPT) != 0)
 299         --j;
 300
 301       i++;
 302       j++;
 303     }
 304
 305   /* If we didn't see a -o option, add one.  This is because we need
 306      the driver to pass all .go files to go1.  Without a -o option the
 307      driver will invoke go1 separately for each input file.  FIXME:
 308      This should probably use some other interface to force the driver
 309      to set combine_inputs.  */
 310   if (first_go_file != NULL && !saw_opt_o)
 311     {
 312       if (saw_opt_c || saw_opt_S)
 313         {
 314           const char *base;
 315           int baselen;
 316           int alen;
 317           char *out;
 318
 319           base = lbasename (first_go_file);
 320           baselen = strlen (base) - 3;
 321           alen = baselen + 3;
 322           out = XNEWVEC (char, alen);
 323           memcpy (out, base, baselen);
 324           /* The driver will convert .o to some other suffix (e.g.,
 325              .obj) if appropriate.  */
 326           out[baselen] = '.';
 327           if (saw_opt_S)
 328             out[baselen + 1] = 's';
 329           else
 330             out[baselen + 1] = 'o';
 331           out[baselen + 2] = '\0';
 332           generate_option (OPT_o, out, 1, CL_DRIVER,
 333                            &new_decoded_options[j]);
 334         }
 335       else
 336         generate_option (OPT_o, "a.out", 1, CL_DRIVER,
 337                          &new_decoded_options[j]);
 338       j++;
 339     }
 340
 341   /* Add `-lgo' if we haven't already done so.  */
 342   if (library > 0)
 343     {
 344       generate_option (OPT_l, LIBGOBEGIN, 1, CL_DRIVER,
 345                        &new_decoded_options[j]);
 346       added_libraries++;
 347       j++;
 348
 349 #ifdef HAVE_LD_STATIC_DYNAMIC
 350       if (library > 1 && !static_link)
 351         {
 352           generate_option (OPT_Wl_, LD_STATIC_OPTION, 1, CL_DRIVER,
 353                            &new_decoded_options[j]);
 354           j++;
 355         }
 356 #endif
 357
 358       generate_option (OPT_l, saw_profile_flag ? LIBGO_PROFILE : LIBGO, 1,
 359                        CL_DRIVER, &new_decoded_options[j]);
 360       added_libraries++;
 361       j++;
 362
 363 #ifdef HAVE_LD_STATIC_DYNAMIC
 364       if (library > 1 && !static_link)
 365         {
 366           generate_option (OPT_Wl_, LD_DYNAMIC_OPTION, 1, CL_DRIVER,
 367                            &new_decoded_options[j]);
 368           j++;
 369         }
 370 #endif
 371
 372       /* When linking libgo statically we also need to link with the
 373          pthread library.  */
 374       if (library > 1 || static_link)
 375         need_thread = 1;
 376     }
 377
 378   if (saw_thread)
 379     new_decoded_options[j++] = *saw_thread;
 380   else if (library > 0 && need_thread)
 381     {
 382       generate_option (OPT_l,
 383                        (saw_profile_flag
 384                         ? THREAD_LIBRARY_PROFILE
 385                         : THREAD_LIBRARY),
 386                        1, CL_DRIVER, &new_decoded_options[j]);
 387       added_libraries++;
 388       j++;
 389     }
 390
 391   if (saw_math)
 392     new_decoded_options[j++] = *saw_math;
 393   else if (library > 0 && need_math)
 394     {
 395       generate_option (OPT_l,
 396                        saw_profile_flag ? MATH_LIBRARY_PROFILE : MATH_LIBRARY,
 397                        1, CL_DRIVER, &new_decoded_options[j]);
 398       added_libraries++;
 399       j++;
 400     }
 401
 402   if (saw_libc)
 403     new_decoded_options[j++] = *saw_libc;
 404   if (shared_libgcc && !static_link)
 405     generate_option (OPT_shared_libgcc, NULL, 1, CL_DRIVER,
 406                      &new_decoded_options[j++]);
 407
 408   /* libgcc wraps pthread_create to support split stack, however, due to
 409      relative ordering of -lpthread and -lgcc, we can't just mark
 410      __real_pthread_create in libgcc as non-weak.  But we need to link in
 411      pthread_create from pthread if we are statically linking, so we work-
 412      around by passing -u pthread_create to the linker. */
 413   if (static_link && supports_split_stack)
 414     {
 415       generate_option (OPT_Wl_, "-u,pthread_create", 1, CL_DRIVER,
 416                        &new_decoded_options[j]);
 417       j++;
 418     }
 419
 420 #if defined(TARGET_SOLARIS) && !defined(USE_GLD)
 421   /* We use a common symbol for go$zerovalue.  On Solaris, when not
 422      using the GNU linker, the Solaris linker needs an option to not
 423      warn about this.  Everything works without this option, but you
 424      get unsightly warnings at link time.  */
 425   generate_option (OPT_Wl_, "-t", 1, CL_DRIVER, &new_decoded_options[j]);
 426   j++;
 427 #endif
 428
 429   *in_decoded_options_count = j;
 430   *in_decoded_options = new_decoded_options;
 431   *in_added_libraries = added_libraries;
 432 }
 433
 434 /* Called before linking.  Returns 0 on success and -1 on failure.  */
 435 int lang_specific_pre_link (void)  /* Not used for Go.  */
 436 {
 437   return 0;
 438 }
 439
 440 /* Number of extra output files that lang_specific_pre_link may generate.  */
 441 int lang_specific_extra_outfiles = 0;  /* Not used for Go.  */