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

/* gospec.c -- Specific flags and argument handling of the gcc Go front end.
   Copyright (C) 2009-2019 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_r:
	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
e440a328	1	/* gospec.c -- Specific flags and argument handling of the gcc Go front end.
fbd26352	2	Copyright (C) 2009-2019 Free Software Foundation, Inc.
e440a328	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"
e440a328	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
e97f880e	108	/* Supports split stack */
	109	int supports_split_stack = 0;
	110
0a80c97a	111	/* Whether the -o option was used. */
	112	bool saw_opt_o = false;
	113
d7a6361c	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
0a80cbc6	119	/* Whether the -S option was used. */
	120	bool saw_opt_S = false;
	121
c33609c3	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
e97f880e	126
0a80c97a	127	/* The first input file with an extension of .go. */
	128	const char *first_go_file = NULL;
	129
e440a328	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	{
32398841	142	case OPT_r:
e440a328	143	case OPT_nostdlib:
	144	case OPT_nodefaultlibs:
	145	library = -1;
	146	break;
	147
	148	case OPT_l:
	149	if (strcmp (arg, MATH_LIBRARY) == 0)
	150	{
	151	args[i] \|= MATHLIB;
	152	need_math = 0;
	153	}
	154	else if (strcmp (arg, THREAD_LIBRARY) == 0)
	155	args[i] \|= THREADLIB;
	156	else if (strcmp (arg, "c") == 0)
	157	args[i] \|= WITHLIBC;
	158	else
	159	/* Unrecognized libraries (e.g. -lfoo) may require libgo. */
	160	library = (library == 0) ? 1 : library;
	161	break;
	162
d608de6f	163	#ifdef TARGET_CAN_SPLIT_STACK_64BIT
e97f880e	164	case OPT_m32:
c33609c3	165	is_m64 = false;
	166	break;
	167
	168	case OPT_m64:
	169	is_m64 = true;
e97f880e	170	break;
d608de6f	171	#endif
e97f880e	172
e440a328	173	case OPT_pg:
	174	case OPT_p:
	175	saw_profile_flag = true;
	176	break;
	177
	178	case OPT_x:
	179	if (library == 0 && strcmp (arg, "go") == 0)
	180	library = 1;
	181	break;
	182
	183	case OPT_Xlinker:
	184	case OPT_Wl_:
	185	/* Arguments that go directly to the linker might be .o files,
	186	or something, and so might cause libgo to be needed. */
	187	if (library == 0)
	188	library = 1;
	189	break;
	190
	191	case OPT_c:
e440a328	192	case OPT_E:
	193	case OPT_M:
	194	case OPT_MM:
	195	case OPT_fsyntax_only:
	196	/* Don't specify libraries if we won't link, since that would
	197	cause a warning. */
d7a6361c	198	saw_opt_c = true;
e440a328	199	library = -1;
	200	break;
	201
0a80cbc6	202	case OPT_S:
	203	saw_opt_S = true;
	204	library = -1;
	205	break;
	206
0a80c97a	207	case OPT_o:
	208	saw_opt_o = true;
	209	break;
	210
e440a328	211	case OPT_static:
	212	static_link = 1;
	213	break;
	214
	215	case OPT_static_libgcc:
	216	shared_libgcc = 0;
	217	break;
	218
	219	case OPT_static_libgo:
	220	library = library >= 0 ? 2 : library;
	221	args[i] \|= SKIPOPT;
	222	break;
	223
	224	case OPT_SPECIAL_input_file:
	225	if (library == 0)
	226	library = 1;
0a80c97a	227
	228	if (first_go_file == NULL)
	229	{
	230	int len;
	231
	232	len = strlen (arg);
	233	if (len > 3 && strcmp (arg + len - 3, ".go") == 0)
	234	first_go_file = arg;
	235	}
	236
e440a328	237	break;
	238	}
	239	}
	240
	241	/* There's no point adding -shared-libgcc if we don't have a shared
	242	libgcc. */
	243	#ifndef ENABLE_SHARED_LIBGCC
	244	shared_libgcc = 0;
	245	#endif
	246
	247	/* Make sure to have room for the trailing NULL argument. */
46d008e4	248	num_args = argc + need_math + shared_libgcc + (library > 0) * 5 + 10;
e440a328	249	new_decoded_options = XNEWVEC (struct cl_decoded_option, num_args);
	250
	251	i = 0;
	252	j = 0;
	253
	254	/* Copy the 0th argument, i.e., the name of the program itself. */
	255	new_decoded_options[j++] = decoded_options[i++];
	256
e440a328	257	#ifdef TARGET_CAN_SPLIT_STACK
e97f880e	258	supports_split_stack = 1;
	259	#endif
	260
	261	#ifdef TARGET_CAN_SPLIT_STACK_64BIT
c33609c3	262	if (is_m64)
e97f880e	263	supports_split_stack = 1;
	264	#endif
	265
	266	/* If we are linking, pass -fsplit-stack if it is supported. */
	267	if ((library >= 0) && supports_split_stack)
e440a328	268	{
	269	generate_option (OPT_fsplit_stack, NULL, 1, CL_DRIVER,
	270	&new_decoded_options[j]);
	271	j++;
	272	}
e440a328	273
	274	/* NOTE: We start at 1 now, not 0. */
	275	while (i < argc)
	276	{
	277	new_decoded_options[j] = decoded_options[i];
	278
	279	/* Make sure -lgo is before the math library, since libgo itself
	280	uses those math routines. */
	281	if (!saw_math && (args[i] & MATHLIB) && library > 0)
	282	{
	283	--j;
	284	saw_math = &decoded_options[i];
	285	}
	286
	287	if (!saw_thread && (args[i] & THREADLIB) && library > 0)
	288	{
	289	--j;
	290	saw_thread = &decoded_options[i];
	291	}
	292
	293	if (!saw_libc && (args[i] & WITHLIBC) && library > 0)
	294	{
	295	--j;
	296	saw_libc = &decoded_options[i];
	297	}
	298
	299	if ((args[i] & SKIPOPT) != 0)
	300	--j;
	301
	302	i++;
	303	j++;
	304	}
	305
d7a6361c	306	/* If we didn't see a -o option, add one. This is because we need
0a80c97a	307	the driver to pass all .go files to go1. Without a -o option the
d7a6361c	308	driver will invoke go1 separately for each input file. FIXME:
	309	This should probably use some other interface to force the driver
	310	to set combine_inputs. */
	311	if (first_go_file != NULL && !saw_opt_o)
0a80c97a	312	{
d7a6361c	313	if (saw_opt_c \|\| saw_opt_S)
	314	{
	315	const char *base;
	316	int baselen;
	317	int alen;
	318	char *out;
	319
	320	base = lbasename (first_go_file);
	321	baselen = strlen (base) - 3;
	322	alen = baselen + 3;
	323	out = XNEWVEC (char, alen);
	324	memcpy (out, base, baselen);
	325	/* The driver will convert .o to some other suffix (e.g.,
	326	.obj) if appropriate. */
	327	out[baselen] = '.';
	328	if (saw_opt_S)
	329	out[baselen + 1] = 's';
	330	else
	331	out[baselen + 1] = 'o';
	332	out[baselen + 2] = '\0';
	333	generate_option (OPT_o, out, 1, CL_DRIVER,
	334	&new_decoded_options[j]);
	335	}
0a80cbc6	336	else
d7a6361c	337	generate_option (OPT_o, "a.out", 1, CL_DRIVER,
d7a6361c	338	&new_decoded_options[j]);
0a80c97a	339	j++;
	340	}
	341
e440a328	342	/* Add `-lgo' if we haven't already done so. */
	343	if (library > 0)
	344	{
	345	generate_option (OPT_l, LIBGOBEGIN, 1, CL_DRIVER,
	346	&new_decoded_options[j]);
	347	added_libraries++;
	348	j++;
	349
	350	#ifdef HAVE_LD_STATIC_DYNAMIC
	351	if (library > 1 && !static_link)
	352	{
e6937b3a	353	generate_option (OPT_Wl_, LD_STATIC_OPTION, 1, CL_DRIVER,
e440a328	354	&new_decoded_options[j]);
	355	j++;
	356	}
	357	#endif
	358
	359	generate_option (OPT_l, saw_profile_flag ? LIBGO_PROFILE : LIBGO, 1,
	360	CL_DRIVER, &new_decoded_options[j]);
	361	added_libraries++;
	362	j++;
	363
	364	#ifdef HAVE_LD_STATIC_DYNAMIC
	365	if (library > 1 && !static_link)
	366	{
e6937b3a	367	generate_option (OPT_Wl_, LD_DYNAMIC_OPTION, 1, CL_DRIVER,
e440a328	368	&new_decoded_options[j]);
	369	j++;
	370	}
	371	#endif
	372
	373	/* When linking libgo statically we also need to link with the
	374	pthread library. */
	375	if (library > 1 \|\| static_link)
	376	need_thread = 1;
	377	}
	378
	379	if (saw_thread)
	380	new_decoded_options[j++] = *saw_thread;
	381	else if (library > 0 && need_thread)
	382	{
	383	generate_option (OPT_l,
	384	(saw_profile_flag
	385	? THREAD_LIBRARY_PROFILE
	386	: THREAD_LIBRARY),
	387	1, CL_DRIVER, &new_decoded_options[j]);
	388	added_libraries++;
	389	j++;
	390	}
	391
	392	if (saw_math)
	393	new_decoded_options[j++] = *saw_math;
	394	else if (library > 0 && need_math)
	395	{
	396	generate_option (OPT_l,
	397	saw_profile_flag ? MATH_LIBRARY_PROFILE : MATH_LIBRARY,
	398	1, CL_DRIVER, &new_decoded_options[j]);
	399	added_libraries++;
	400	j++;
	401	}
	402
	403	if (saw_libc)
	404	new_decoded_options[j++] = *saw_libc;
	405	if (shared_libgcc && !static_link)
	406	generate_option (OPT_shared_libgcc, NULL, 1, CL_DRIVER,
	407	&new_decoded_options[j++]);
	408
46d008e4	409	/* libgcc wraps pthread_create to support split stack, however, due to
	410	relative ordering of -lpthread and -lgcc, we can't just mark
	411	__real_pthread_create in libgcc as non-weak. But we need to link in
	412	pthread_create from pthread if we are statically linking, so we work-
47ae02b7	413	around by passing -u pthread_create to the linker. */
e97f880e	414	if (static_link && supports_split_stack)
46d008e4	415	{
	416	generate_option (OPT_Wl_, "-u,pthread_create", 1, CL_DRIVER,
	417	&new_decoded_options[j]);
	418	j++;
	419	}
46d008e4	420
4f31a4e7	421	#if defined(TARGET_SOLARIS) && !defined(USE_GLD)
	422	/* We use a common symbol for go$zerovalue. On Solaris, when not
	423	using the GNU linker, the Solaris linker needs an option to not
	424	warn about this. Everything works without this option, but you
	425	get unsightly warnings at link time. */
	426	generate_option (OPT_Wl_, "-t", 1, CL_DRIVER, &new_decoded_options[j]);
	427	j++;
	428	#endif
	429
e440a328	430	*in_decoded_options_count = j;
	431	*in_decoded_options = new_decoded_options;
	432	*in_added_libraries = added_libraries;
	433	}
	434
	435	/* Called before linking. Returns 0 on success and -1 on failure. */
	436	int lang_specific_pre_link (void) /* Not used for Go. */
	437	{
	438	return 0;
	439	}
	440
	441	/* Number of extra output files that lang_specific_pre_link may generate. */
	442	int lang_specific_extra_outfiles = 0; /* Not used for Go. */