[binutils.git] / binutils / strip.c

/* strip.c -- strip certain symbols from a rel file.
   Copyright (C) 1986, 1990, 1991 Free Software Foundation, Inc.

   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, 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* BUGS: When there's not enough memory, this should do the copy
   in pieces rather than just fail as it does now */

#include "bfd.h"
#include "sysdep.h"
#include "getopt.h"
#include <signal.h>

/* Various program options */

int show_version = 0;

/* Which symbols to remove. */
enum strip_action {
  strip_undef,
  strip_all,			/* strip all symbols */
  strip_debug,			/* strip all debugger symbols */
} strip_symbols;

/* Which local symbols to remove. */
enum {
  locals_undef,
  locals_start_L,		/* discard locals starting with L */
  locals_all,			/* discard all locals */
} discard_locals;

extern char *mktemp();

/* IMPORTS */
extern char *program_version;
extern char *program_name;
extern char *target;
extern char *xmalloc();

PROTO(static boolean, strip_file, (char *filetostrip));
PROTO(static void, copy_sections, (bfd *ibfd, sec_ptr isection, bfd *obfd));
PROTO(static void, setup_sections, (bfd *ibfd, sec_ptr isection, bfd *obfd));
\f
/** main, etc */

static void
usage ()
{
  fprintf (stderr, "strip %s\nUsage: %s [-gsxSX] files ...\n",
	   program_version, program_name);
  exit (1);
}

struct option long_options[] = {{"strip-all", 0, 0, 's'},
				{"strip-debug", 0, 0, 'S'},
				{"discard-all", 0, 0, 'x'},
				{"discard-locals", 0, 0, 'X'},
				{0, 0, 0, 0}
				};

int
main (argc, argv)
     char **argv;
     int argc;
{
  int ind;
  int c;
  program_name = argv[0];
	
  bfd_init();

  strip_symbols = strip_undef;	/* default is to strip everything.  */
  discard_locals = locals_undef;
	
  while ((c = getopt_long (argc, argv, "gsST:xX", long_options, &ind)) != EOF) {
    switch (c) {
    case 0:
      break;
    case 's':
      strip_symbols = strip_all;
      break;
    case 'g':
    case 'S':
      strip_symbols = strip_debug;
      break;
    case 'T':
      target = optarg;
      break;
    case 'x':
      discard_locals = locals_all;
      break;
    case 'X':
      discard_locals = locals_start_L;
      break;
    default:
      usage ();
    }
  }

  /* Default is to strip all symbols: */
  if (strip_symbols == strip_undef && discard_locals == locals_undef) {
    strip_symbols = strip_all;
  }

  /* OK, all options now parsed.  If no filename specified, do a.out. */
  if (optind == argc) return !strip_file ("a.out");
  
  /* We were given several filenames to do: */
  while (optind < argc)
    if (!strip_file (argv[optind++])) return 1;

  return 0;
}
\f
/** Hack signals */

/* Why does strip need to do this, and anyway, if it does shouldn't this be
   handled by bfd? */

static int delayed_signal;

static int sigint_handled = 0;
static int sighup_handled = 0;
static int sigterm_handled = 0;

void
delay_signal (signo)
     int signo;
{
  delayed_signal = signo;
  signal (signo, delay_signal);
}

/* Effectively defer handling of asynchronous kill signals.  */
void
handle_sigs ()			/* puff puff */
{
  delayed_signal = 0;
	
  if (signal (SIGINT, SIG_IGN) != SIG_IGN) {
    sigint_handled = 1;
    signal (SIGINT, delay_signal);
  }
	
  if (signal (SIGHUP, SIG_IGN) != SIG_IGN) {
    sighup_handled = 1;
    signal (SIGHUP, delay_signal);
  }
	
  if (signal (SIGTERM, SIG_IGN) != SIG_IGN) {
    sigterm_handled = 1;
    signal (SIGTERM, delay_signal);
  }
	
  return;
}

/* Effectively undefer handling.  */
void
unhandle_sigs ()		/* put them down */
{
  if (sigint_handled) signal (SIGINT, SIG_DFL);

  if (sighup_handled) signal (SIGHUP, SIG_DFL);

  if (sigterm_handled) signal (SIGTERM, SIG_DFL);
	
  /* Handle any signal that came in while they were deferred.  */
  if (delayed_signal)
    kill (getpid (), delayed_signal);
	
  return;
}
\f

static boolean
strip_file (filetostrip)
     char *filetostrip;
{
  static char template[] = "stXXXXXX";
  char *slash;
  char *tmpname;
  bfd *ibfd;
  bfd *obfd;

  ibfd = bfd_openr (filetostrip, target);

  if (ibfd == NULL) bfd_fatal (filetostrip);

  handle_sigs ();		/* light up */

  if (!bfd_check_format (ibfd, bfd_object)) {
    fprintf (stderr, "Can't strip %s file %s.\n",
	     bfd_format_string (bfd_get_format (ibfd)), filetostrip);
    exit (1);
  }

  slash = strrchr( filetostrip, '/' );
  if ( slash ){
    *slash = 0;
    tmpname = xmalloc( strlen(filetostrip) + sizeof(template) + 1 );
    strcpy( tmpname, filetostrip );
    strcat( tmpname, "/" );
    strcat( tmpname, template );
    mktemp( tmpname );
    *slash = '/';
  } else {
    tmpname = xmalloc( sizeof(template) );
    strcpy( tmpname, template );
    mktemp( tmpname );
  }

  obfd = bfd_openw (mktemp(tmpname), (target ? target : bfd_get_target (ibfd)));
  if (obfd == NULL) bfd_fatal (tmpname);

  if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
    bfd_fatal (tmpname);


  if ((bfd_set_start_address (obfd, bfd_get_start_address (ibfd)) == false) ||
      (bfd_set_file_flags (obfd, (bfd_get_file_flags (ibfd) &
				  ~(HAS_LINENO | HAS_DEBUG | HAS_SYMS |
				    HAS_LOCALS))) == false) ||
      bfd_set_start_address (obfd, bfd_get_start_address (ibfd)) == false)
    bfd_fatal (bfd_get_filename (ibfd));

   /* Copy architecture of input file to output file */
   if (!bfd_set_arch_mach (obfd, bfd_get_architecture (ibfd),
 			       bfd_get_machine (ibfd))) {
     fprintf(stderr, "Output file cannot represent architecture %s",
 	bfd_printable_arch_mach (bfd_get_architecture(ibfd),
 				 bfd_get_machine (ibfd)));
   }
 

  /* bfd mandates that all output sections be created and sizes set before
     any output is done.  Thus, we traverse all sections twice.  */
  bfd_map_over_sections (ibfd, setup_sections, (void *)obfd);
  bfd_map_over_sections (ibfd, copy_sections, (void *)obfd);

  if (!bfd_close (obfd)) bfd_fatal (filetostrip);
  if (!bfd_close (ibfd)) bfd_fatal (filetostrip);

  rename(tmpname, filetostrip);
  free(tmpname);

  unhandle_sigs();

  return true;
}
\f
/** Actually do the work */
static void
setup_sections (ibfd, isection, obfd)
     bfd *ibfd;
     sec_ptr isection;
     bfd *obfd;
{
  sec_ptr osection;
  char *err;

  osection = bfd_make_section (obfd, bfd_section_name (ibfd, isection));
  if (osection == NULL) {
      err = "making";
      goto loser;
    }

  if (!bfd_set_section_size(obfd, osection, bfd_section_size(ibfd, isection))) {
     err = "size";
     goto loser;
  }

  if (!bfd_set_section_vma (obfd, osection, bfd_section_vma (ibfd, isection))) {
     err = "vma";
     goto loser;
  }

  if (bfd_set_section_alignment (obfd, osection,
			     bfd_section_alignment (ibfd, isection))
      != true) {
	  err = "alignment";
	  goto loser;
  } /* on error, I presume. */

  if (!bfd_set_section_flags (obfd, osection,
			      bfd_get_section_flags (ibfd, isection))) {
     err = "flags";
     goto loser;
  }

  /* All went well */
  return;
  
 loser:
  fprintf (stderr, "%s: file \"%s\", section \"%s\": error in %s: %s\n",
	   program_name,
	   bfd_get_filename (ibfd), bfd_section_name (ibfd, isection),
	   err, bfd_errmsg (bfd_error));
  exit (1);
}

static void
copy_sections (ibfd, isection, obfd)
     bfd *ibfd;
     sec_ptr isection;
     bfd *obfd;
{
  static unsigned char *memhunk = NULL;
  static unsigned memhunksize = 0;

  sec_ptr osection;
  unsigned long size;
  flagword iflg;
  unsigned char *temp;

  osection = bfd_get_section_by_name (obfd, bfd_section_name (ibfd, isection));

  size = bfd_section_size (ibfd, isection);
  iflg = bfd_get_section_flags (ibfd, isection);

  /* either:
     we don't need any memory because there's nothing in this section,
     we had no memory so we got some,
     we had some memory but not enough so we got more,
     or we fail to allocat. */

  if (size == 0)
     return;

  if ((iflg & SEC_HAS_CONTENTS) == 0)
      return;

  if (memhunk == NULL) {
     memhunk = (unsigned char *) xmalloc (size);
     memhunksize = size;
  }

  if (size > memhunksize) {
     temp = (unsigned char *) xrealloc ((char *) memhunk, size);
     memhunksize = size;
     memhunk = temp;
  }

  /* now we have enough memory, just do it: */
  if (!bfd_get_section_contents (ibfd, isection, memhunk, 0, size))
     bfd_fatal (bfd_get_filename (ibfd));

  if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
     bfd_fatal (bfd_get_filename (obfd));
}
Commit	Line	Data
d8474a9b PB	1	/* strip.c -- strip certain symbols from a rel file.
d8474a9b PB	2	Copyright (C) 1986, 1990, 1991 Free Software Foundation, Inc.
c074abee DHW	3
	4	This program is free software; you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
d8474a9b	6	the Free Software Foundation; either version 2, or (at your option)
c074abee DHW	7	any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with this program; if not, write to the Free Software
	16	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	17
	18	/* BUGS: When there's not enough memory, this should do the copy
	19	in pieces rather than just fail as it does now */
	20
c074abee	21	#include "bfd.h"
2a5f387b	22	#include "sysdep.h"
c074abee	23	#include "getopt.h"
c074abee DHW	24	#include <signal.h>
	25
	26	/* Various program options */
	27
	28	int show_version = 0;
	29
	30	/* Which symbols to remove. */
	31	enum strip_action {
	32	strip_undef,
	33	strip_all, /* strip all symbols */
	34	strip_debug, /* strip all debugger symbols */
	35	} strip_symbols;
	36
	37	/* Which local symbols to remove. */
	38	enum {
	39	locals_undef,
	40	locals_start_L, /* discard locals starting with L */
	41	locals_all, /* discard all locals */
	42	} discard_locals;
	43
	44	extern char *mktemp();
	45
	46	/* IMPORTS */
	47	extern char *program_version;
	48	extern char *program_name;
	49	extern char *target;
	50	extern char *xmalloc();
	51
	52	PROTO(static boolean, strip_file, (char *filetostrip));
	53	PROTO(static void, copy_sections, (bfd ibfd, sec_ptr isection, bfd obfd));
	54	PROTO(static void, setup_sections, (bfd ibfd, sec_ptr isection, bfd obfd));
	55	\f
	56	/** main, etc */
	57
	58	static void
	59	usage ()
	60	{
	61	fprintf (stderr, "strip %s\nUsage: %s [-gsxSX] files ...\n",
	62	program_version, program_name);
	63	exit (1);
	64	}
	65
	66	struct option long_options[] = {{"strip-all", 0, 0, 's'},
	67	{"strip-debug", 0, 0, 'S'},
	68	{"discard-all", 0, 0, 'x'},
	69	{"discard-locals", 0, 0, 'X'},
	70	{0, 0, 0, 0}
	71	};
	72
	73	int
	74	main (argc, argv)
	75	char **argv;
	76	int argc;
	77	{
	78	int ind;
	79	int c;
	80	program_name = argv[0];
	81
21214e8e SC	82	bfd_init();
21214e8e SC	83
c074abee DHW	84	strip_symbols = strip_undef; /* default is to strip everything. */
	85	discard_locals = locals_undef;
	86
	87	while ((c = getopt_long (argc, argv, "gsST:xX", long_options, &ind)) != EOF) {
	88	switch (c) {
	89	case 0:
	90	break;
	91	case 's':
	92	strip_symbols = strip_all;
	93	break;
	94	case 'g':
	95	case 'S':
	96	strip_symbols = strip_debug;
	97	break;
	98	case 'T':
	99	target = optarg;
	100	break;
	101	case 'x':
	102	discard_locals = locals_all;
	103	break;
	104	case 'X':
	105	discard_locals = locals_start_L;
	106	break;
	107	default:
	108	usage ();
	109	}
	110	}
	111
	112	/* Default is to strip all symbols: */
	113	if (strip_symbols == strip_undef && discard_locals == locals_undef) {
	114	strip_symbols = strip_all;
	115	}
	116
	117	/* OK, all options now parsed. If no filename specified, do a.out. */
	118	if (optind == argc) return !strip_file ("a.out");
	119
	120	/* We were given several filenames to do: */
	121	while (optind < argc)
	122	if (!strip_file (argv[optind++])) return 1;
	123
	124	return 0;
	125	}
	126	\f
	127	/** Hack signals */
	128
	129	/* Why does strip need to do this, and anyway, if it does shouldn't this be
	130	handled by bfd? */
	131
	132	static int delayed_signal;
	133
	134	static int sigint_handled = 0;
	135	static int sighup_handled = 0;
	136	static int sigterm_handled = 0;
	137
	138	void
	139	delay_signal (signo)
	140	int signo;
	141	{
	142	delayed_signal = signo;
	143	signal (signo, delay_signal);
	144	}
	145
	146	/* Effectively defer handling of asynchronous kill signals. */
	147	void
148	handle_sigs () /* puff puff */
149	{
150	delayed_signal = 0;
151
152	if (signal (SIGINT, SIG_IGN) != SIG_IGN) {
153	sigint_handled = 1;
154	signal (SIGINT, delay_signal);
155	}
156
157	if (signal (SIGHUP, SIG_IGN) != SIG_IGN) {
158	sighup_handled = 1;
159	signal (SIGHUP, delay_signal);
160	}
161
162	if (signal (SIGTERM, SIG_IGN) != SIG_IGN) {
163	sigterm_handled = 1;
164	signal (SIGTERM, delay_signal);
165	}
166
167	return;
168	}
169
170	/* Effectively undefer handling. */
171	void
172	unhandle_sigs () /* put them down */
173	{
174	if (sigint_handled) signal (SIGINT, SIG_DFL);
175
176	if (sighup_handled) signal (SIGHUP, SIG_DFL);
177
178	if (sigterm_handled) signal (SIGTERM, SIG_DFL);
179
180	/* Handle any signal that came in while they were deferred. */
181	if (delayed_signal)
182	kill (getpid (), delayed_signal);
183
184	return;
185	}
186	\f
187
188	static boolean
189	strip_file (filetostrip)
190	char *filetostrip;
191	{
192	static char template[] = "stXXXXXX";
193	char *slash;
194	char *tmpname;
195	bfd *ibfd;
196	bfd *obfd;
197
198	ibfd = bfd_openr (filetostrip, target);
199
200	if (ibfd == NULL) bfd_fatal (filetostrip);
201
202	handle_sigs (); /* light up */
203
204	if (!bfd_check_format (ibfd, bfd_object)) {
205	fprintf (stderr, "Can't strip %s file %s.\n",
206	bfd_format_string (bfd_get_format (ibfd)), filetostrip);
207	exit (1);
208	}
209
210	slash = strrchr( filetostrip, '/' );
211	if ( slash ){
212	*slash = 0;
213	tmpname = xmalloc( strlen(filetostrip) + sizeof(template) + 1 );
214	strcpy( tmpname, filetostrip );
215	strcat( tmpname, "/" );
216	strcat( tmpname, template );
217	mktemp( tmpname );
218	*slash = '/';
219	} else {
220	tmpname = xmalloc( sizeof(template) );
221	strcpy( tmpname, template );
222	mktemp( tmpname );
223	}
224
225	obfd = bfd_openw (mktemp(tmpname), (target ? target : bfd_get_target (ibfd)));
226	if (obfd == NULL) bfd_fatal (tmpname);
227
228	if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
229	bfd_fatal (tmpname);
230
231
232	if ((bfd_set_start_address (obfd, bfd_get_start_address (ibfd)) == false) \|\|
233	(bfd_set_file_flags (obfd, (bfd_get_file_flags (ibfd) &
234	~(HAS_LINENO \| HAS_DEBUG \| HAS_SYMS \|
235	HAS_LOCALS))) == false) \|\|
236	bfd_set_start_address (obfd, bfd_get_start_address (ibfd)) == false)
237	bfd_fatal (bfd_get_filename (ibfd));
238
239	/* Copy architecture of input file to output file */
240	if (!bfd_set_arch_mach (obfd, bfd_get_architecture (ibfd),
241	bfd_get_machine (ibfd))) {
242	fprintf(stderr, "Output file cannot represent architecture %s",
243	bfd_printable_arch_mach (bfd_get_architecture(ibfd),
244	bfd_get_machine (ibfd)));
245	}
246
247
248	/* bfd mandates that all output sections be created and sizes set before
249	any output is done. Thus, we traverse all sections twice. */
250	bfd_map_over_sections (ibfd, setup_sections, (void *)obfd);
251	bfd_map_over_sections (ibfd, copy_sections, (void *)obfd);
252
253	if (!bfd_close (obfd)) bfd_fatal (filetostrip);
254	if (!bfd_close (ibfd)) bfd_fatal (filetostrip);
255
256	rename(tmpname, filetostrip);
257	free(tmpname);
258
259	unhandle_sigs();
260
261	return true;
262	}
263	\f
264	/** Actually do the work */
265	static void
266	setup_sections (ibfd, isection, obfd)
267	bfd *ibfd;
268	sec_ptr isection;
269	bfd *obfd;
270	{
271	sec_ptr osection;
272	char *err;
273
274	osection = bfd_make_section (obfd, bfd_section_name (ibfd, isection));
275	if (osection == NULL) {
276	err = "making";
277	goto loser;
278	}
279
280	if (!bfd_set_section_size(obfd, osection, bfd_section_size(ibfd, isection))) {
281	err = "size";
282	goto loser;
283	}
284
285	if (!bfd_set_section_vma (obfd, osection, bfd_section_vma (ibfd, isection))) {
286	err = "vma";
287	goto loser;
288	}
289
290	if (bfd_set_section_alignment (obfd, osection,
291	bfd_section_alignment (ibfd, isection))
292	!= true) {
293	err = "alignment";
294	goto loser;
295	} /* on error, I presume. */
296
297	if (!bfd_set_section_flags (obfd, osection,
298	bfd_get_section_flags (ibfd, isection))) {
299	err = "flags";
300	goto loser;
301	}
302
303	/* All went well */
304	return;
305
306	loser:
307	fprintf (stderr, "%s: file \"%s\", section \"%s\": error in %s: %s\n",
308	program_name,
309	bfd_get_filename (ibfd), bfd_section_name (ibfd, isection),
310	err, bfd_errmsg (bfd_error));
311	exit (1);
312	}
313
314	static void
315	copy_sections (ibfd, isection, obfd)
316	bfd *ibfd;
317	sec_ptr isection;
318	bfd *obfd;
319	{
320	static unsigned char *memhunk = NULL;
321	static unsigned memhunksize = 0;
322
323	sec_ptr osection;
324	unsigned long size;
325	flagword iflg;
326	unsigned char *temp;
327
328	osection = bfd_get_section_by_name (obfd, bfd_section_name (ibfd, isection));
329
330	size = bfd_section_size (ibfd, isection);
331	iflg = bfd_get_section_flags (ibfd, isection);
332
333	/* either:
334	we don't need any memory because there's nothing in this section,
335	we had no memory so we got some,
336	we had some memory but not enough so we got more,
337	or we fail to allocat. */
338
339	if (size == 0)
340	return;
341
342	if ((iflg & SEC_HAS_CONTENTS) == 0)
343	return;
344
345	if (memhunk == NULL) {
346	memhunk = (unsigned char *) xmalloc (size);
347	memhunksize = size;
348	}
349
350	if (size > memhunksize) {
351	temp = (unsigned char ) xrealloc ((char ) memhunk, size);
352	memhunksize = size;
353	memhunk = temp;
354	}
355
356	/* now we have enough memory, just do it: */
357	if (!bfd_get_section_contents (ibfd, isection, memhunk, 0, size))
358	bfd_fatal (bfd_get_filename (ibfd));
359
360	if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
361	bfd_fatal (bfd_get_filename (obfd));
362	}