[deliverable/binutils-gdb.git] / binutils / ostrip.c

/* strip certain symbols from a rel file.
   Copyright (C) 1986, 1990 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 1, 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.  */

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

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>

enum strip_action {
  strip_undef,
  strip_all,			/* strip all symbols */
  strip_debug,			/* strip all debugger symbols */
};

/* Which symbols to remove. */
enum strip_action strip_symbols;

enum locals_action {
  locals_undef,
  locals_start_L,		/* discard locals starting with L */
  locals_all,			/* discard all locals */
};

/* Which local symbols to remove. */
enum locals_action discard_locals;

/* The name this program was run with. */
char *program_name;

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},
};

static char *target = NULL;

static int fatal_error;

extern char *malloc();
extern char *mktemp();
extern char *realloc();
extern char *strcpy();
extern int exit();
extern int fprintf();
extern int free();
extern int getpid();
extern int kill();
extern int perror();
extern int sprintf();
extern int unlink();

#ifdef __STDC__
static int strip_bfd(bfd *ibfd, bfd *obfd);
static int strip_file(char *filetostrip);
static void usage(void);
#else
static int strip_bfd();
static int strip_file();
static void usage();
#endif /* __STDC__ */
static void copy_sections ();
static void setup_sections ();

int main(argc, argv)
char **argv;
int argc;
{
	int ind;
	int c;
	program_name = argv[0];
	
	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 ();
		} /* switch on option */
	} /* for each option */
	
	if (strip_symbols == strip_undef && discard_locals == locals_undef) {
		strip_symbols = strip_all;
	} /* Default is to strip all symbols.  */
	
	
	if (argc == optind) {
		return(strip_file("a.out"));
	} else {
		int retval = 0;

		for ( ; optind < argc; ++optind) {
			retval &= strip_file(argv[optind]);
		} /* for each file to strip */

		return(retval);
	} /* if no arguments given */

} /* main() */

static int delayed_signal;

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

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

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

void unhandle_sigs() {
	/* Effectively undefer handling.  */
	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;
} /* unhandle_sigs() */

static int strip_file(filetostrip)
char *filetostrip;
{
	bfd *ibfd;
	bfd *obfd;
	char tmpfilename[] = "stXXXXXX";

	if ((ibfd = bfd_openr(filetostrip, (char *)NULL)) == NULL) {
		bfd_perror(filetostrip);
		return(1);
	} /* on error opening input */
	
	obfd = bfd_openw(mktemp(tmpfilename),
			 target? target: bfd_get_target (ibfd));
	if (obfd == NULL) {
		bfd_perror(tmpfilename);

		if (bfd_close(ibfd) == false) {
			bfd_perror(bfd_get_filename(ibfd));
		} /* on close error */

		return(1);
	} /* on error opening output */

	handle_sigs();

	if (bfd_check_format(ibfd, bfd_object) != false) {
		if (bfd_set_format(obfd, bfd_get_format(ibfd)) != false) {
			if (!strip_bfd(ibfd, obfd)) {
				/* success */

				if (bfd_close(ibfd) == false) {
					bfd_perror(bfd_get_filename(ibfd));
				} /* on close error */

				if (bfd_close(obfd) == false) {
					bfd_perror(bfd_get_filename(obfd));
				} /* on close error */

				rename(tmpfilename, filetostrip);
				unhandle_sigs();
				return(0);
			} /* strip_bfd prints it's own failing messages */
		} else {
			bfd_perror(filetostrip);
		} /* can't set format */
	} else {
		/* not an object file */
		(void) fprintf(stderr, "File %s has format 0x%x that will not be stripped.\n",
			       filetostrip, (unsigned) bfd_get_format(ibfd));
	} /* if anything fails along the way */
	

	if (bfd_close(ibfd) == false) {
		bfd_perror(bfd_get_filename(ibfd));
	} /* on close error */

	if (bfd_close(obfd) == false) {
		bfd_perror(bfd_get_filename(obfd));
	} /* on close error */
	
	if (unlink(tmpfilename)) {
		perror(tmpfilename);
	} /* on error */
	
	unhandle_sigs();

	return(1);
} /* strip_file() */


boolean
bfd_set_start_address (abfd, new_address)
     bfd *abfd;
     bfd_vma new_address;
{
  bfd_get_start_address (abfd) = new_address;
  return true;
}


static int
strip_bfd(ibfd, obfd)
	bfd *ibfd;
	bfd *obfd;
{
	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_perror(bfd_get_filename(ibfd));
		return(1);
	} /* on error setting file attributes */

      /* bfd mandates that all output sections be created and sizes set before
	 any output is done.  Thus, we traverse all sections twice.  */

	fatal_error = 0;
	bfd_map_over_sections (ibfd, setup_sections, (void *)obfd);
	if (!fatal_error)
		bfd_map_over_sections (ibfd, copy_sections,  (void *)obfd);
	return fatal_error;
}

static void
setup_sections(ibfd, isection, obfd)
bfd *ibfd;
sec_ptr isection;
bfd *obfd;
{
	sec_ptr osection;
	char *err;

	do {
	    err = "making";
	    osection = bfd_make_section(obfd, bfd_section_name(ibfd, isection));
	    if (osection == NULL)
		break;
	    err = "size";
	    if (!bfd_set_section_size(obfd, osection, 
		 bfd_section_size(ibfd, isection)))
		break;
	    err = "vma";
	    if (!bfd_set_section_vma(obfd, osection,
		 bfd_section_vma(ibfd, isection)))
		break;
	    err = "alignment";
	    if (!bfd_set_section_alignment(obfd, osection,
		 bfd_section_alignment(ibfd, isection)))
		break;
	    err = "flags";
	    if (!bfd_set_section_flags(obfd, osection,
		 bfd_get_section_flags(ibfd, isection)))
		break;
	    return;
	} while (0);

	(void) fprintf(stderr, "file \"%s\", section \"%s\": error in %s: ",
		       bfd_get_filename(ibfd),
		       bfd_section_name(ibfd, isection),
		       err);

	bfd_perror("");
	fatal_error = 1;
}

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

	sec_ptr osection;
	unsigned long size;
	flagword iflg;
	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 (memhunk == NULL) {
		memhunk = malloc (size);
		memhunksize = size;
	}

	if (size > memhunksize) {
		temp = realloc (memhunk, size);
		memhunksize = size;
		if (!temp)	/* If realloc failed, blow away our mem */
			free (memhunk);
		memhunk = temp;
	}

	if (memhunk == NULL) {
		/* failed to allocate or reallocate */
		/* FIXME, we should just copy in pieces. */
		(void) fprintf(stderr,
	   "Could not allocate %lu bytes in which to copy section.\n", size);
		return;
	}

	/* now we have enough memory */
	
	if (!bfd_get_section_contents(ibfd, isection, memhunk, 0, size)) {
		bfd_perror(bfd_get_filename(ibfd));
		fatal_error = 1;
		return;
	}
	if (!bfd_set_section_contents(obfd, osection, memhunk, 0, size)) {
		bfd_perror(bfd_get_filename(obfd));
		fatal_error = 1;
		return;
	}
}

void
usage ()
{
  fprintf (stderr, "\
Usage: %s [-gsxSX] [+strip-all] [+strip-debug] [+discard-all]\n\
       [+discard-locals] file...\n", program_name);
  exit (1);
}

/*
 * Local Variables:
 * comment-column: 0
 * fill-column: 131
 * End:
 */

/* end of strip.c */
Commit	Line	Data
c074abee DHW	1	/* strip certain symbols from a rel file.
	2	Copyright (C) 1986, 1990 Free Software Foundation, Inc.
	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
	6	the Free Software Foundation; either version 1, or (at your option)
	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
2a5f387b	18	#include "bfd.h"
c074abee	19	#include "sysdep.h"
2a5f387b	20	#include "getopt.h"
c074abee DHW	21
	22	#include <stdio.h>
	23	#include <signal.h>
	24	#include <sys/types.h>
	25	#include <sys/stat.h>
	26
c074abee DHW	27	enum strip_action {
	28	strip_undef,
	29	strip_all, /* strip all symbols */
	30	strip_debug, /* strip all debugger symbols */
	31	};
	32
	33	/* Which symbols to remove. */
	34	enum strip_action strip_symbols;
	35
	36	enum locals_action {
	37	locals_undef,
	38	locals_start_L, /* discard locals starting with L */
	39	locals_all, /* discard all locals */
	40	};
	41
	42	/* Which local symbols to remove. */
	43	enum locals_action discard_locals;
	44
	45	/* The name this program was run with. */
	46	char *program_name;
	47
	48	struct option long_options[] = {
	49	{"strip-all", 0, 0, 's'},
	50	{"strip-debug", 0, 0, 'S'},
	51	{"discard-all", 0, 0, 'x'},
	52	{"discard-locals", 0, 0, 'X'},
	53	{0, 0, 0, 0},
	54	};
	55
	56	static char *target = NULL;
	57
	58	static int fatal_error;
	59
	60	extern char *malloc();
	61	extern char *mktemp();
	62	extern char *realloc();
	63	extern char *strcpy();
	64	extern int exit();
	65	extern int fprintf();
	66	extern int free();
	67	extern int getpid();
	68	extern int kill();
	69	extern int perror();
	70	extern int sprintf();
	71	extern int unlink();
	72
	73	#ifdef __STDC__
	74	static int strip_bfd(bfd ibfd, bfd obfd);
	75	static int strip_file(char *filetostrip);
	76	static void usage(void);
	77	#else
	78	static int strip_bfd();
	79	static int strip_file();
	80	static void usage();
	81	#endif /* __STDC__ */
	82	static void copy_sections ();
	83	static void setup_sections ();
	84
	85	int main(argc, argv)
	86	char **argv;
	87	int argc;
	88	{
	89	int ind;
	90	int c;
91	program_name = argv[0];
92
93	strip_symbols = strip_undef; /* default is to strip everything. */
94	discard_locals = locals_undef;
95
96	while ((c = getopt_long (argc, argv, "gsST:xX", long_options, &ind)) != EOF) {
97	switch (c) {
98	case 0:
99	break;
100	case 's':
101	strip_symbols = strip_all;
102	break;
103	case 'g':
104	case 'S':
105	strip_symbols = strip_debug;
106	break;
107	case 'T':
108	target = optarg;
109	break;
110	case 'x':
111	discard_locals = locals_all;
112	break;
113	case 'X':
114	discard_locals = locals_start_L;
115	break;
116	default:
117	usage ();
118	} /* switch on option */
119	} /* for each option */
120
121	if (strip_symbols == strip_undef && discard_locals == locals_undef) {
122	strip_symbols = strip_all;
123	} /* Default is to strip all symbols. */
124
125
126	if (argc == optind) {
127	return(strip_file("a.out"));
128	} else {
129	int retval = 0;
130
131	for ( ; optind < argc; ++optind) {
132	retval &= strip_file(argv[optind]);
133	} /* for each file to strip */
134
135	return(retval);
136	} /* if no arguments given */
137
138	} /* main() */
139
140	static int delayed_signal;
141
142	void delay_signal(signo)
143	int signo;
144	{
145	delayed_signal = signo;
146	signal(signo, delay_signal);
147	} /* delay_signal() */
148
149	static int sigint_handled = 0;
150	static int sighup_handled = 0;
151	static int sigterm_handled = 0;
152
153	void handle_sigs() {
154	/* Effectively defer handling of asynchronous kill signals. */
155	delayed_signal = 0;
156
157	if (signal (SIGINT, SIG_IGN) != SIG_IGN) {
158	sigint_handled = 1;
159	signal(SIGINT, delay_signal);
160	} /* if not ignored */
161
162	if (signal (SIGHUP, SIG_IGN) != SIG_IGN) {
163	sighup_handled = 1;
164	signal(SIGHUP, delay_signal);
165	} /* if not ignored */
166
167	if (signal (SIGTERM, SIG_IGN) != SIG_IGN) {
168	sigterm_handled = 1;
169	signal(SIGTERM, delay_signal);
170	} /* if not ignored */
171
172	return;
173	} /* handle_sigs() */
174
175	void unhandle_sigs() {
176	/* Effectively undefer handling. */
177	if (sigint_handled)
178	signal (SIGINT, SIG_DFL);
179	if (sighup_handled)
180	signal (SIGHUP, SIG_DFL);
181	if (sigterm_handled)
182	signal (SIGTERM, SIG_DFL);
183
184	/* Handle any signal that came in while they were deferred. */
185	if (delayed_signal)
186	kill (getpid (), delayed_signal);
187
188	return;
189	} /* unhandle_sigs() */
190
191	static int strip_file(filetostrip)
192	char *filetostrip;
193	{
194	bfd *ibfd;
195	bfd *obfd;
196	char tmpfilename[] = "stXXXXXX";
197
198	if ((ibfd = bfd_openr(filetostrip, (char *)NULL)) == NULL) {
199	bfd_perror(filetostrip);
200	return(1);
201	} /* on error opening input */
202
203	obfd = bfd_openw(mktemp(tmpfilename),
204	target? target: bfd_get_target (ibfd));
205	if (obfd == NULL) {
206	bfd_perror(tmpfilename);
207
208	if (bfd_close(ibfd) == false) {
209	bfd_perror(bfd_get_filename(ibfd));
210	} /* on close error */
211
212	return(1);
213	} /* on error opening output */
214
215	handle_sigs();
216
217	if (bfd_check_format(ibfd, bfd_object) != false) {
218	if (bfd_set_format(obfd, bfd_get_format(ibfd)) != false) {
219	if (!strip_bfd(ibfd, obfd)) {
220	/* success */
221
222	if (bfd_close(ibfd) == false) {
223	bfd_perror(bfd_get_filename(ibfd));
224	} /* on close error */
225
226	if (bfd_close(obfd) == false) {
227	bfd_perror(bfd_get_filename(obfd));
228	} /* on close error */
229
230	rename(tmpfilename, filetostrip);
231	unhandle_sigs();
232	return(0);
233	} /* strip_bfd prints it's own failing messages */
234	} else {
235	bfd_perror(filetostrip);
236	} /* can't set format */
237	} else {
238	/* not an object file */
239	(void) fprintf(stderr, "File %s has format 0x%x that will not be stripped.\n",
240	filetostrip, (unsigned) bfd_get_format(ibfd));
241	} /* if anything fails along the way */
242
243
244	if (bfd_close(ibfd) == false) {
245	bfd_perror(bfd_get_filename(ibfd));
246	} /* on close error */
247
248	if (bfd_close(obfd) == false) {
249	bfd_perror(bfd_get_filename(obfd));
250	} /* on close error */
251
252	if (unlink(tmpfilename)) {
253	perror(tmpfilename);
254	} /* on error */
255
256	unhandle_sigs();
257
258	return(1);
259	} /* strip_file() */
260
261
262	boolean
263	bfd_set_start_address (abfd, new_address)
264	bfd *abfd;
265	bfd_vma new_address;
266	{
267	bfd_get_start_address (abfd) = new_address;
268	return true;
269	}
270
271
272
273	static int
274	strip_bfd(ibfd, obfd)
275	bfd *ibfd;
276	bfd *obfd;
277	{
278	if (bfd_set_start_address(obfd, bfd_get_start_address(ibfd)) == false
279	\|\| bfd_set_file_flags(obfd, bfd_get_file_flags(ibfd) & ~(HAS_LINENO \| HAS_DEBUG \| HAS_SYMS \| HAS_LOCALS)) == false
280	\|\| bfd_set_start_address(obfd, bfd_get_start_address(ibfd)) == false) {
281	bfd_perror(bfd_get_filename(ibfd));
282	return(1);
283	} /* on error setting file attributes */
284
285	/* bfd mandates that all output sections be created and sizes set before
286	any output is done. Thus, we traverse all sections twice. */
287
288	fatal_error = 0;
289	bfd_map_over_sections (ibfd, setup_sections, (void *)obfd);
290	if (!fatal_error)
291	bfd_map_over_sections (ibfd, copy_sections, (void *)obfd);
292	return fatal_error;
293	}
294
295	static void
296	setup_sections(ibfd, isection, obfd)
297	bfd *ibfd;
298	sec_ptr isection;
299	bfd *obfd;
300	{
301	sec_ptr osection;
302	char *err;
303
304	do {
305	err = "making";
306	osection = bfd_make_section(obfd, bfd_section_name(ibfd, isection));
307	if (osection == NULL)
308	break;
309	err = "size";
310	if (!bfd_set_section_size(obfd, osection,
311	bfd_section_size(ibfd, isection)))
312	break;
313	err = "vma";
314	if (!bfd_set_section_vma(obfd, osection,
315	bfd_section_vma(ibfd, isection)))
316	break;
317	err = "alignment";
318	if (!bfd_set_section_alignment(obfd, osection,
319	bfd_section_alignment(ibfd, isection)))
320	break;
321	err = "flags";
322	if (!bfd_set_section_flags(obfd, osection,
323	bfd_get_section_flags(ibfd, isection)))
324	break;
325	return;
326	} while (0);
327
328	(void) fprintf(stderr, "file \"%s\", section \"%s\": error in %s: ",
329	bfd_get_filename(ibfd),
330	bfd_section_name(ibfd, isection),
331	err);
332
333	bfd_perror("");
334	fatal_error = 1;
335	}
336
337	static void
338	copy_sections(ibfd, isection, obfd)
339	bfd *ibfd;
340	sec_ptr isection;
341	bfd *obfd;
342	{
343	static char *memhunk = NULL;
344	static unsigned memhunksize = 0;
345
346	sec_ptr osection;
347	unsigned long size;
348	flagword iflg;
349	char *temp;
350
351	osection = bfd_get_section_by_name (obfd,
352	bfd_section_name(ibfd, isection));
353
354	size = bfd_section_size(ibfd, isection);
355	iflg = bfd_get_section_flags(ibfd, isection);
356
357	/* either:
358	we don't need any memory because there's nothing in this section,
359	we had no memory so we got some,
360	we had some memory but not enough so we got more,
361	or we fail to allocat. */
362
363	if (size == 0)
364	return;
365
366	if (memhunk == NULL) {
367	memhunk = malloc (size);
368	memhunksize = size;
369	}
370
371	if (size > memhunksize) {
372	temp = realloc (memhunk, size);
373	memhunksize = size;
374	if (!temp) /* If realloc failed, blow away our mem */
375	free (memhunk);
376	memhunk = temp;
377	}
378
379	if (memhunk == NULL) {
380	/* failed to allocate or reallocate */
381	/* FIXME, we should just copy in pieces. */
382	(void) fprintf(stderr,
383	"Could not allocate %lu bytes in which to copy section.\n", size);
384	return;
385	}
386
387	/* now we have enough memory */
388
389	if (!bfd_get_section_contents(ibfd, isection, memhunk, 0, size)) {
390	bfd_perror(bfd_get_filename(ibfd));
391	fatal_error = 1;
392	return;
393	}
394	if (!bfd_set_section_contents(obfd, osection, memhunk, 0, size)) {
395	bfd_perror(bfd_get_filename(obfd));
396	fatal_error = 1;
397	return;
398	}
399	}
400
401	void
402	usage ()
403	{
404	fprintf (stderr, "\
405	Usage: %s [-gsxSX] [+strip-all] [+strip-debug] [+discard-all]\n\
406	[+discard-locals] file...\n", program_name);
407	exit (1);
408	}
409
410	/*
411	* Local Variables:
412	* comment-column: 0
413	* fill-column: 131
414	* End:
415	*/
416
417	/* end of strip.c */