[deliverable/binutils-gdb.git] / ld / emultempl / aix.em

# This shell script emits a C file. -*- C -*-
# It does some substitutions.
cat >e${EMULATION_NAME}.c <<EOF
/* This file is is generated by a shell script.  DO NOT EDIT! */

/* AIX emulation code for ${EMULATION_NAME}
   Copyright (C) 1991, 1993, 1995 Free Software Foundation, Inc.
   Written by Steve Chamberlain <sac@cygnus.com>
   AIX support by Ian Lance Taylor <ian@cygnus.com>

This file is part of GLD, the Gnu Linker.

This program 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 2 of the License, or
(at your option) any later version.

This program 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 this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#define TARGET_IS_${EMULATION_NAME}

#include "bfd.h"
#include "sysdep.h"
#include "libiberty.h"
#include "getopt.h"
#include "bfdlink.h"

#include <ctype.h>

#include "ld.h"
#include "ldmain.h"
#include "ldemul.h"
#include "ldfile.h"
#include "ldmisc.h"
#include "ldexp.h"
#include "ldlang.h"

static void gld${EMULATION_NAME}_before_parse PARAMS ((void));
static int gld${EMULATION_NAME}_parse_args PARAMS ((int, char **));
static void gld${EMULATION_NAME}_before_allocation PARAMS ((void));
static void gld${EMULATION_NAME}_read_file PARAMS ((const char *, boolean));
static void gld${EMULATION_NAME}_free PARAMS ((PTR));
static char *gld${EMULATION_NAME}_get_script PARAMS ((int *isfile));

/* The file alignment required for each section.  */
static unsigned long file_align;

/* The maximum size the stack is permitted to grow.  This is stored in
   the a.out header.  */
static unsigned long maxstack;

/* The maximum data size.  This is stored in the a.out header.  */
static unsigned long maxdata;

/* Whether to perform garbage collection.  */
static int gc = 1;

/* The module type to use.  */
static unsigned short modtype = ('1' << 8) | 'L';

/* Whether the .text section must be read-only (i.e., no relocs
   permitted).  */
static int textro;

/* Structure used to hold import or export file list.  */

struct filelist
{
  struct filelist *next;
  const char *name;
};

/* List of import files.  */
struct filelist *import_files;

/* List of export files.  */
struct filelist *export_files;

static void
gld${EMULATION_NAME}_before_parse()
{
#ifndef TARGET_			/* I.e., if not generic.  */
  ldfile_output_architecture = bfd_arch_${ARCH};
#endif /* not TARGET_ */
}

/* Handle AIX specific options.  */

static int
gld${EMULATION_NAME}_parse_args (argc, argv)
     int argc;
     char **argv;
{
  int prevoptind = optind;
  int prevopterr = opterr;
  int longind;
  int optc;
  long val;
  char *end;

#define OPTION_IGNORE (300)
#define OPTION_AUTOIMP (OPTION_IGNORE + 1)
#define OPTION_ERNOTOK (OPTION_AUTOIMP + 1)
#define OPTION_EROK (OPTION_ERNOTOK + 1)
#define OPTION_EXPORT (OPTION_EROK + 1)
#define OPTION_IMPORT (OPTION_EXPORT + 1)
#define OPTION_MAXDATA (OPTION_IMPORT + 1)
#define OPTION_MAXSTACK (OPTION_MAXDATA + 1)
#define OPTION_MODTYPE (OPTION_MAXSTACK + 1)
#define OPTION_NOAUTOIMP (OPTION_MODTYPE + 1)
#define OPTION_NOSTRCMPCT (OPTION_NOAUTOIMP + 1)
#define OPTION_STRCMPCT (OPTION_NOSTRCMPCT + 1)

  static struct option longopts[] = {
    {"basis", no_argument, NULL, OPTION_IGNORE},
    {"bautoimp", no_argument, NULL, OPTION_AUTOIMP},
    {"bcomprld", no_argument, NULL, OPTION_IGNORE},
    {"bcrld", no_argument, NULL, OPTION_IGNORE},
    {"bcror31", no_argument, NULL, OPTION_IGNORE},
    {"bD", required_argument, NULL, OPTION_MAXDATA},
    {"bE", required_argument, NULL, OPTION_EXPORT},
    {"bernotok", no_argument, NULL, OPTION_ERNOTOK},
    {"berok", no_argument, NULL, OPTION_EROK},
    {"berrmsg", no_argument, NULL, OPTION_IGNORE},
    {"bexport", required_argument, NULL, OPTION_EXPORT},
    {"bf", no_argument, NULL, OPTION_ERNOTOK},
    {"bgc", no_argument, &gc, 1},
    {"bh", required_argument, NULL, OPTION_IGNORE},
    {"bhalt", required_argument, NULL, OPTION_IGNORE},
    {"bI", required_argument, NULL, OPTION_IMPORT},
    {"bimport", required_argument, NULL, OPTION_IMPORT},
    {"bmaxdata", required_argument, NULL, OPTION_MAXDATA},
    {"bmaxstack", required_argument, NULL, OPTION_MAXSTACK},
    {"bM", required_argument, NULL, OPTION_MODTYPE},
    {"bmodtype", required_argument, NULL, OPTION_MODTYPE},
    {"bnoautoimp", no_argument, NULL, OPTION_NOAUTOIMP},
    {"bnodelcsect", no_argument, NULL, OPTION_IGNORE},
    {"bnogc", no_argument, &gc, 0},
    {"bnso", no_argument, NULL, OPTION_NOAUTOIMP},
    {"bnostrcmpct", no_argument, NULL, OPTION_NOSTRCMPCT},
    {"bnotextro", no_argument, &textro, 0},
    {"bnro", no_argument, &textro, 0},
    {"bro", no_argument, &textro, 1},
    {"bS", required_argument, NULL, OPTION_MAXSTACK},
    {"bso", no_argument, NULL, OPTION_AUTOIMP},
    {"bstrcmpct", no_argument, NULL, OPTION_STRCMPCT},
    {"btextro", no_argument, &textro, 1},
    {"static", no_argument, NULL, OPTION_NOAUTOIMP},
    {NULL, no_argument, NULL, 0}
  };

  /* Options supported by the AIX linker which we do not support: -f,
     -S, -v, -Z, -bbindcmds, -bbinder, -bbindopts, -bcalls, -bcaps,
     -bcror15, -bdebugopt, -bdbg, -bdelcsect, -bex?, -bfilelist, -bfl,
     -bgcbypass, -bglink, -binsert, -bi, -bloadmap, -bl, -bmap, -bnl,
     -bnobind, -bnocomprld, -bnocrld, -bnoerrmsg, -bnoglink,
     -bnoloadmap, -bnl, -bnoobjreorder, -bnoquiet, -bnoreorder,
     -bnotypchk, -bnox, -bquiet, -bR, -brename, -breorder, -btypchk,
     -bx, -bX, -bxref.  */

  /* If the first option starts with -b, change the first : to an =.
     The AIX linker uses : to separate the option from the argument;
     changing it to = lets us treat it as a getopt option.  */
  if (optind < argc && strncmp (argv[optind], "-b", 2) == 0)
    {
      char *s;

      for (s = argv[optind]; *s != '\0'; s++)
	{
	  if (*s == ':')
	    {
	      *s = '=';
	      break;
	    }
	}
    }

  opterr = 0;
  optc = getopt_long_only (argc, argv, "-D:H:KT:z", longopts, &longind);
  opterr = prevopterr;

  switch (optc)
    {
    default:
      optind = prevoptind;
      return 0;

    case 0:
      /* Long option which just sets a flag.  */
      break;

    case 'D':
      val = strtol (optarg, &end, 0);
      if (*end != '\0')
	einfo ("%P: warning: ignoring invalid -D number %s\n", optarg);
      else if (val != -1)
	lang_section_start (".data", exp_intop (val));
      break;

    case 'H':
      val = strtoul (optarg, &end, 0);
      if (*end != '\0'
	  || (val & (val - 1)) != 0)
	einfo ("%P: warning: ignoring invalid -H number %s\n", optarg);
      else
	file_align = val;
      break;

    case 'K':
    case 'z':
      /* FIXME: This should use the page size for the target system.  */
      file_align = 4096;
      break;

    case 'T':
      /* On AIX this is the same as GNU ld -Ttext.  When we see -T
         number, we assume the AIX option is intended.  Otherwise, we
         assume the usual GNU ld -T option is intended.  We can't just
         ignore the AIX option, because gcc passes it to the linker.  */
      val = strtoul (optarg, &end, 0);
      if (*end != '\0')
	{
	  optind = prevoptind;
	  return 0;
	}
      lang_section_start (".text", exp_intop (val));
      break;

    case OPTION_IGNORE:
      break;

    case OPTION_AUTOIMP:
      link_info.static_link = false;
      break;

    case OPTION_ERNOTOK:
      force_make_executable = false;
      break;

    case OPTION_EROK:
      force_make_executable = true;
      break;

    case OPTION_EXPORT:
    case OPTION_IMPORT:
      {
	struct filelist *n;
	struct filelist **flpp;

	n = (struct filelist *) xmalloc (sizeof (struct filelist));
	n->next = NULL;
	n->name = optarg;
	if (optc == OPTION_EXPORT)
	  flpp = &export_files;
	else
	  flpp = &import_files;
	while (*flpp != NULL)
	  flpp = &(*flpp)->next;
	*flpp = n;
      }
      break;

    case OPTION_MAXDATA:
      val = strtoul (optarg, &end, 0);
      if (*end != '\0')
	einfo ("%P: warning: ignoring invalid -bmaxdata number %s\n",
	       optarg);
      else
	maxdata = val;
      break;

    case OPTION_MAXSTACK:
      val = strtoul (optarg, &end, 0);
      if (*end != '\0')
	einfo ("%P: warning: ignoring invalid -bmaxstack number %s\n",
	       optarg);
      else
	maxstack = val;
      break;

    case OPTION_MODTYPE:
      if (*optarg == 'S')
	{
	  link_info.shared = true;
	  ++optarg;
	}
      if (*optarg == '\0' || optarg[1] == '\0')
	einfo ("%P: warning: ignoring invalid module type %s\n", optarg);
      else
	modtype = (*optarg << 8) | optarg[1];
      break;

    case OPTION_NOAUTOIMP:
      link_info.static_link = true;
      break;

    case OPTION_NOSTRCMPCT:
      config.traditional_format = true;
      break;

    case OPTION_STRCMPCT:
      config.traditional_format = false;
      break;
    }

  return 1;
}

/* This is called after the sections have been attached to output
   sections, but before any sizes or addresses have been set.  */

static void
gld${EMULATION_NAME}_before_allocation ()
{
  struct filelist *fl;
  char *libpath;

  /* Handle the import and export files, if any.  */
  for (fl = import_files; fl != NULL; fl = fl->next)
    gld${EMULATION_NAME}_read_file (fl->name, true);
  for (fl = export_files; fl != NULL; fl = fl->next)
    gld${EMULATION_NAME}_read_file (fl->name, false);

  /* We need to build LIBPATH from the -L arguments.  If any -rpath
     arguments were used, though, we use -rpath instead, as a GNU
     extension.  */
  if (command_line.rpath != NULL)
    libpath = command_line.rpath;
  else if (search_head == NULL)
    libpath = (char *) "";
  else
    {
      size_t len;
      search_dirs_type *search;

      len = strlen (search_head->name);
      libpath = xmalloc (len + 1);
      strcpy (libpath, search_head->name);
      for (search = search_head->next; search != NULL; search = search->next)
	{
	  size_t nlen;

	  nlen = strlen (search->name);
	  libpath = xrealloc (libpath, len + nlen + 2);
	  libpath[len] = ':';
	  strcpy (libpath + len + 1, search->name);
	  len += nlen + 1;
	}
    }

  /* Let the XCOFF backend set up the .loader section.  */
  if (! bfd_xcoff_size_dynamic_sections (output_bfd, &link_info, libpath,
					 entry_symbol, file_align,
					 maxstack, maxdata,
					 gc ? true : false,
					 modtype,
					 textro ? true : false))
    einfo ("%P%F: failed to set dynamic section sizes: %E\n");
}

/* Read an import or export file.  */

static void
gld${EMULATION_NAME}_read_file (filename, import)
     const char *filename;
     boolean import;
{
  struct obstack *o;
  FILE *f;
  int lineno;
  int c;
  boolean keep;
  const char *imppath;
  const char *impfile;
  const char *impmember;

  o = (struct obstack *) xmalloc (sizeof (struct obstack));
  obstack_specify_allocation (o, 0, 0, xmalloc, gld${EMULATION_NAME}_free);

  f = fopen (filename, "r");
  if (f == NULL)
    {
      bfd_set_error (bfd_error_system_call);
      einfo ("%F%s: %E\n", filename);
    }

  keep = false;

  imppath = NULL;
  impfile = NULL;
  impmember = NULL;

  lineno = 0;
  while ((c = getc (f)) != EOF)
    {
      char *s;
      char *symname;
      boolean syscall;
      bfd_vma address;
      struct bfd_link_hash_entry *h;

      if (c != '\n')
	{
	  obstack_1grow (o, c);
	  continue;
	}

      obstack_1grow (o, '\0');
      ++lineno;

      s = (char *) obstack_base (o);
      while (isspace ((unsigned char) *s))
	++s;
      if (*s == '\0'
	  || *s == '*'
	  || (*s == '#' && s[1] == ' ')
	  || (! import && *s == '#' && s[1] == '!'))
	{
	  obstack_free (o, obstack_base (o));
	  continue;
	}

      if (*s == '#' && s[1] == '!')
	{
	  s += 2;
	  while (isspace ((unsigned char) *s))
	    ++s;
	  if (*s == '\0')
	    {
	      imppath = NULL;
	      impfile = NULL;
	      impmember = NULL;
	      obstack_free (o, obstack_base (o));
	    }
	  else if (*s == '(')
	    einfo ("%F%s%d: #! ([member]) is not supported in import files",
		   filename, lineno);
	  else
	    {
	      char cs;
	      char *file;

	      (void) obstack_finish (o);
	      keep = true;
	      imppath = s;
	      impfile = NULL;
	      while (! isspace ((unsigned char) *s) && *s != '(' && *s != '\0')
		{
		  if (*s == '/')
		    file = s + 1;
		  ++s;
		}
	      if (file != NULL)
		{
		  file[-1] = '\0';
		  impfile = file;
		  if (imppath == file - 1)
		    imppath = "/";
		}
	      else
		{
		  impfile = imppath;
		  imppath = "";
		}
	      cs = *s;
	      *s = '\0';
	      while (isspace ((unsigned char) cs))
		{
		  ++s;
		  cs = *s;
		}
	      if (cs != '(')
		{
		  impmember = "";
		  if (cs != '\0')
		    einfo ("%s:%d: warning: syntax error in import file\n",
			   filename, lineno);
		}
	      else
		{
		  ++s;
		  impmember = s;
		  while (*s != ')' && *s != '\0')
		    ++s;
		  if (*s == ')')
		    *s = '\0';
		  else
		    einfo ("%s:%d: warning: syntax error in import file\n",
			   filename, lineno);
		}
	    }

	  continue;
	}

      /* This is a symbol to be imported or exported.  */
      symname = s;
      syscall = false;
      address = (bfd_vma) -1;

      while (! isspace ((unsigned char) *s) && *s != '\0')
	++s;
      if (*s != '\0')
	{
	  char *se;

	  *s++ = '\0';

	  while (isspace ((unsigned char) *s))
	    ++s;

	  se = s;
	  while (! isspace ((unsigned char) *se) && *se != '\0')
	    ++se;
	  if (*se != '\0')
	    {
	      *se++ = '\0';
	      while (isspace ((unsigned char) *se))
		++se;
	      if (*se != '\0')
		einfo ("%s%d: warning: syntax error in import/export file\n",
		       filename, lineno);
	    }

	  if (strcasecmp (s, "svc") == 0
	      || strcasecmp (s, "syscall") == 0)
	    syscall = true;
	  else
	    {
	      char *end;

	      address = strtoul (s, &end, 0);
	      if (*end != '\0')
		einfo ("%s:%d: warning: syntax error in import/export file\n",
		       filename, lineno);
	    }
	}

      h = bfd_link_hash_lookup (link_info.hash, symname, false, false, true);
      if (h == NULL || h->type == bfd_link_hash_new)
	{
	  /* We can just ignore attempts to import an unreferenced
	     symbol.  */
	  if (! import)
	    einfo ("%X%s:%d: attempt to export undefined symbol %s\n",
		   filename, lineno, symname);
	}
      else if (import)
	{
	  if (! bfd_xcoff_import_symbol (output_bfd, &link_info, h, address,
					 imppath, impfile, impmember))
	    einfo ("%X%s:%d: failed to import symbol %s: %E\n",
		   filename, lineno, symname);
	}
      else
	{
	  if (! bfd_xcoff_export_symbol (output_bfd, &link_info, h, syscall))
	    einfo ("%X%s:%d: failed to export symbol %s: %E\n",
		   filename, lineno, symname);
	}

      obstack_free (o, obstack_base (o));
    }

  if (obstack_object_size (o) > 0)
    {
      einfo ("%s:%d: warning: ignoring unterminated last line\n",
	     filename, lineno);
      obstack_free (o, obstack_base (o));
    }

  if (! keep)
    {
      obstack_free (o, NULL);
      free (o);
    }
}

/* This routine saves us from worrying about declaring free.  */

static void
gld${EMULATION_NAME}_free (p)
     PTR p;
{
  free (p);
}

static char *
gld${EMULATION_NAME}_get_script(isfile)
     int *isfile;
EOF

if test -n "$COMPILE_IN"
then
# Scripts compiled in.

# sed commands to quote an ld script as a C string.
sc="-f ${srcdir}/emultempl/stringify.sed"

cat >>e${EMULATION_NAME}.c <<EOF
{			     
  *isfile = 0;

  if (link_info.relocateable == true && config.build_constructors == true)
    return
EOF
sed $sc ldscripts/${EMULATION_NAME}.xu                     >> e${EMULATION_NAME}.c
echo '  ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
sed $sc ldscripts/${EMULATION_NAME}.xr                     >> e${EMULATION_NAME}.c
echo '  ; else if (!config.text_read_only) return'         >> e${EMULATION_NAME}.c
sed $sc ldscripts/${EMULATION_NAME}.xbn                    >> e${EMULATION_NAME}.c
echo '  ; else if (!config.magic_demand_paged) return'     >> e${EMULATION_NAME}.c
sed $sc ldscripts/${EMULATION_NAME}.xn                     >> e${EMULATION_NAME}.c
echo '  ; else return'                                     >> e${EMULATION_NAME}.c
sed $sc ldscripts/${EMULATION_NAME}.x                      >> e${EMULATION_NAME}.c
echo '; }'                                                 >> e${EMULATION_NAME}.c

else
# Scripts read from the filesystem.

cat >>e${EMULATION_NAME}.c <<EOF
{			     
  *isfile = 1;

  if (link_info.relocateable == true && config.build_constructors == true)
    return "ldscripts/${EMULATION_NAME}.xu";
  else if (link_info.relocateable == true)
    return "ldscripts/${EMULATION_NAME}.xr";
  else if (!config.text_read_only)
    return "ldscripts/${EMULATION_NAME}.xbn";
  else if (!config.magic_demand_paged)
    return "ldscripts/${EMULATION_NAME}.xn";
  else
    return "ldscripts/${EMULATION_NAME}.x";
}
EOF

fi

cat >>e${EMULATION_NAME}.c <<EOF

struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation = 
{
  gld${EMULATION_NAME}_before_parse,
  syslib_default,
  hll_default,
  after_parse_default,
  after_open_default,
  after_allocation_default,
  set_output_arch_default,
  ldemul_default_target,
  gld${EMULATION_NAME}_before_allocation,
  gld${EMULATION_NAME}_get_script,
  "${EMULATION_NAME}",
  "${OUTPUT_FORMAT}",
  0,	/* finish */
  0,	/* create_output_section_statements */
  0,	/* open_dynamic_archive */
  0,	/* place_orphan */
  0,	/* set_symbols */
  gld${EMULATION_NAME}_parse_args,
};
EOF
Commit	Line	Data
57fc1e90 ILT	1	# This shell script emits a C file. -- C --
	2	# It does some substitutions.
	3	cat >e${EMULATION_NAME}.c <<EOF
	4	/* This file is is generated by a shell script. DO NOT EDIT! */
	5
	6	/* AIX emulation code for ${EMULATION_NAME}
	7	Copyright (C) 1991, 1993, 1995 Free Software Foundation, Inc.
	8	Written by Steve Chamberlain <sac@cygnus.com>
	9	AIX support by Ian Lance Taylor <ian@cygnus.com>
	10
	11	This file is part of GLD, the Gnu Linker.
	12
	13	This program is free software; you can redistribute it and/or modify
	14	it under the terms of the GNU General Public License as published by
	15	the Free Software Foundation; either version 2 of the License, or
	16	(at your option) any later version.
	17
	18	This program is distributed in the hope that it will be useful,
	19	but WITHOUT ANY WARRANTY; without even the implied warranty of
	20	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	21	GNU General Public License for more details.
	22
	23	You should have received a copy of the GNU General Public License
	24	along with this program; if not, write to the Free Software
	25	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	26
	27	#define TARGET_IS_${EMULATION_NAME}
	28
	29	#include "bfd.h"
	30	#include "sysdep.h"
	31	#include "libiberty.h"
	32	#include "getopt.h"
	33	#include "bfdlink.h"
	34
	35	#include <ctype.h>
	36
	37	#include "ld.h"
	38	#include "ldmain.h"
	39	#include "ldemul.h"
	40	#include "ldfile.h"
	41	#include "ldmisc.h"
	42	#include "ldexp.h"
	43	#include "ldlang.h"
	44
	45	static void gld${EMULATION_NAME}_before_parse PARAMS ((void));
	46	static int gld${EMULATION_NAME}_parse_args PARAMS ((int, char **));
	47	static void gld${EMULATION_NAME}_before_allocation PARAMS ((void));
	48	static void gld${EMULATION_NAME}_read_file PARAMS ((const char *, boolean));
	49	static void gld${EMULATION_NAME}_free PARAMS ((PTR));
	50	static char gld${EMULATION_NAME}_get_script PARAMS ((int isfile));
	51
	52	/* The file alignment required for each section. */
	53	static unsigned long file_align;
	54
	55	/* The maximum size the stack is permitted to grow. This is stored in
	56	the a.out header. */
	57	static unsigned long maxstack;
	58
	59	/* The maximum data size. This is stored in the a.out header. */
	60	static unsigned long maxdata;
	61
	62	/* Whether to perform garbage collection. */
	63	static int gc = 1;
	64
65	/* The module type to use. */
66	static unsigned short modtype = ('1' << 8) \| 'L';
67
68	/* Whether the .text section must be read-only (i.e., no relocs
69	permitted). */
70	static int textro;
71
72	/* Structure used to hold import or export file list. */
73
74	struct filelist
75	{
76	struct filelist *next;
77	const char *name;
78	};
79
80	/* List of import files. */
81	struct filelist *import_files;
82
83	/* List of export files. */
84	struct filelist *export_files;
85
86	static void
87	gld${EMULATION_NAME}_before_parse()
88	{
89	#ifndef TARGET_ /* I.e., if not generic. */
90	ldfile_output_architecture = bfd_arch_${ARCH};
91	#endif /* not TARGET_ */
92	}
93
94	/* Handle AIX specific options. */
95
96	static int
97	gld${EMULATION_NAME}_parse_args (argc, argv)
98	int argc;
99	char **argv;
100	{
101	int prevoptind = optind;
102	int prevopterr = opterr;
103	int longind;
104	int optc;
105	long val;
106	char *end;
107
108	#define OPTION_IGNORE (300)
109	#define OPTION_AUTOIMP (OPTION_IGNORE + 1)
110	#define OPTION_ERNOTOK (OPTION_AUTOIMP + 1)
111	#define OPTION_EROK (OPTION_ERNOTOK + 1)
112	#define OPTION_EXPORT (OPTION_EROK + 1)
113	#define OPTION_IMPORT (OPTION_EXPORT + 1)
114	#define OPTION_MAXDATA (OPTION_IMPORT + 1)
115	#define OPTION_MAXSTACK (OPTION_MAXDATA + 1)
116	#define OPTION_MODTYPE (OPTION_MAXSTACK + 1)
117	#define OPTION_NOAUTOIMP (OPTION_MODTYPE + 1)
118	#define OPTION_NOSTRCMPCT (OPTION_NOAUTOIMP + 1)
119	#define OPTION_STRCMPCT (OPTION_NOSTRCMPCT + 1)
120
121	static struct option longopts[] = {
122	{"basis", no_argument, NULL, OPTION_IGNORE},
123	{"bautoimp", no_argument, NULL, OPTION_AUTOIMP},
124	{"bcomprld", no_argument, NULL, OPTION_IGNORE},
125	{"bcrld", no_argument, NULL, OPTION_IGNORE},
126	{"bcror31", no_argument, NULL, OPTION_IGNORE},
127	{"bD", required_argument, NULL, OPTION_MAXDATA},
128	{"bE", required_argument, NULL, OPTION_EXPORT},
129	{"bernotok", no_argument, NULL, OPTION_ERNOTOK},
130	{"berok", no_argument, NULL, OPTION_EROK},
131	{"berrmsg", no_argument, NULL, OPTION_IGNORE},
132	{"bexport", required_argument, NULL, OPTION_EXPORT},
133	{"bf", no_argument, NULL, OPTION_ERNOTOK},
134	{"bgc", no_argument, &gc, 1},
135	{"bh", required_argument, NULL, OPTION_IGNORE},
136	{"bhalt", required_argument, NULL, OPTION_IGNORE},
137	{"bI", required_argument, NULL, OPTION_IMPORT},
138	{"bimport", required_argument, NULL, OPTION_IMPORT},
139	{"bmaxdata", required_argument, NULL, OPTION_MAXDATA},
140	{"bmaxstack", required_argument, NULL, OPTION_MAXSTACK},
141	{"bM", required_argument, NULL, OPTION_MODTYPE},
142	{"bmodtype", required_argument, NULL, OPTION_MODTYPE},
143	{"bnoautoimp", no_argument, NULL, OPTION_NOAUTOIMP},
144	{"bnodelcsect", no_argument, NULL, OPTION_IGNORE},
145	{"bnogc", no_argument, &gc, 0},
146	{"bnso", no_argument, NULL, OPTION_NOAUTOIMP},
147	{"bnostrcmpct", no_argument, NULL, OPTION_NOSTRCMPCT},
148	{"bnotextro", no_argument, &textro, 0},
149	{"bnro", no_argument, &textro, 0},
150	{"bro", no_argument, &textro, 1},
151	{"bS", required_argument, NULL, OPTION_MAXSTACK},
152	{"bso", no_argument, NULL, OPTION_AUTOIMP},
153	{"bstrcmpct", no_argument, NULL, OPTION_STRCMPCT},
154	{"btextro", no_argument, &textro, 1},
c7c8b500	155	{"static", no_argument, NULL, OPTION_NOAUTOIMP},
57fc1e90 ILT	156	{NULL, no_argument, NULL, 0}
	157	};
	158
	159	/* Options supported by the AIX linker which we do not support: -f,
	160	-S, -v, -Z, -bbindcmds, -bbinder, -bbindopts, -bcalls, -bcaps,
	161	-bcror15, -bdebugopt, -bdbg, -bdelcsect, -bex?, -bfilelist, -bfl,
	162	-bgcbypass, -bglink, -binsert, -bi, -bloadmap, -bl, -bmap, -bnl,
	163	-bnobind, -bnocomprld, -bnocrld, -bnoerrmsg, -bnoglink,
	164	-bnoloadmap, -bnl, -bnoobjreorder, -bnoquiet, -bnoreorder,
	165	-bnotypchk, -bnox, -bquiet, -bR, -brename, -breorder, -btypchk,
	166	-bx, -bX, -bxref. */
	167
	168	/* If the first option starts with -b, change the first : to an =.
	169	The AIX linker uses : to separate the option from the argument;
	170	changing it to = lets us treat it as a getopt option. */
	171	if (optind < argc && strncmp (argv[optind], "-b", 2) == 0)
	172	{
	173	char *s;
	174
	175	for (s = argv[optind]; *s != '\0'; s++)
	176	{
	177	if (*s == ':')
	178	{
	179	*s = '=';
	180	break;
	181	}
	182	}
	183	}
	184
	185	opterr = 0;
	186	optc = getopt_long_only (argc, argv, "-D:H:KT:z", longopts, &longind);
	187	opterr = prevopterr;
	188
	189	switch (optc)
	190	{
	191	default:
	192	optind = prevoptind;
	193	return 0;
	194
1764521f ILT	195	case 0:
	196	/* Long option which just sets a flag. */
	197	break;
	198
57fc1e90 ILT	199	case 'D':
	200	val = strtol (optarg, &end, 0);
	201	if (*end != '\0')
	202	einfo ("%P: warning: ignoring invalid -D number %s\n", optarg);
	203	else if (val != -1)
	204	lang_section_start (".data", exp_intop (val));
	205	break;
	206
	207	case 'H':
	208	val = strtoul (optarg, &end, 0);
	209	if (*end != '\0'
	210	\|\| (val & (val - 1)) != 0)
	211	einfo ("%P: warning: ignoring invalid -H number %s\n", optarg);
	212	else
	213	file_align = val;
	214	break;
	215
	216	case 'K':
	217	case 'z':
	218	/* FIXME: This should use the page size for the target system. */
	219	file_align = 4096;
	220	break;
	221
	222	case 'T':
	223	/* On AIX this is the same as GNU ld -Ttext. When we see -T
	224	number, we assume the AIX option is intended. Otherwise, we
	225	assume the usual GNU ld -T option is intended. We can't just
	226	ignore the AIX option, because gcc passes it to the linker. */
	227	val = strtoul (optarg, &end, 0);
	228	if (*end != '\0')
	229	{
	230	optind = prevoptind;
	231	return 0;
	232	}
	233	lang_section_start (".text", exp_intop (val));
	234	break;
	235
	236	case OPTION_IGNORE:
	237	break;
	238
	239	case OPTION_AUTOIMP:
	240	link_info.static_link = false;
	241	break;
	242
	243	case OPTION_ERNOTOK:
	244	force_make_executable = false;
	245	break;
	246
	247	case OPTION_EROK:
	248	force_make_executable = true;
	249	break;
	250
	251	case OPTION_EXPORT:
	252	case OPTION_IMPORT:
	253	{
	254	struct filelist *n;
	255	struct filelist **flpp;
	256
	257	n = (struct filelist *) xmalloc (sizeof (struct filelist));
	258	n->next = NULL;
	259	n->name = optarg;
	260	if (optc == OPTION_EXPORT)
	261	flpp = &export_files;
	262	else
263	flpp = &import_files;
264	while (*flpp != NULL)
265	flpp = &(*flpp)->next;
266	*flpp = n;
267	}
268	break;
269
270	case OPTION_MAXDATA:
271	val = strtoul (optarg, &end, 0);
272	if (*end != '\0')
273	einfo ("%P: warning: ignoring invalid -bmaxdata number %s\n",
274	optarg);
275	else
276	maxdata = val;
277	break;
278
279	case OPTION_MAXSTACK:
280	val = strtoul (optarg, &end, 0);
281	if (*end != '\0')
282	einfo ("%P: warning: ignoring invalid -bmaxstack number %s\n",
283	optarg);
284	else
285	maxstack = val;
286	break;
287
288	case OPTION_MODTYPE:
289	if (*optarg == 'S')
290	{
291	link_info.shared = true;
292	++optarg;
293	}
294	if (*optarg == '\0' \|\| optarg[1] == '\0')
295	einfo ("%P: warning: ignoring invalid module type %s\n", optarg);
296	else
297	modtype = (*optarg << 8) \| optarg[1];
298	break;
299
300	case OPTION_NOAUTOIMP:
301	link_info.static_link = true;
302	break;
303
304	case OPTION_NOSTRCMPCT:
305	config.traditional_format = true;
306	break;
307
308	case OPTION_STRCMPCT:
309	config.traditional_format = false;
310	break;
311	}
312
313	return 1;
314	}
315
316	/* This is called after the sections have been attached to output
317	sections, but before any sizes or addresses have been set. */
318
319	static void
320	gld${EMULATION_NAME}_before_allocation ()
321	{
322	struct filelist *fl;
323	char *libpath;
324
325	/* Handle the import and export files, if any. */
326	for (fl = import_files; fl != NULL; fl = fl->next)
327	gld${EMULATION_NAME}_read_file (fl->name, true);
328	for (fl = export_files; fl != NULL; fl = fl->next)
329	gld${EMULATION_NAME}_read_file (fl->name, false);
330
331	/* We need to build LIBPATH from the -L arguments. If any -rpath
332	arguments were used, though, we use -rpath instead, as a GNU
333	extension. */
334	if (command_line.rpath != NULL)
335	libpath = command_line.rpath;
336	else if (search_head == NULL)
337	libpath = (char *) "";
338	else
339	{
340	size_t len;
341	search_dirs_type *search;
342
343	len = strlen (search_head->name);
344	libpath = xmalloc (len + 1);
345	strcpy (libpath, search_head->name);
346	for (search = search_head->next; search != NULL; search = search->next)
347	{
348	size_t nlen;
349
350	nlen = strlen (search->name);
351	libpath = xrealloc (libpath, len + nlen + 2);
352	libpath[len] = ':';
353	strcpy (libpath + len + 1, search->name);
354	len += nlen + 1;
355	}
356	}
357
358	/* Let the XCOFF backend set up the .loader section. */
359	if (! bfd_xcoff_size_dynamic_sections (output_bfd, &link_info, libpath,
360	entry_symbol, file_align,
361	maxstack, maxdata,
362	gc ? true : false,
363	modtype,
364	textro ? true : false))
365	einfo ("%P%F: failed to set dynamic section sizes: %E\n");
366	}
367
368	/* Read an import or export file. */
369
370	static void
371	gld${EMULATION_NAME}_read_file (filename, import)
372	const char *filename;
373	boolean import;
374	{
375	struct obstack *o;
376	FILE *f;
377	int lineno;
378	int c;
379	boolean keep;
380	const char *imppath;
381	const char *impfile;
382	const char *impmember;
383
384	o = (struct obstack *) xmalloc (sizeof (struct obstack));
385	obstack_specify_allocation (o, 0, 0, xmalloc, gld${EMULATION_NAME}_free);
386
387	f = fopen (filename, "r");
388	if (f == NULL)
389	{
390	bfd_set_error (bfd_error_system_call);
391	einfo ("%F%s: %E\n", filename);
392	}
393
394	keep = false;
395
396	imppath = NULL;
397	impfile = NULL;
398	impmember = NULL;
399
400	lineno = 0;
401	while ((c = getc (f)) != EOF)
402	{
403	char *s;
404	char *symname;
405	boolean syscall;
406	bfd_vma address;
407	struct bfd_link_hash_entry *h;
408
409	if (c != '\n')
410	{
411	obstack_1grow (o, c);
412	continue;
413	}
414
415	obstack_1grow (o, '\0');
416	++lineno;
417
418	s = (char *) obstack_base (o);
419	while (isspace ((unsigned char) *s))
420	++s;
421	if (*s == '\0'
422	\|\| s == ''
423	\|\| (*s == '#' && s[1] == ' ')
424	\|\| (! import && *s == '#' && s[1] == '!'))
425	{
426	obstack_free (o, obstack_base (o));
427	continue;
428	}
429
430	if (*s == '#' && s[1] == '!')
431	{
432	s += 2;
433	while (isspace ((unsigned char) *s))
434	++s;
435	if (*s == '\0')
436	{
437	imppath = NULL;
438	impfile = NULL;
439	impmember = NULL;
440	obstack_free (o, obstack_base (o));
441	}
442	else if (*s == '(')
443	einfo ("%F%s%d: #! ([member]) is not supported in import files",
444	filename, lineno);
445	else
446	{
447	char cs;
448	char *file;
449
450	(void) obstack_finish (o);
451	keep = true;
452	imppath = s;
453	impfile = NULL;
454	while (! isspace ((unsigned char) s) && s != '(' && *s != '\0')
455	{
456	if (*s == '/')
457	file = s + 1;
458	++s;
459	}
460	if (file != NULL)
461	{
462	file[-1] = '\0';
463	impfile = file;
464	if (imppath == file - 1)
465	imppath = "/";
466	}
467	else
468	{
469	impfile = imppath;
470	imppath = "";
471	}
472	cs = *s;
473	*s = '\0';
474	while (isspace ((unsigned char) cs))
475	{
476	++s;
477	cs = *s;
478	}
479	if (cs != '(')
480	{
481	impmember = "";
482	if (cs != '\0')
483	einfo ("%s:%d: warning: syntax error in import file\n",
484	filename, lineno);
485	}
486	else
487	{
488	++s;
489	impmember = s;
490	while (s != ')' && s != '\0')
491	++s;
492	if (*s == ')')
493	*s = '\0';
494	else
495	einfo ("%s:%d: warning: syntax error in import file\n",
496	filename, lineno);
497	}
498	}
499
500	continue;
501	}
502
503	/* This is a symbol to be imported or exported. */
504	symname = s;
505	syscall = false;
506	address = (bfd_vma) -1;
507
508	while (! isspace ((unsigned char) s) && s != '\0')
509	++s;
510	if (*s != '\0')
511	{
512	char *se;
513
514	*s++ = '\0';
515
516	while (isspace ((unsigned char) *s))
517	++s;
518
519	se = s;
520	while (! isspace ((unsigned char) se) && se != '\0')
521	++se;
522	if (*se != '\0')
523	{
524	*se++ = '\0';
525	while (isspace ((unsigned char) *se))
526	++se;
527	if (*se != '\0')
528	einfo ("%s%d: warning: syntax error in import/export file\n",
529	filename, lineno);
530	}
531
532	if (strcasecmp (s, "svc") == 0
533	\|\| strcasecmp (s, "syscall") == 0)
534	syscall = true;
535	else
536	{
537	char *end;
538
539	address = strtoul (s, &end, 0);
540	if (*end != '\0')
541	einfo ("%s:%d: warning: syntax error in import/export file\n",
542	filename, lineno);
543	}
544	}
545
546	h = bfd_link_hash_lookup (link_info.hash, symname, false, false, true);
547	if (h == NULL \|\| h->type == bfd_link_hash_new)
548	{
549	/* We can just ignore attempts to import an unreferenced
550	symbol. */
551	if (! import)
552	einfo ("%X%s:%d: attempt to export undefined symbol %s\n",
553	filename, lineno, symname);
554	}
555	else if (import)
556	{
557	if (! bfd_xcoff_import_symbol (output_bfd, &link_info, h, address,
558	imppath, impfile, impmember))
559	einfo ("%X%s:%d: failed to import symbol %s: %E\n",
560	filename, lineno, symname);
561	}
562	else
563	{
564	if (! bfd_xcoff_export_symbol (output_bfd, &link_info, h, syscall))
565	einfo ("%X%s:%d: failed to export symbol %s: %E\n",
566	filename, lineno, symname);
567	}
568
569	obstack_free (o, obstack_base (o));
570	}
571
572	if (obstack_object_size (o) > 0)
573	{
574	einfo ("%s:%d: warning: ignoring unterminated last line\n",
575	filename, lineno);
576	obstack_free (o, obstack_base (o));
577	}
578
579	if (! keep)
580	{
581	obstack_free (o, NULL);
582	free (o);
583	}
584	}
585
586	/* This routine saves us from worrying about declaring free. */
587
588	static void
589	gld${EMULATION_NAME}_free (p)
590	PTR p;
591	{
592	free (p);
593	}
594
595	static char *
596	gld${EMULATION_NAME}_get_script(isfile)
597	int *isfile;
598	EOF
599
600	if test -n "$COMPILE_IN"
601	then
602	# Scripts compiled in.
603
604	# sed commands to quote an ld script as a C string.
605	sc="-f ${srcdir}/emultempl/stringify.sed"
606
607	cat >>e${EMULATION_NAME}.c <<EOF
608	{
609	*isfile = 0;
610
611	if (link_info.relocateable == true && config.build_constructors == true)
612	return
613	EOF
614	sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
615	echo ' ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
616	sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
617	echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
618	sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
619	echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
620	sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
621	echo ' ; else return' >> e${EMULATION_NAME}.c
622	sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
623	echo '; }' >> e${EMULATION_NAME}.c
624
625	else
626	# Scripts read from the filesystem.
627
628	cat >>e${EMULATION_NAME}.c <<EOF
629	{
630	*isfile = 1;
631
632	if (link_info.relocateable == true && config.build_constructors == true)
633	return "ldscripts/${EMULATION_NAME}.xu";
634	else if (link_info.relocateable == true)
635	return "ldscripts/${EMULATION_NAME}.xr";
636	else if (!config.text_read_only)
637	return "ldscripts/${EMULATION_NAME}.xbn";
638	else if (!config.magic_demand_paged)
639	return "ldscripts/${EMULATION_NAME}.xn";
640	else
641	return "ldscripts/${EMULATION_NAME}.x";
642	}
643	EOF
644
645	fi
646
647	cat >>e${EMULATION_NAME}.c <<EOF
648
649	struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
650	{
651	gld${EMULATION_NAME}_before_parse,
652	syslib_default,
653	hll_default,
654	after_parse_default,
655	after_open_default,
656	after_allocation_default,
657	set_output_arch_default,
658	ldemul_default_target,
659	gld${EMULATION_NAME}_before_allocation,
660	gld${EMULATION_NAME}_get_script,
661	"${EMULATION_NAME}",
662	"${OUTPUT_FORMAT}",
663	0, /* finish */
664	0, /* create_output_section_statements */
665	0, /* open_dynamic_archive */
666	0, /* place_orphan */
667	0, /* set_symbols */
668	gld${EMULATION_NAME}_parse_args,
669	};
670	EOF