[binutils.git] / ld / emultempl / lnk960.em

# This shell script emits a C file. -*- C -*-
# It does some substitutions.
cat >e${EMULATION_NAME}.c <<EOF
/* intel coff loader emulation specific stuff
   Copyright (C) 1991, 93, 94, 95, 96, 1999 Free Software Foundation, Inc.
   Written by Steve Chamberlain [email protected]

This file is part of GLD, the Gnu Linker.

GLD 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, or (at your option)
any later version.

GLD 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 GLD; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

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

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

typedef struct lib_list {
  char *name;
  struct lib_list *next;
} lib_list_type;

static lib_list_type *hll_list;
static lib_list_type **hll_list_tail = &hll_list;

static lib_list_type *syslib_list;
static lib_list_type **syslib_list_tail = &syslib_list;


static void
append(list, name)
     lib_list_type ***list;
     char *name;
{
  lib_list_type *element = 
    (lib_list_type *)(xmalloc(sizeof(lib_list_type)));

  element->name = name;
  element->next = (lib_list_type *)NULL;
  **list = element;
  *list = &element->next;

}

static boolean had_hll = false;
static boolean had_hll_name = false;

static void
lnk960_hll(name)
     char *name;
{
  had_hll = true;
  if (name != (char *)NULL) {
    had_hll_name = true;
    append(&hll_list_tail, name);
  }
}

static void 
lnk960_syslib(name)
     char *name;
{
  append(&syslib_list_tail,name);
}


#ifdef GNU960

static void 
lnk960_before_parse()
{
  static char *env_variables[] = { "G960LIB", "G960BASE", 0 };
  char **p;
  char *env ;

  for ( p = env_variables; *p; p++ ){
    env =  (char *) getenv(*p);
    if (env) {
      ldfile_add_library_path(concat(env,"/lib/libcoff",""), false);
    }
  }

  env= (char *) getenv("I960BASE");
  if ( env ) {
    ldfile_add_library_path(concat(env,"/lib",""), false);
  }

  ldfile_output_architecture = bfd_arch_i960;
  ldfile_output_machine = bfd_mach_i960_core;
}

#else	/* not GNU960 */

static void 
lnk960_before_parse()
{
  char *name = getenv("I960BASE");

  if (name == (char *)NULL) {
    name = getenv("G960BASE");
    if (name == (char *)NULL) {
      einfo("%P%F I960BASE and G960BASE not set\n");
    }
  }


  ldfile_add_library_path(concat(name,"/lib",""), false);
  ldfile_output_architecture = bfd_arch_i960;
  ldfile_output_machine = bfd_mach_i960_core;
}

#endif	/* GNU960 */


static void
add_on(list, search)
     lib_list_type *list;
     lang_input_file_enum_type search;
{
  while (list) {
    lang_add_input_file(list->name,
			search,
			(char *)NULL);
    list = list->next;
  }
}
static void
lnk960_after_parse()
{
  /* If there has been no arch, default to -KB */
  if (ldfile_output_machine_name[0] ==0) {
    ldfile_add_arch("KB");
  }

  /* if there has been no hll list then add our own */
  
  if(had_hll && !had_hll_name) {
    append(&hll_list_tail,"cg");
    if (ldfile_output_machine == bfd_mach_i960_ka_sa ||
  	ldfile_output_machine == bfd_mach_i960_ca) {
        {
	  append(&hll_list_tail,"fpg");
        }
    }
  }
  
  add_on(hll_list, lang_input_file_is_l_enum);
  add_on(syslib_list, lang_input_file_is_search_file_enum);
}

static void
lnk960_before_allocation()
{
}

static void
lnk960_after_allocation()
{
  if (link_info.relocateable == false) {
    lang_abs_symbol_at_end_of(".text","_etext");
    lang_abs_symbol_at_end_of(".data","_edata");
    lang_abs_symbol_at_beginning_of(".bss","_bss_start");
    lang_abs_symbol_at_end_of(".bss","_end");
  }
}


static struct
 {
   unsigned  long number;
   char *name; 
 }
machine_table[] =
{
  { bfd_mach_i960_core	,"CORE" },
  { bfd_mach_i960_kb_sb	,"KB" },
  { bfd_mach_i960_kb_sb	,"SB" },
  { bfd_mach_i960_mc	,"MC" },
  { bfd_mach_i960_xa	,"XA" },
  { bfd_mach_i960_ca	,"CA" },
  { bfd_mach_i960_ka_sa	,"KA" },
  { bfd_mach_i960_ka_sa	,"SA" },
  { bfd_mach_i960_jx	,"JX" },
  { bfd_mach_i960_hx	,"HX" },

  { bfd_mach_i960_core	,"core" },
  { bfd_mach_i960_kb_sb	,"kb" },
  { bfd_mach_i960_kb_sb	,"sb" },
  { bfd_mach_i960_mc	,"mc" },
  { bfd_mach_i960_xa	,"xa" },
  { bfd_mach_i960_ca	,"ca" },
  { bfd_mach_i960_ka_sa	,"ka" },
  { bfd_mach_i960_ka_sa	,"sa" },
  { bfd_mach_i960_jx	,"jx" },
  { bfd_mach_i960_hx	,"hx" },

  { 0, (char *) NULL }
};

static void
lnk960_set_output_arch()
{
  /* Set the output architecture and machine if possible */
  unsigned int i;
  ldfile_output_machine = bfd_mach_i960_core;
  for (i= 0; machine_table[i].name != (char*)NULL; i++) {
    if (strcmp(ldfile_output_machine_name,machine_table[i].name)==0) {
      ldfile_output_machine = machine_table[i].number;
      break;
    }
  }
  bfd_set_arch_mach(output_bfd, ldfile_output_architecture, ldfile_output_machine);
}

static char *
lnk960_choose_target()
{
#ifdef GNU960

  return bfd_make_targ_name(BFD_COFF_FORMAT, 0);

#else

  char *from_outside = getenv(TARGET_ENVIRON);
  if (from_outside != (char *)NULL)
    return from_outside;
#ifdef LNK960_LITTLE
  return "coff-Intel-little";
#else
  return "coff-Intel-big";
#endif
#endif

}

static char *
lnk960_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 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_lnk960_emulation = 
{
  lnk960_before_parse,
  lnk960_syslib,
  lnk960_hll,
  lnk960_after_parse,
  NULL,			/* after_open */
  lnk960_after_allocation,
  lnk960_set_output_arch,
  lnk960_choose_target,
  lnk960_before_allocation,
  lnk960_get_script,
  "lnk960",
  "",
  NULL,	/* finish */
  NULL,	/* create output section statements */
  NULL,	/* open dynamic archive */
  NULL,	/* place orphan */
  NULL,	/* set symbols */
  NULL,	/* parse args */
  NULL,	/* unrecognized file */
  NULL,	/* list options */
  NULL,	/* recognized file */
  NULL 	/* find_potential_libraries */
};
EOF
Commit	Line	Data
252b5132 RH	1	# This shell script emits a C file. -- C --
	2	# It does some substitutions.
	3	cat >e${EMULATION_NAME}.c <<EOF
	4	/* intel coff loader emulation specific stuff
597e2591	5	Copyright (C) 1991, 93, 94, 95, 96, 1999 Free Software Foundation, Inc.
252b5132 RH	6	Written by Steve Chamberlain [email protected]
	7
	8	This file is part of GLD, the Gnu Linker.
	9
	10	GLD is free software; you can redistribute it and/or modify
	11	it under the terms of the GNU General Public License as published by
	12	the Free Software Foundation; either version 2, or (at your option)
	13	any later version.
	14
	15	GLD is distributed in the hope that it will be useful,
	16	but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	GNU General Public License for more details.
	19
	20	You should have received a copy of the GNU General Public License
	21	along with GLD; see the file COPYING. If not, write to
	22	the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	23
	24	#include "libiberty.h"
	25	#include "bfd.h"
	26	#include "sysdep.h"
	27	#include "bfdlink.h"
	28
	29	/#include "archures.h"/
	30	#include "ld.h"
	31	#include "ldemul.h"
	32	#include "ldmisc.h"
	33	#include "ldexp.h"
	34	#include "ldlang.h"
	35	#include "ldfile.h"
	36	#include "ldmain.h"
	37
	38	typedef struct lib_list {
	39	char *name;
	40	struct lib_list *next;
	41	} lib_list_type;
	42
	43	static lib_list_type *hll_list;
	44	static lib_list_type **hll_list_tail = &hll_list;
	45
	46	static lib_list_type *syslib_list;
	47	static lib_list_type **syslib_list_tail = &syslib_list;
	48
	49
	50	static void
	51	append(list, name)
	52	lib_list_type ***list;
	53	char *name;
	54	{
	55	lib_list_type *element =
	56	(lib_list_type *)(xmalloc(sizeof(lib_list_type)));
	57
	58	element->name = name;
	59	element->next = (lib_list_type *)NULL;
	60	**list = element;
	61	*list = &element->next;
	62
	63	}
	64
	65	static boolean had_hll = false;
	66	static boolean had_hll_name = false;
	67
	68	static void
	69	lnk960_hll(name)
70	char *name;
71	{
72	had_hll = true;
73	if (name != (char *)NULL) {
74	had_hll_name = true;
75	append(&hll_list_tail, name);
76	}
77	}
78
79	static void
80	lnk960_syslib(name)
81	char *name;
82	{
83	append(&syslib_list_tail,name);
84	}
85
86
87	#ifdef GNU960
88
89	static void
90	lnk960_before_parse()
91	{
92	static char *env_variables[] = { "G960LIB", "G960BASE", 0 };
93	char **p;
94	char *env ;
95
96	for ( p = env_variables; *p; p++ ){
97	env = (char ) getenv(p);
98	if (env) {
99	ldfile_add_library_path(concat(env,"/lib/libcoff",""), false);
100	}
101	}
102
103	env= (char *) getenv("I960BASE");
104	if ( env ) {
105	ldfile_add_library_path(concat(env,"/lib",""), false);
106	}
107
108	ldfile_output_architecture = bfd_arch_i960;
109	ldfile_output_machine = bfd_mach_i960_core;
110	}
111
112	#else /* not GNU960 */
113
114	static void
115	lnk960_before_parse()
116	{
117	char *name = getenv("I960BASE");
118
119	if (name == (char *)NULL) {
120	name = getenv("G960BASE");
121	if (name == (char *)NULL) {
122	einfo("%P%F I960BASE and G960BASE not set\n");
123	}
124	}
125
126
127	ldfile_add_library_path(concat(name,"/lib",""), false);
128	ldfile_output_architecture = bfd_arch_i960;
129	ldfile_output_machine = bfd_mach_i960_core;
130	}
131
132	#endif /* GNU960 */
133
134
135	static void
136	add_on(list, search)
137	lib_list_type *list;
138	lang_input_file_enum_type search;
139	{
140	while (list) {
141	lang_add_input_file(list->name,
142	search,
143	(char *)NULL);
144	list = list->next;
145	}
146	}
147	static void
148	lnk960_after_parse()
149	{
150	/* If there has been no arch, default to -KB */
151	if (ldfile_output_machine_name[0] ==0) {
152	ldfile_add_arch("KB");
153	}
154
155	/* if there has been no hll list then add our own */
156
157	if(had_hll && !had_hll_name) {
158	append(&hll_list_tail,"cg");
159	if (ldfile_output_machine == bfd_mach_i960_ka_sa \|\|
160	ldfile_output_machine == bfd_mach_i960_ca) {
161	{
162	append(&hll_list_tail,"fpg");
163	}
164	}
165	}
166
167	add_on(hll_list, lang_input_file_is_l_enum);
168	add_on(syslib_list, lang_input_file_is_search_file_enum);
169	}
170
171	static void
172	lnk960_before_allocation()
173	{
174	}
175
176	static void
177	lnk960_after_allocation()
178	{
179	if (link_info.relocateable == false) {
180	lang_abs_symbol_at_end_of(".text","_etext");
181	lang_abs_symbol_at_end_of(".data","_edata");
182	lang_abs_symbol_at_beginning_of(".bss","_bss_start");
183	lang_abs_symbol_at_end_of(".bss","_end");
184	}
185	}
186
187
188	static struct
189	{
190	unsigned long number;
191	char *name;
192	}
193	machine_table[] =
194	{
195	{ bfd_mach_i960_core ,"CORE" },
196	{ bfd_mach_i960_kb_sb ,"KB" },
197	{ bfd_mach_i960_kb_sb ,"SB" },
198	{ bfd_mach_i960_mc ,"MC" },
199	{ bfd_mach_i960_xa ,"XA" },
200	{ bfd_mach_i960_ca ,"CA" },
201	{ bfd_mach_i960_ka_sa ,"KA" },
202	{ bfd_mach_i960_ka_sa ,"SA" },
203	{ bfd_mach_i960_jx ,"JX" },
204	{ bfd_mach_i960_hx ,"HX" },
205
206	{ bfd_mach_i960_core ,"core" },
207	{ bfd_mach_i960_kb_sb ,"kb" },
208	{ bfd_mach_i960_kb_sb ,"sb" },
209	{ bfd_mach_i960_mc ,"mc" },
210	{ bfd_mach_i960_xa ,"xa" },
211	{ bfd_mach_i960_ca ,"ca" },
212	{ bfd_mach_i960_ka_sa ,"ka" },
213	{ bfd_mach_i960_ka_sa ,"sa" },
214	{ bfd_mach_i960_jx ,"jx" },
215	{ bfd_mach_i960_hx ,"hx" },
216
217	{ 0, (char *) NULL }
218	};
219
220	static void
221	lnk960_set_output_arch()
222	{
223	/* Set the output architecture and machine if possible */
224	unsigned int i;
225	ldfile_output_machine = bfd_mach_i960_core;
226	for (i= 0; machine_table[i].name != (char*)NULL; i++) {
227	if (strcmp(ldfile_output_machine_name,machine_table[i].name)==0) {
228	ldfile_output_machine = machine_table[i].number;
229	break;
230	}
231	}
232	bfd_set_arch_mach(output_bfd, ldfile_output_architecture, ldfile_output_machine);
233	}
234
235	static char *
236	lnk960_choose_target()
237	{
238	#ifdef GNU960
239
240	return bfd_make_targ_name(BFD_COFF_FORMAT, 0);
241
242	#else
243
244	char *from_outside = getenv(TARGET_ENVIRON);
245	if (from_outside != (char *)NULL)
246	return from_outside;
247	#ifdef LNK960_LITTLE
248	return "coff-Intel-little";
249	#else
250	return "coff-Intel-big";
251	#endif
252	#endif
253
254	}
255
256	static char *
257	lnk960_get_script(isfile)
258	int *isfile;
259	EOF
260
261	if test -n "$COMPILE_IN"
262	then
263	# Scripts compiled in.
264
265	# sed commands to quote an ld script as a C string.
597e2591	266	sc="-f stringify.sed"
252b5132 RH	267
252b5132 RH	268	cat >>e${EMULATION_NAME}.c <<EOF
597e2591	269	{
252b5132 RH	270	*isfile = 0;
	271
	272	if (link_info.relocateable == true && config.build_constructors == true)
597e2591	273	return
252b5132	274	EOF
597e2591 ILT	275	sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
	276	echo ' ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
	277	sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
	278	echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
	279	sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
	280	echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
	281	sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
	282	echo ' ; else return' >> e${EMULATION_NAME}.c
	283	sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
	284	echo '; }' >> e${EMULATION_NAME}.c
252b5132 RH	285
	286	else
	287	# Scripts read from the filesystem.
	288
	289	cat >>e${EMULATION_NAME}.c <<EOF
	290	{
	291	*isfile = 1;
	292
	293	if (link_info.relocateable == true && config.build_constructors == true)
	294	return "ldscripts/${EMULATION_NAME}.xu";
	295	else if (link_info.relocateable == true)
	296	return "ldscripts/${EMULATION_NAME}.xr";
	297	else if (!config.text_read_only)
	298	return "ldscripts/${EMULATION_NAME}.xbn";
	299	else if (!config.magic_demand_paged)
	300	return "ldscripts/${EMULATION_NAME}.xn";
	301	else
	302	return "ldscripts/${EMULATION_NAME}.x";
	303	}
	304	EOF
	305
	306	fi
	307
	308	cat >>e${EMULATION_NAME}.c <<EOF
	309
	310	struct ld_emulation_xfer_struct ld_lnk960_emulation =
	311	{
	312	lnk960_before_parse,
	313	lnk960_syslib,
	314	lnk960_hll,
	315	lnk960_after_parse,
	316	NULL, /* after_open */
	317	lnk960_after_allocation,
	318	lnk960_set_output_arch,
	319	lnk960_choose_target,
	320	lnk960_before_allocation,
	321	lnk960_get_script,
	322	"lnk960",
e1c47aa4 AM	323	"",
	324	NULL, /* finish */
	325	NULL, /* create output section statements */
	326	NULL, /* open dynamic archive */
	327	NULL, /* place orphan */
	328	NULL, /* set symbols */
	329	NULL, /* parse args */
	330	NULL, /* unrecognized file */
	331	NULL, /* list options */
40d109bf AM	332	NULL, /* recognized file */
40d109bf AM	333	NULL /* find_potential_libraries */
252b5132 RH	334	};
252b5132 RH	335	EOF