[thirdparty/gcc.git] / gcc / go / gospec.c

/* gospec.c -- Specific flags and argument handling of the gcc Go front end.
   Copyright (C) 2009-2018 Free Software Foundation, 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 "system.h"
#include "coretypes.h"
#include "tm.h"
#include "opts.h"

/* This bit is set if we saw a `-xfoo' language specification.  */
#define LANGSPEC	(1<<1)
/* This bit is set if they did `-lm' or `-lmath'.  */
#define MATHLIB		(1<<2)
/* This bit is set if they did `-lpthread'.  */
#define THREADLIB	(1<<3)
/* This bit is set if they did `-lc'.  */
#define WITHLIBC	(1<<4)
/* Skip this option.  */
#define SKIPOPT		(1<<5)

#ifndef MATH_LIBRARY
#define MATH_LIBRARY "m"
#endif
#ifndef MATH_LIBRARY_PROFILE
#define MATH_LIBRARY_PROFILE MATH_LIBRARY
#endif

#define THREAD_LIBRARY "pthread"
#define THREAD_LIBRARY_PROFILE THREAD_LIBRARY

#define LIBGO "go"
#define LIBGO_PROFILE LIBGO
#define LIBGOBEGIN "gobegin"

void
lang_specific_driver (struct cl_decoded_option **in_decoded_options,
		      unsigned int *in_decoded_options_count,
		      int *in_added_libraries)
{
  unsigned int i, j;

  /* If true, the user gave us the `-p' or `-pg' flag.  */
  bool saw_profile_flag = false;

  /* This is a tristate:
     -1 means we should not link in libgo
     0  means we should link in libgo if it is needed
     1  means libgo is needed and should be linked in.
     2  means libgo is needed and should be linked statically.  */
  int library = 0;

  /* The new argument list will be contained in this.  */
  struct cl_decoded_option *new_decoded_options;

  /* "-lm" or "-lmath" if it appears on the command line.  */
  const struct cl_decoded_option *saw_math = 0;

  /* "-lpthread" if it appears on the command line.  */
  const struct cl_decoded_option *saw_thread = 0;

  /* "-lc" if it appears on the command line.  */
  const struct cl_decoded_option *saw_libc = 0;

  /* An array used to flag each argument that needs a bit set for
     LANGSPEC, MATHLIB, or WITHLIBC.  */
  int *args;

  /* Whether we need the thread library.  */
  int need_thread = 0;

  /* By default, we throw on the math library if we have one.  */
  int need_math = (MATH_LIBRARY[0] != '\0');

  /* True if we saw -static.  */
  int static_link = 0;

  /* True if we should add -shared-libgcc to the command-line.  */
  int shared_libgcc = 1;

  /* The total number of arguments with the new stuff.  */
  unsigned int argc;

  /* The argument list.  */
  struct cl_decoded_option *decoded_options;

  /* The number of libraries added in.  */
  int added_libraries;

  /* The total number of arguments with the new stuff.  */
  int num_args = 1;

  /* Supports split stack */
  int supports_split_stack = 0;

  /* Whether the -o option was used.  */
  bool saw_opt_o = false;

  /* Whether the -c option was used.  Also used for -E, -fsyntax-only,
     in general anything which implies only compilation and not
     linking.  */
  bool saw_opt_c = false;

  /* Whether the -S option was used.  */
  bool saw_opt_S = false;

#ifdef TARGET_CAN_SPLIT_STACK_64BIT
  /* Whether the -m64 option is in force. */
  bool is_m64 = TARGET_CAN_SPLIT_STACK_64BIT;
#endif

  /* The first input file with an extension of .go.  */
  const char *first_go_file = NULL;  

  argc = *in_decoded_options_count;
  decoded_options = *in_decoded_options;
  added_libraries = *in_added_libraries;

  args = XCNEWVEC (int, argc);

  for (i = 1; i < argc; i++)
    {
      const char *arg = decoded_options[i].arg;

      switch (decoded_options[i].opt_index)
	{
	case OPT_nostdlib:
	case OPT_nodefaultlibs:
	  library = -1;
	  break;

	case OPT_l:
	  if (strcmp (arg, MATH_LIBRARY) == 0)
	    {
	      args[i] |= MATHLIB;
	      need_math = 0;
	    }
	  else if (strcmp (arg, THREAD_LIBRARY) == 0)
	    args[i] |= THREADLIB;
	  else if (strcmp (arg, "c") == 0)
	    args[i] |= WITHLIBC;
	  else
	    /* Unrecognized libraries (e.g. -lfoo) may require libgo.  */
	    library = (library == 0) ? 1 : library;
	  break;

#ifdef TARGET_CAN_SPLIT_STACK_64BIT
	case OPT_m32:
	  is_m64 = false;
	  break;

	case OPT_m64:
	  is_m64 = true;
	  break;
#endif

	case OPT_pg:
	case OPT_p:
	  saw_profile_flag = true;
	  break;

	case OPT_x:
	  if (library == 0 && strcmp (arg, "go") == 0)
	    library = 1;
	  break;

	case OPT_Xlinker:
	case OPT_Wl_:
	  /* Arguments that go directly to the linker might be .o files,
	     or something, and so might cause libgo to be needed.  */
	  if (library == 0)
	    library = 1;
	  break;

	case OPT_c:
	case OPT_E:
	case OPT_M:
	case OPT_MM:
	case OPT_fsyntax_only:
	  /* Don't specify libraries if we won't link, since that would
	     cause a warning.  */
	  saw_opt_c = true;
	  library = -1;
	  break;

	case OPT_S:
	  saw_opt_S = true;
	  library = -1;
	  break;

	case OPT_o:
	  saw_opt_o = true;
	  break;

	case OPT_static:
	  static_link = 1;
	  break;

	case OPT_static_libgcc:
	  shared_libgcc = 0;
	  break;

	case OPT_static_libgo:
	  library = library >= 0 ? 2 : library;
	  args[i] |= SKIPOPT;
	  break;

	case OPT_SPECIAL_input_file:
	  if (library == 0)
	    library = 1;

	  if (first_go_file == NULL)
	    {
	      int len;

	      len = strlen (arg);
	      if (len > 3 && strcmp (arg + len - 3, ".go") == 0)
		first_go_file = arg;
	    }

	  break;
	}
    }

  /* There's no point adding -shared-libgcc if we don't have a shared
     libgcc.  */
#ifndef ENABLE_SHARED_LIBGCC
  shared_libgcc = 0;
#endif

  /* Make sure to have room for the trailing NULL argument.  */
  num_args = argc + need_math + shared_libgcc + (library > 0) * 5 + 10;
  new_decoded_options = XNEWVEC (struct cl_decoded_option, num_args);

  i = 0;
  j = 0;

  /* Copy the 0th argument, i.e., the name of the program itself.  */
  new_decoded_options[j++] = decoded_options[i++];

#ifdef TARGET_CAN_SPLIT_STACK
  supports_split_stack = 1;
#endif

#ifdef TARGET_CAN_SPLIT_STACK_64BIT
  if (is_m64)
    supports_split_stack = 1;
#endif

  /* If we are linking, pass -fsplit-stack if it is supported.  */
  if ((library >= 0) && supports_split_stack)
    {
      generate_option (OPT_fsplit_stack, NULL, 1, CL_DRIVER,
		       &new_decoded_options[j]);
      j++;
    }

  /* NOTE: We start at 1 now, not 0.  */
  while (i < argc)
    {
      new_decoded_options[j] = decoded_options[i];

      /* Make sure -lgo is before the math library, since libgo itself
	 uses those math routines.  */
      if (!saw_math && (args[i] & MATHLIB) && library > 0)
	{
	  --j;
	  saw_math = &decoded_options[i];
	}

      if (!saw_thread && (args[i] & THREADLIB) && library > 0)
	{
	  --j;
	  saw_thread = &decoded_options[i];
	}

      if (!saw_libc && (args[i] & WITHLIBC) && library > 0)
	{
	  --j;
	  saw_libc = &decoded_options[i];
	}

      if ((args[i] & SKIPOPT) != 0)
	--j;

      i++;
      j++;
    }

  /* If we didn't see a -o option, add one.  This is because we need
     the driver to pass all .go files to go1.  Without a -o option the
     driver will invoke go1 separately for each input file.  FIXME:
     This should probably use some other interface to force the driver
     to set combine_inputs.  */
  if (first_go_file != NULL && !saw_opt_o)
    {
      if (saw_opt_c || saw_opt_S)
	{
	  const char *base;
	  int baselen;
	  int alen;
	  char *out;

	  base = lbasename (first_go_file);
	  baselen = strlen (base) - 3;
	  alen = baselen + 3;
	  out = XNEWVEC (char, alen);
	  memcpy (out, base, baselen);
	  /* The driver will convert .o to some other suffix (e.g.,
	     .obj) if appropriate.  */
	  out[baselen] = '.';
	  if (saw_opt_S)
	    out[baselen + 1] = 's';
	  else
	    out[baselen + 1] = 'o';
	  out[baselen + 2] = '\0';
	  generate_option (OPT_o, out, 1, CL_DRIVER,
			   &new_decoded_options[j]);
	}
      else
	generate_option (OPT_o, "a.out", 1, CL_DRIVER,
			 &new_decoded_options[j]);
      j++;
    }

  /* Add `-lgo' if we haven't already done so.  */
  if (library > 0)
    {
      generate_option (OPT_l, LIBGOBEGIN, 1, CL_DRIVER,
		       &new_decoded_options[j]);
      added_libraries++;
      j++;

#ifdef HAVE_LD_STATIC_DYNAMIC
      if (library > 1 && !static_link)
	{
	  generate_option (OPT_Wl_, LD_STATIC_OPTION, 1, CL_DRIVER,
			   &new_decoded_options[j]);
	  j++;
	}
#endif

      generate_option (OPT_l, saw_profile_flag ? LIBGO_PROFILE : LIBGO, 1,
		       CL_DRIVER, &new_decoded_options[j]);
      added_libraries++;
      j++;

#ifdef HAVE_LD_STATIC_DYNAMIC
      if (library > 1 && !static_link)
	{
	  generate_option (OPT_Wl_, LD_DYNAMIC_OPTION, 1, CL_DRIVER,
			   &new_decoded_options[j]);
	  j++;
	}
#endif

      /* When linking libgo statically we also need to link with the
	 pthread library.  */
      if (library > 1 || static_link)
	need_thread = 1;
    }

  if (saw_thread)
    new_decoded_options[j++] = *saw_thread;
  else if (library > 0 && need_thread)
    {
      generate_option (OPT_l,
		       (saw_profile_flag
			? THREAD_LIBRARY_PROFILE
			: THREAD_LIBRARY),
		       1, CL_DRIVER, &new_decoded_options[j]);
      added_libraries++;
      j++;
    }

  if (saw_math)
    new_decoded_options[j++] = *saw_math;
  else if (library > 0 && need_math)
    {
      generate_option (OPT_l,
		       saw_profile_flag ? MATH_LIBRARY_PROFILE : MATH_LIBRARY,
		       1, CL_DRIVER, &new_decoded_options[j]);
      added_libraries++;
      j++;
    }

  if (saw_libc)
    new_decoded_options[j++] = *saw_libc;
  if (shared_libgcc && !static_link)
    generate_option (OPT_shared_libgcc, NULL, 1, CL_DRIVER,
		     &new_decoded_options[j++]);

  /* libgcc wraps pthread_create to support split stack, however, due to
     relative ordering of -lpthread and -lgcc, we can't just mark
     __real_pthread_create in libgcc as non-weak.  But we need to link in
     pthread_create from pthread if we are statically linking, so we work-
     around by passing -u pthread_create to the linker. */
  if (static_link && supports_split_stack)
    {
      generate_option (OPT_Wl_, "-u,pthread_create", 1, CL_DRIVER,
		       &new_decoded_options[j]);
      j++;
    }

#if defined(TARGET_SOLARIS) && !defined(USE_GLD)
  /* We use a common symbol for go$zerovalue.  On Solaris, when not
     using the GNU linker, the Solaris linker needs an option to not
     warn about this.  Everything works without this option, but you
     get unsightly warnings at link time.  */
  generate_option (OPT_Wl_, "-t", 1, CL_DRIVER, &new_decoded_options[j]);
  j++;
#endif

  *in_decoded_options_count = j;
  *in_decoded_options = new_decoded_options;
  *in_added_libraries = added_libraries;
}

/* Called before linking.  Returns 0 on success and -1 on failure.  */
int lang_specific_pre_link (void)  /* Not used for Go.  */
{
  return 0;
}

/* Number of extra output files that lang_specific_pre_link may generate.  */
int lang_specific_extra_outfiles = 0;  /* Not used for Go.  */
Commit	Line	Data
7a938933	1	/* gospec.c -- Specific flags and argument handling of the gcc Go front end.
85ec4feb	2	Copyright (C) 2009-2018 Free Software Foundation, Inc.
7a938933 ILT	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"
7a938933 ILT	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
402565b6 LB	108	/* Supports split stack */
	109	int supports_split_stack = 0;
	110
6f855258 ILT	111	/* Whether the -o option was used. */
	112	bool saw_opt_o = false;
	113
f7b67575 ILT	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
a6d10e80 ILT	119	/* Whether the -S option was used. */
	120	bool saw_opt_S = false;
	121
b2e4c071 AM	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
402565b6	126
6f855258 ILT	127	/* The first input file with an extension of .go. */
	128	const char *first_go_file = NULL;
	129
7a938933 ILT	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
209919e2	162	#ifdef TARGET_CAN_SPLIT_STACK_64BIT
402565b6	163	case OPT_m32:
b2e4c071 AM	164	is_m64 = false;
	165	break;
	166
	167	case OPT_m64:
	168	is_m64 = true;
402565b6	169	break;
209919e2	170	#endif
402565b6	171
7a938933 ILT	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:
7a938933 ILT	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. */
f7b67575	197	saw_opt_c = true;
7a938933 ILT	198	library = -1;
	199	break;
	200
a6d10e80 ILT	201	case OPT_S:
	202	saw_opt_S = true;
	203	library = -1;
	204	break;
	205
6f855258 ILT	206	case OPT_o:
	207	saw_opt_o = true;
	208	break;
	209
7a938933 ILT	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;
6f855258 ILT	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
7a938933 ILT	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. */
20f36478	247	num_args = argc + need_math + shared_libgcc + (library > 0) * 5 + 10;
7a938933 ILT	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
7a938933	256	#ifdef TARGET_CAN_SPLIT_STACK
402565b6 LB	257	supports_split_stack = 1;
	258	#endif
	259
	260	#ifdef TARGET_CAN_SPLIT_STACK_64BIT
b2e4c071	261	if (is_m64)
402565b6 LB	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)
7a938933 ILT	267	{
	268	generate_option (OPT_fsplit_stack, NULL, 1, CL_DRIVER,
	269	&new_decoded_options[j]);
	270	j++;
	271	}
7a938933 ILT	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
f7b67575	305	/* If we didn't see a -o option, add one. This is because we need
6f855258	306	the driver to pass all .go files to go1. Without a -o option the
f7b67575 ILT	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)
6f855258	311	{
f7b67575 ILT	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	}
a6d10e80	335	else
f7b67575 ILT	336	generate_option (OPT_o, "a.out", 1, CL_DRIVER,
f7b67575 ILT	337	&new_decoded_options[j]);
6f855258 ILT	338	j++;
	339	}
	340
7a938933 ILT	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	{
c6092243	352	generate_option (OPT_Wl_, LD_STATIC_OPTION, 1, CL_DRIVER,
7a938933 ILT	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	{
c6092243	366	generate_option (OPT_Wl_, LD_DYNAMIC_OPTION, 1, CL_DRIVER,
7a938933 ILT	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
20f36478 SM	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-
026c3cfd	412	around by passing -u pthread_create to the linker. */
402565b6	413	if (static_link && supports_split_stack)
20f36478 SM	414	{
	415	generate_option (OPT_Wl_, "-u,pthread_create", 1, CL_DRIVER,
	416	&new_decoded_options[j]);
	417	j++;
	418	}
20f36478	419
bbeaf05d ILT	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
7a938933 ILT	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. */