1// SPDX-License-Identifier: GPL-2.0
2/* This is included from relocs_32/64.c */
3
4#define ElfW(type)		_ElfW(ELF_BITS, type)
5#define _ElfW(bits, type)	__ElfW(bits, type)
6#define __ElfW(bits, type)	Elf##bits##_##type
7
8#define Elf_Addr		ElfW(Addr)
9#define Elf_Ehdr		ElfW(Ehdr)
10#define Elf_Phdr		ElfW(Phdr)
11#define Elf_Shdr		ElfW(Shdr)
12#define Elf_Sym			ElfW(Sym)
13
14static Elf_Ehdr ehdr;
15
16struct relocs {
17	uint32_t	*offset;
18	unsigned long	count;
19	unsigned long	size;
20};
21
22static struct relocs relocs;
23
24struct section {
25	Elf_Shdr       shdr;
26	struct section *link;
27	Elf_Sym        *symtab;
28	Elf_Rel        *reltab;
29	char           *strtab;
30	long           shdr_offset;
31};
32static struct section *secs;
33
34static const char * const regex_sym_kernel = {
35/* Symbols matching these regex's should never be relocated */
36	"^(__crc_)",
37};
38
39static regex_t sym_regex_c;
40
41static int regex_skip_reloc(const char *sym_name)
42{
43	return !regexec(&sym_regex_c, sym_name, 0, NULL, 0);
44}
45
46static void regex_init(void)
47{
48	char errbuf[128];
49	int err;
50
51	err = regcomp(&sym_regex_c, regex_sym_kernel,
52			REG_EXTENDED|REG_NOSUB);
53
54	if (err) {
55		regerror(err, &sym_regex_c, errbuf, sizeof(errbuf));
56		die("%s", errbuf);
57	}
58}
59
60static const char *rel_type(unsigned type)
61{
62	static const char * const type_name[] = {
63#define REL_TYPE(X)[X] = #X
64		REL_TYPE(R_MIPS_NONE),
65		REL_TYPE(R_MIPS_16),
66		REL_TYPE(R_MIPS_32),
67		REL_TYPE(R_MIPS_REL32),
68		REL_TYPE(R_MIPS_26),
69		REL_TYPE(R_MIPS_HI16),
70		REL_TYPE(R_MIPS_LO16),
71		REL_TYPE(R_MIPS_GPREL16),
72		REL_TYPE(R_MIPS_LITERAL),
73		REL_TYPE(R_MIPS_GOT16),
74		REL_TYPE(R_MIPS_PC16),
75		REL_TYPE(R_MIPS_CALL16),
76		REL_TYPE(R_MIPS_GPREL32),
77		REL_TYPE(R_MIPS_64),
78		REL_TYPE(R_MIPS_HIGHER),
79		REL_TYPE(R_MIPS_HIGHEST),
80		REL_TYPE(R_MIPS_PC21_S2),
81		REL_TYPE(R_MIPS_PC26_S2),
82#undef REL_TYPE
83	};
84	const char *name = "unknown type rel type name";
85
86	if (type < ARRAY_SIZE(type_name) && type_name[type])
87		name = type_name[type];
88	return name;
89}
90
91static const char *sec_name(unsigned shndx)
92{
93	const char *sec_strtab;
94	const char *name;
95
96	sec_strtab = secs[ehdr.e_shstrndx].strtab;
97	if (shndx < ehdr.e_shnum)
98		name = sec_strtab + secs[shndx].shdr.sh_name;
99	else if (shndx == SHN_ABS)
100		name = "ABSOLUTE";
101	else if (shndx == SHN_COMMON)
102		name = "COMMON";
103	else
104		name = "<noname>";
105	return name;
106}
107
108static struct section *sec_lookup(const char *secname)
109{
110	int i;
111
112	for (i = 0; i < ehdr.e_shnum; i++)
113		if (strcmp(secname, sec_name(i)) == 0)
114			return &secs[i];
115
116	return NULL;
117}
118
119static const char *sym_name(const char *sym_strtab, Elf_Sym *sym)
120{
121	const char *name;
122
123	if (sym->st_name)
124		name = sym_strtab + sym->st_name;
125	else
126		name = sec_name(sym->st_shndx);
127	return name;
128}
129
130#if BYTE_ORDER == LITTLE_ENDIAN
131#define le16_to_cpu(val) (val)
132#define le32_to_cpu(val) (val)
133#define le64_to_cpu(val) (val)
134#define be16_to_cpu(val) bswap_16(val)
135#define be32_to_cpu(val) bswap_32(val)
136#define be64_to_cpu(val) bswap_64(val)
137
138#define cpu_to_le16(val) (val)
139#define cpu_to_le32(val) (val)
140#define cpu_to_le64(val) (val)
141#define cpu_to_be16(val) bswap_16(val)
142#define cpu_to_be32(val) bswap_32(val)
143#define cpu_to_be64(val) bswap_64(val)
144#endif
145#if BYTE_ORDER == BIG_ENDIAN
146#define le16_to_cpu(val) bswap_16(val)
147#define le32_to_cpu(val) bswap_32(val)
148#define le64_to_cpu(val) bswap_64(val)
149#define be16_to_cpu(val) (val)
150#define be32_to_cpu(val) (val)
151#define be64_to_cpu(val) (val)
152
153#define cpu_to_le16(val) bswap_16(val)
154#define cpu_to_le32(val) bswap_32(val)
155#define cpu_to_le64(val) bswap_64(val)
156#define cpu_to_be16(val) (val)
157#define cpu_to_be32(val) (val)
158#define cpu_to_be64(val) (val)
159#endif
160
161static uint16_t elf16_to_cpu(uint16_t val)
162{
163	if (ehdr.e_ident[EI_DATA] == ELFDATA2LSB)
164		return le16_to_cpu(val);
165	else
166		return be16_to_cpu(val);
167}
168
169static uint32_t elf32_to_cpu(uint32_t val)
170{
171	if (ehdr.e_ident[EI_DATA] == ELFDATA2LSB)
172		return le32_to_cpu(val);
173	else
174		return be32_to_cpu(val);
175}
176
177static uint32_t cpu_to_elf32(uint32_t val)
178{
179	if (ehdr.e_ident[EI_DATA] == ELFDATA2LSB)
180		return cpu_to_le32(val);
181	else
182		return cpu_to_be32(val);
183}
184
185#define elf_half_to_cpu(x)	elf16_to_cpu(x)
186#define elf_word_to_cpu(x)	elf32_to_cpu(x)
187
188#if ELF_BITS == 64
189static uint64_t elf64_to_cpu(uint64_t val)
190{
191	if (ehdr.e_ident[EI_DATA] == ELFDATA2LSB)
192		return le64_to_cpu(val);
193	else
194		return be64_to_cpu(val);
195}
196#define elf_addr_to_cpu(x)	elf64_to_cpu(x)
197#define elf_off_to_cpu(x)	elf64_to_cpu(x)
198#define elf_xword_to_cpu(x)	elf64_to_cpu(x)
199#else
200#define elf_addr_to_cpu(x)	elf32_to_cpu(x)
201#define elf_off_to_cpu(x)	elf32_to_cpu(x)
202#define elf_xword_to_cpu(x)	elf32_to_cpu(x)
203#endif
204
205static void read_ehdr(FILE *fp)
206{
207	if (fread(&ehdr, sizeof(ehdr), 1, fp) != 1)
208		die("Cannot read ELF header: %s\n", strerror(errno));
209
210	if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0)
211		die("No ELF magic\n");
212
213	if (ehdr.e_ident[EI_CLASS] != ELF_CLASS)
214		die("Not a %d bit executable\n", ELF_BITS);
215
216	if ((ehdr.e_ident[EI_DATA] != ELFDATA2LSB) &&
217	    (ehdr.e_ident[EI_DATA] != ELFDATA2MSB))
218		die("Unknown ELF Endianness\n");
219
220	if (ehdr.e_ident[EI_VERSION] != EV_CURRENT)
221		die("Unknown ELF version\n");
222
223	/* Convert the fields to native endian */
224	ehdr.e_type      = elf_half_to_cpu(ehdr.e_type);
225	ehdr.e_machine   = elf_half_to_cpu(ehdr.e_machine);
226	ehdr.e_version   = elf_word_to_cpu(ehdr.e_version);
227	ehdr.e_entry     = elf_addr_to_cpu(ehdr.e_entry);
228	ehdr.e_phoff     = elf_off_to_cpu(ehdr.e_phoff);
229	ehdr.e_shoff     = elf_off_to_cpu(ehdr.e_shoff);
230	ehdr.e_flags     = elf_word_to_cpu(ehdr.e_flags);
231	ehdr.e_ehsize    = elf_half_to_cpu(ehdr.e_ehsize);
232	ehdr.e_phentsize = elf_half_to_cpu(ehdr.e_phentsize);
233	ehdr.e_phnum     = elf_half_to_cpu(ehdr.e_phnum);
234	ehdr.e_shentsize = elf_half_to_cpu(ehdr.e_shentsize);
235	ehdr.e_shnum     = elf_half_to_cpu(ehdr.e_shnum);
236	ehdr.e_shstrndx  = elf_half_to_cpu(ehdr.e_shstrndx);
237
238	if ((ehdr.e_type != ET_EXEC) && (ehdr.e_type != ET_DYN))
239		die("Unsupported ELF header type\n");
240
241	if (ehdr.e_machine != ELF_MACHINE)
242		die("Not for %s\n", ELF_MACHINE_NAME);
243
244	if (ehdr.e_version != EV_CURRENT)
245		die("Unknown ELF version\n");
246
247	if (ehdr.e_ehsize != sizeof(Elf_Ehdr))
248		die("Bad Elf header size\n");
249
250	if (ehdr.e_phentsize != sizeof(Elf_Phdr))
251		die("Bad program header entry\n");
252
253	if (ehdr.e_shentsize != sizeof(Elf_Shdr))
254		die("Bad section header entry\n");
255
256	if (ehdr.e_shstrndx >= ehdr.e_shnum)
257		die("String table index out of bounds\n");
258}
259
260static void read_shdrs(FILE *fp)
261{
262	int i;
263	Elf_Shdr shdr;
264
265	secs = calloc(ehdr.e_shnum, sizeof(struct section));
266	if (!secs)
267		die("Unable to allocate %d section headers\n", ehdr.e_shnum);
268
269	if (fseek(fp, ehdr.e_shoff, SEEK_SET) < 0)
270		die("Seek to %d failed: %s\n", ehdr.e_shoff, strerror(errno));
271
272	for (i = 0; i < ehdr.e_shnum; i++) {
273		struct section *sec = &secs[i];
274
275		sec->shdr_offset = ftell(fp);
276		if (fread(&shdr, sizeof(shdr), 1, fp) != 1)
277			die("Cannot read ELF section headers %d/%d: %s\n",
278			    i, ehdr.e_shnum, strerror(errno));
279		sec->shdr.sh_name      = elf_word_to_cpu(shdr.sh_name);
280		sec->shdr.sh_type      = elf_word_to_cpu(shdr.sh_type);
281		sec->shdr.sh_flags     = elf_xword_to_cpu(shdr.sh_flags);
282		sec->shdr.sh_addr      = elf_addr_to_cpu(shdr.sh_addr);
283		sec->shdr.sh_offset    = elf_off_to_cpu(shdr.sh_offset);
284		sec->shdr.sh_size      = elf_xword_to_cpu(shdr.sh_size);
285		sec->shdr.sh_link      = elf_word_to_cpu(shdr.sh_link);
286		sec->shdr.sh_info      = elf_word_to_cpu(shdr.sh_info);
287		sec->shdr.sh_addralign = elf_xword_to_cpu(shdr.sh_addralign);
288		sec->shdr.sh_entsize   = elf_xword_to_cpu(shdr.sh_entsize);
289		if (sec->shdr.sh_link < ehdr.e_shnum)
290			sec->link = &secs[sec->shdr.sh_link];
291	}
292}
293
294static void read_strtabs(FILE *fp)
295{
296	int i;
297
298	for (i = 0; i < ehdr.e_shnum; i++) {
299		struct section *sec = &secs[i];
300
301		if (sec->shdr.sh_type != SHT_STRTAB)
302			continue;
303
304		sec->strtab = malloc(sec->shdr.sh_size);
305		if (!sec->strtab)
306			die("malloc of %d bytes for strtab failed\n",
307			    sec->shdr.sh_size);
308
309		if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0)
310			die("Seek to %d failed: %s\n",
311			    sec->shdr.sh_offset, strerror(errno));
312
313		if (fread(sec->strtab, 1, sec->shdr.sh_size, fp) !=
314		    sec->shdr.sh_size)
315			die("Cannot read symbol table: %s\n", strerror(errno));
316	}
317}
318
319static void read_symtabs(FILE *fp)
320{
321	int i, j;
322
323	for (i = 0; i < ehdr.e_shnum; i++) {
324		struct section *sec = &secs[i];
325		if (sec->shdr.sh_type != SHT_SYMTAB)
326			continue;
327
328		sec->symtab = malloc(sec->shdr.sh_size);
329		if (!sec->symtab)
330			die("malloc of %d bytes for symtab failed\n",
331			    sec->shdr.sh_size);
332
333		if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0)
334			die("Seek to %d failed: %s\n",
335			    sec->shdr.sh_offset, strerror(errno));
336
337		if (fread(sec->symtab, 1, sec->shdr.sh_size, fp) !=
338		    sec->shdr.sh_size)
339			die("Cannot read symbol table: %s\n", strerror(errno));
340
341		for (j = 0; j < sec->shdr.sh_size/sizeof(Elf_Sym); j++) {
342			Elf_Sym *sym = &sec->symtab[j];
343
344			sym->st_name  = elf_word_to_cpu(sym->st_name);
345			sym->st_value = elf_addr_to_cpu(sym->st_value);
346			sym->st_size  = elf_xword_to_cpu(sym->st_size);
347			sym->st_shndx = elf_half_to_cpu(sym->st_shndx);
348		}
349	}
350}
351
352static void read_relocs(FILE *fp)
353{
354	static unsigned long base = 0;
355	int i, j;
356
357	if (!base) {
358		struct section *sec = sec_lookup(".text");
359
360		if (!sec)
361			die("Could not find .text section\n");
362
363		base = sec->shdr.sh_addr;
364	}
365
366	for (i = 0; i < ehdr.e_shnum; i++) {
367		struct section *sec = &secs[i];
368
369		if (sec->shdr.sh_type != SHT_REL_TYPE)
370			continue;
371
372		sec->reltab = malloc(sec->shdr.sh_size);
373		if (!sec->reltab)
374			die("malloc of %d bytes for relocs failed\n",
375			    sec->shdr.sh_size);
376
377		if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0)
378			die("Seek to %d failed: %s\n",
379			    sec->shdr.sh_offset, strerror(errno));
380
381		if (fread(sec->reltab, 1, sec->shdr.sh_size, fp) !=
382		    sec->shdr.sh_size)
383			die("Cannot read symbol table: %s\n", strerror(errno));
384
385		for (j = 0; j < sec->shdr.sh_size/sizeof(Elf_Rel); j++) {
386			Elf_Rel *rel = &sec->reltab[j];
387
388			rel->r_offset = elf_addr_to_cpu(rel->r_offset);
389			/* Set offset into kernel image */
390			rel->r_offset -= base;
391#if (ELF_BITS == 32)
392			rel->r_info   = elf_xword_to_cpu(rel->r_info);
393#else
394			/* Convert MIPS64 RELA format - only the symbol
395			 * index needs converting to native endianness
396			 */
397			rel->r_info   = rel->r_info;
398			ELF_R_SYM(rel->r_info) = elf32_to_cpu(ELF_R_SYM(rel->r_info));
399#endif
400#if (SHT_REL_TYPE == SHT_RELA)
401			rel->r_addend = elf_xword_to_cpu(rel->r_addend);
402#endif
403		}
404	}
405}
406
407static void remove_relocs(FILE *fp)
408{
409	int i;
410	Elf_Shdr shdr;
411
412	for (i = 0; i < ehdr.e_shnum; i++) {
413		struct section *sec = &secs[i];
414
415		if (sec->shdr.sh_type != SHT_REL_TYPE)
416			continue;
417
418		if (fseek(fp, sec->shdr_offset, SEEK_SET) < 0)
419			die("Seek to %d failed: %s\n",
420			    sec->shdr_offset, strerror(errno));
421
422		if (fread(&shdr, sizeof(shdr), 1, fp) != 1)
423			die("Cannot read ELF section headers %d/%d: %s\n",
424			    i, ehdr.e_shnum, strerror(errno));
425
426		/* Set relocation section size to 0, effectively removing it.
427		 * This is necessary due to lack of support for relocations
428		 * in objcopy when creating 32bit elf from 64bit elf.
429		 */
430		shdr.sh_size = 0;
431
432		if (fseek(fp, sec->shdr_offset, SEEK_SET) < 0)
433			die("Seek to %d failed: %s\n",
434			    sec->shdr_offset, strerror(errno));
435
436		if (fwrite(&shdr, sizeof(shdr), 1, fp) != 1)
437			die("Cannot write ELF section headers %d/%d: %s\n",
438			    i, ehdr.e_shnum, strerror(errno));
439	}
440}
441
442static void add_reloc(struct relocs *r, uint32_t offset, unsigned type)
443{
444	/* Relocation representation in binary table:
445	 * |76543210|76543210|76543210|76543210|
446	 * |  Type  |  offset from _text >> 2  |
447	 */
448	offset >>= 2;
449	if (offset > 0x00FFFFFF)
450		die("Kernel image exceeds maximum size for relocation!\n");
451
452	offset = (offset & 0x00FFFFFF) | ((type & 0xFF) << 24);
453
454	if (r->count == r->size) {
455		unsigned long newsize = r->size + 50000;
456		void *mem = realloc(r->offset, newsize * sizeof(r->offset[0]));
457
458		if (!mem)
459			die("realloc failed\n");
460
461		r->offset = mem;
462		r->size = newsize;
463	}
464	r->offset[r->count++] = offset;
465}
466
467static void walk_relocs(int (*process)(struct section *sec, Elf_Rel *rel,
468			Elf_Sym *sym, const char *symname))
469{
470	int i;
471
472	/* Walk through the relocations */
473	for (i = 0; i < ehdr.e_shnum; i++) {
474		char *sym_strtab;
475		Elf_Sym *sh_symtab;
476		struct section *sec_applies, *sec_symtab;
477		int j;
478		struct section *sec = &secs[i];
479
480		if (sec->shdr.sh_type != SHT_REL_TYPE)
481			continue;
482
483		sec_symtab  = sec->link;
484		sec_applies = &secs[sec->shdr.sh_info];
485		if (!(sec_applies->shdr.sh_flags & SHF_ALLOC))
486			continue;
487
488		sh_symtab = sec_symtab->symtab;
489		sym_strtab = sec_symtab->link->strtab;
490		for (j = 0; j < sec->shdr.sh_size/sizeof(Elf_Rel); j++) {
491			Elf_Rel *rel = &sec->reltab[j];
492			Elf_Sym *sym = &sh_symtab[ELF_R_SYM(rel->r_info)];
493			const char *symname = sym_name(sym_strtab, sym);
494
495			process(sec, rel, sym, symname);
496		}
497	}
498}
499
500static int do_reloc(struct section *sec, Elf_Rel *rel, Elf_Sym *sym,
501		      const char *symname)
502{
503	unsigned r_type = ELF_R_TYPE(rel->r_info);
504	unsigned bind = ELF_ST_BIND(sym->st_info);
505
506	if ((bind == STB_WEAK) && (sym->st_value == 0)) {
507		/* Don't relocate weak symbols without a target */
508		return 0;
509	}
510
511	if (regex_skip_reloc(symname))
512		return 0;
513
514	switch (r_type) {
515	case R_MIPS_NONE:
516	case R_MIPS_REL32:
517	case R_MIPS_PC16:
518	case R_MIPS_PC21_S2:
519	case R_MIPS_PC26_S2:
520		/*
521		 * NONE can be ignored and PC relative relocations don't
522		 * need to be adjusted.
523		 */
524	case R_MIPS_HIGHEST:
525	case R_MIPS_HIGHER:
526		/* We support relocating within the same 4Gb segment only,
527		 * thus leaving the top 32bits unchanged
528		 */
529	case R_MIPS_LO16:
530		/* We support relocating by 64k jumps only
531		 * thus leaving the bottom 16bits unchanged
532		 */
533		break;
534
535	case R_MIPS_64:
536	case R_MIPS_32:
537	case R_MIPS_26:
538	case R_MIPS_HI16:
539		add_reloc(&relocs, rel->r_offset, r_type);
540		break;
541
542	default:
543		die("Unsupported relocation type: %s (%d)\n",
544		    rel_type(r_type), r_type);
545		break;
546	}
547
548	return 0;
549}
550
551static int write_reloc_as_bin(uint32_t v, FILE *f)
552{
553	unsigned char buf[4];
554
555	v = cpu_to_elf32(v);
556
557	memcpy(buf, &v, sizeof(uint32_t));
558	return fwrite(buf, 1, 4, f);
559}
560
561static int write_reloc_as_text(uint32_t v, FILE *f)
562{
563	int res;
564
565	res = fprintf(f, "\t.long 0x%08"PRIx32"\n", v);
566	if (res < 0)
567		return res;
568	else
569		return sizeof(uint32_t);
570}
571
572static void emit_relocs(int as_text, int as_bin, FILE *outf)
573{
574	int i;
575	int (*write_reloc)(uint32_t, FILE *) = write_reloc_as_bin;
576	int size = 0;
577	int size_reserved;
578	struct section *sec_reloc;
579
580	sec_reloc = sec_lookup(".data.reloc");
581	if (!sec_reloc)
582		die("Could not find relocation section\n");
583
584	size_reserved = sec_reloc->shdr.sh_size;
585
586	/* Collect up the relocations */
587	walk_relocs(do_reloc);
588
589	/* Print the relocations */
590	if (as_text) {
591		/* Print the relocations in a form suitable that
592		 * gas will like.
593		 */
594		printf(".section \".data.reloc\",\"a\"\n");
595		printf(".balign 4\n");
596		/* Output text to stdout */
597		write_reloc = write_reloc_as_text;
598		outf = stdout;
599	} else if (as_bin) {
600		/* Output raw binary to stdout */
601		outf = stdout;
602	} else {
603		/* Seek to offset of the relocation section.
604		* Each relocation is then written into the
605		* vmlinux kernel image.
606		*/
607		if (fseek(outf, sec_reloc->shdr.sh_offset, SEEK_SET) < 0) {
608			die("Seek to %d failed: %s\n",
609				sec_reloc->shdr.sh_offset, strerror(errno));
610		}
611	}
612
613	for (i = 0; i < relocs.count; i++)
614		size += write_reloc(relocs.offset[i], outf);
615
616	/* Print a stop, but only if we've actually written some relocs */
617	if (size)
618		size += write_reloc(0, outf);
619
620	if (size > size_reserved)
621		/* Die, but suggest a value for CONFIG_RELOCATION_TABLE_SIZE
622		 * which will fix this problem and allow a bit of headroom
623		 * if more kernel features are enabled
624		 */
625		die("Relocations overflow available space!\n" \
626		    "Please adjust CONFIG_RELOCATION_TABLE_SIZE " \
627		    "to at least 0x%08x\n", (size + 0x1000) & ~0xFFF);
628}
629
630/*
631 * As an aid to debugging problems with different linkers
632 * print summary information about the relocs.
633 * Since different linkers tend to emit the sections in
634 * different orders we use the section names in the output.
635 */
636static int do_reloc_info(struct section *sec, Elf_Rel *rel, ElfW(Sym) *sym,
637				const char *symname)
638{
639	printf("%16s  0x%08x  %16s  %40s  %16s\n",
640		sec_name(sec->shdr.sh_info),
641		(unsigned int)rel->r_offset,
642		rel_type(ELF_R_TYPE(rel->r_info)),
643		symname,
644		sec_name(sym->st_shndx));
645	return 0;
646}
647
648static void print_reloc_info(void)
649{
650	printf("%16s  %10s  %16s  %40s  %16s\n",
651		"reloc section",
652		"offset",
653		"reloc type",
654		"symbol",
655		"symbol section");
656	walk_relocs(do_reloc_info);
657}
658
659#if ELF_BITS == 64
660# define process process_64
661#else
662# define process process_32
663#endif
664
665void process(FILE *fp, int as_text, int as_bin,
666	     int show_reloc_info, int keep_relocs)
667{
668	regex_init();
669	read_ehdr(fp);
670	read_shdrs(fp);
671	read_strtabs(fp);
672	read_symtabs(fp);
673	read_relocs(fp);
674	if (show_reloc_info) {
675		print_reloc_info();
676		return;
677	}
678	emit_relocs(as_text, as_bin, fp);
679	if (!keep_relocs)
680		remove_relocs(fp);
681}
682