?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
NASM 0.95
[nasm/avx512.git] / outelf.c
blob3c7f27635fd2ad55a9525f4b01287ef7ac05487d
1 /* outelf.c output routines for the Netwide Assembler to produce
2 * ELF32 (i386 of course) object file format
3 *
4 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
5 * Julian Hall. All rights reserved. The software is
6 * redistributable under the licence given in the file "Licence"
7 * distributed in the NASM archive.
8 */
9
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include <ctype.h>
14
15 #include "nasm.h"
16 #include "nasmlib.h"
17 #include "outform.h"
18
19 #ifdef OF_ELF
20
21 struct Reloc {
22 struct Reloc *next;
23 long address; /* relative to _start_ of section */
24 long symbol; /* ELF symbol info thingy */
25 int relative; /* TRUE or FALSE */
26 };
27
28 struct Symbol {
29 long strpos; /* string table position of name */
30 long section; /* section ID of the symbol */
31 int type; /* TRUE or FALSE */
32 long value; /* address, or COMMON variable size */
33 };
34
35 #define SHT_PROGBITS 1
36 #define SHT_NOBITS 8
37
38 #define SHF_WRITE 1
39 #define SHF_ALLOC 2
40 #define SHF_EXECINSTR 4
41
42 struct Section {
43 struct SAA *data;
44 unsigned long len, size, nrelocs;
45 long index;
46 int type; /* SHT_PROGBITS or SHT_NOBITS */
47 int align; /* alignment: power of two */
48 unsigned long flags; /* section flags */
49 char *name;
50 struct SAA *rel;
51 long rellen;
52 struct Reloc *head, **tail;
53 };
54
55 #define SECT_DELTA 32
56 static struct Section **sects;
57 static int nsects, sectlen;
58
59 #define SHSTR_DELTA 256
60 static char *shstrtab;
61 static int shstrtablen, shstrtabsize;
62
63 static struct SAA *syms;
64 static unsigned long nlocals, nglobs;
65
66 static long def_seg;
67
68 static struct RAA *bsym;
69
70 static struct SAA *strs;
71 static unsigned long strslen;
72
73 static FILE *elffp;
74 static efunc error;
75
76 static char elf_module[FILENAME_MAX];
77
78 #define SHN_ABS 0xFFF1
79 #define SHN_COMMON 0xFFF2
80 #define SHN_UNDEF 0
81
82 #define SYM_SECTION 0x04
83 #define SYM_GLOBAL 0x10
84
85 #define GLOBAL_TEMP_BASE 6 /* bigger than any constant sym id */
86
87 #define SEG_ALIGN 16 /* alignment of sections in file */
88 #define SEG_ALIGN_1 (SEG_ALIGN-1)
89
90 static const char align_str[SEG_ALIGN] = ""; /* ANSI will pad this with 0s */
91
92 #define ELF_MAX_SECTIONS 16 /* really 10, but let's play safe */
93 static struct ELF_SECTDATA {
94 void *data;
95 long len;
96 int is_saa;
97 } elf_sects[ELF_MAX_SECTIONS];
98 static int elf_nsect;
99 static long elf_foffs;
100
101 static void elf_write(void);
102 static void elf_sect_write(struct Section *, unsigned char *, unsigned long);
103 static void elf_section_header (int, int, int, void *, int, long,
104 int, int, int, int);
105 static void elf_write_sections (void);
106 static struct SAA *elf_build_symtab (long *, long *);
107 static struct SAA *elf_build_reltab (long *, struct Reloc *);
108 static void add_sectname (char *, char *);
109
110 static void elf_init(FILE *fp, efunc errfunc, ldfunc ldef) {
111 elffp = fp;
112 error = errfunc;
113 (void) ldef; /* placate optimisers */
114 sects = NULL;
115 nsects = sectlen = 0;
116 syms = saa_init((long)sizeof(struct Symbol));
117 nlocals = nglobs = 0;
118 bsym = raa_init();
119 strs = saa_init(1L);
120 saa_wbytes (strs, "\0", 1L);
121 saa_wbytes (strs, elf_module, (long)(strlen(elf_module)+1));
122 strslen = 2+strlen(elf_module);
123 shstrtab = NULL;
124 shstrtablen = shstrtabsize = 0;;
125 add_sectname ("", "");
126 def_seg = seg_alloc();
127 }
128
129 static void elf_cleanup(void) {
130 struct Reloc *r;
131 int i;
132
133 elf_write();
134 fclose (elffp);
135 for (i=0; i<nsects; i++) {
136 if (sects[i]->type != SHT_NOBITS)
137 saa_free (sects[i]->data);
138 if (sects[i]->head)
139 saa_free (sects[i]->rel);
140 while (sects[i]->head) {
141 r = sects[i]->head;
142 sects[i]->head = sects[i]->head->next;
143 nasm_free (r);
144 }
145 }
146 nasm_free (sects);
147 saa_free (syms);
148 raa_free (bsym);
149 saa_free (strs);
150 }
151
152 static void add_sectname (char *firsthalf, char *secondhalf) {
153 int len = strlen(firsthalf)+strlen(secondhalf);
154 while (shstrtablen + len + 1 > shstrtabsize)
155 shstrtab = nasm_realloc (shstrtab, (shstrtabsize += SHSTR_DELTA));
156 strcpy (shstrtab+shstrtablen, firsthalf);
157 strcat (shstrtab+shstrtablen, secondhalf);
158 shstrtablen += len+1;
159 }
160
161 static int elf_make_section (char *name, int type, int flags, int align) {
162 struct Section *s;
163
164 s = nasm_malloc (sizeof(*s));
165
166 if (type != SHT_NOBITS)
167 s->data = saa_init (1L);
168 s->head = NULL;
169 s->tail = &s->head;
170 s->len = s->size = 0;
171 s->nrelocs = 0;
172 if (!strcmp(name, ".text"))
173 s->index = def_seg;
174 else
175 s->index = seg_alloc();
176 add_sectname ("", name);
177 s->name = nasm_malloc (1+strlen(name));
178 strcpy (s->name, name);
179 s->type = type;
180 s->flags = flags;
181 s->align = align;
182
183 if (nsects >= sectlen)
184 sects = nasm_realloc (sects, (sectlen += SECT_DELTA)*sizeof(*sects));
185 sects[nsects++] = s;
186
187 return nsects-1;
188 }
189
190 static long elf_section_names (char *name, int pass, int *bits) {
191 char *p;
192 int flags_and, flags_or, type, align, i;
193
194 /*
195 * Default is 32 bits.
196 */
197 if (!name)
198 *bits = 32;
199
200 if (!name)
201 return def_seg;
202
203 p = name;
204 while (*p && !isspace(*p)) p++;
205 if (*p) *p++ = '\0';
206 flags_and = flags_or = type = align = 0;
207
208 while (*p && isspace(*p)) p++;
209 while (*p) {
210 char *q = p;
211 while (*p && !isspace(*p)) p++;
212 if (*p) *p++ = '\0';
213 while (*p && isspace(*p)) p++;
214
215 if (!nasm_strnicmp(q, "align=", 6)) {
216 align = atoi(q+6);
217 if (align == 0)
218 align = 1;
219 if ( (align-1) & align ) { /* means it's not a power of two */
220 error (ERR_NONFATAL, "section alignment %d is not"
221 " a power of two", align);
222 align = 1;
223 }
224 } else if (!nasm_stricmp(q, "alloc")) {
225 flags_and |= SHF_ALLOC;
226 flags_or |= SHF_ALLOC;
227 } else if (!nasm_stricmp(q, "noalloc")) {
228 flags_and |= SHF_ALLOC;
229 flags_or &= ~SHF_ALLOC;
230 } else if (!nasm_stricmp(q, "exec")) {
231 flags_and |= SHF_EXECINSTR;
232 flags_or |= SHF_EXECINSTR;
233 } else if (!nasm_stricmp(q, "noexec")) {
234 flags_and |= SHF_EXECINSTR;
235 flags_or &= ~SHF_EXECINSTR;
236 } else if (!nasm_stricmp(q, "write")) {
237 flags_and |= SHF_WRITE;
238 flags_or |= SHF_WRITE;
239 } else if (!nasm_stricmp(q, "nowrite")) {
240 flags_and |= SHF_WRITE;
241 flags_or &= ~SHF_WRITE;
242 } else if (!nasm_stricmp(q, "progbits")) {
243 type = SHT_PROGBITS;
244 } else if (!nasm_stricmp(q, "nobits")) {
245 type = SHT_NOBITS;
246 }
247 }
248
249 if (!strcmp(name, ".comment") ||
250 !strcmp(name, ".shstrtab") ||
251 !strcmp(name, ".symtab") ||
252 !strcmp(name, ".strtab")) {
253 error (ERR_NONFATAL, "attempt to redefine reserved section"
254 "name `%s'", name);
255 return NO_SEG;
256 }
257
258 for (i=0; i<nsects; i++)
259 if (!strcmp(name, sects[i]->name))
260 break;
261 if (i == nsects) {
262 if (!strcmp(name, ".text"))
263 i = elf_make_section (name, SHT_PROGBITS,
264 SHF_ALLOC | SHF_EXECINSTR, 16);
265 else if (!strcmp(name, ".data"))
266 i = elf_make_section (name, SHT_PROGBITS,
267 SHF_ALLOC | SHF_WRITE, 4);
268 else if (!strcmp(name, ".bss"))
269 i = elf_make_section (name, SHT_NOBITS,
270 SHF_ALLOC | SHF_WRITE, 4);
271 else
272 i = elf_make_section (name, SHT_PROGBITS, SHF_ALLOC, 1);
273 if (type)
274 sects[i]->type = type;
275 if (align)
276 sects[i]->align = align;
277 sects[i]->flags &= ~flags_and;
278 sects[i]->flags |= flags_or;
279 } else if (pass == 1) {
280 if (type || align || flags_and)
281 error (ERR_WARNING, "section attributes ignored on"
282 " redeclaration of section `%s'", name);
283 }
284
285 return sects[i]->index;
286 }
287
288 static void elf_deflabel (char *name, long segment, long offset,
289 int is_global) {
290 int pos = strslen;
291 struct Symbol *sym;
292
293 if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
294 error (ERR_NONFATAL, "unrecognised special symbol `%s'", name);
295 return;
296 }
297
298 saa_wbytes (strs, name, (long)(1+strlen(name)));
299 strslen += 1+strlen(name);
300
301 sym = saa_wstruct (syms);
302
303 sym->strpos = pos;
304 sym->type = is_global ? SYM_GLOBAL : 0;
305 if (segment == NO_SEG)
306 sym->section = SHN_ABS;
307 else {
308 int i;
309 sym->section = SHN_UNDEF;
310 if (nsects == 0 && segment == def_seg) {
311 int tempint;
312 if (segment != elf_section_names (".text", 2, &tempint))
313 error (ERR_PANIC, "strange segment conditions in ELF driver");
314 sym->section = nsects;
315 } else {
316 for (i=0; i<nsects; i++)
317 if (segment == sects[i]->index) {
318 sym->section = i+1;
319 break;
320 }
321 }
322 }
323
324 if (is_global == 2) {
325 sym->value = offset;
326 sym->section = SHN_COMMON;
327 } else
328 sym->value = (sym->section == SHN_UNDEF ? 0 : offset);
329
330 if (sym->type == SYM_GLOBAL) {
331 if (sym->section == SHN_UNDEF || sym->section == SHN_COMMON)
332 bsym = raa_write (bsym, segment, nglobs);
333 nglobs++;
334 } else
335 nlocals++;
336 }
337
338 static void elf_add_reloc (struct Section *sect, long segment,
339 int relative) {
340 struct Reloc *r;
341
342 r = *sect->tail = nasm_malloc(sizeof(struct Reloc));
343 sect->tail = &r->next;
344 r->next = NULL;
345
346 r->address = sect->len;
347 if (segment == NO_SEG)
348 r->symbol = 2;
349 else {
350 int i;
351 r->symbol = 0;
352 for (i=0; i<nsects; i++)
353 if (segment == sects[i]->index)
354 r->symbol = i+3;
355 if (!r->symbol)
356 r->symbol = GLOBAL_TEMP_BASE + raa_read(bsym, segment);
357 }
358 r->relative = relative;
359
360 sect->nrelocs++;
361 }
362
363 static void elf_out (long segto, void *data, unsigned long type,
364 long segment, long wrt) {
365 struct Section *s;
366 long realbytes = type & OUT_SIZMASK;
367 unsigned char mydata[4], *p;
368 int i;
369
370 if (wrt != NO_SEG) {
371 wrt = NO_SEG; /* continue to do _something_ */
372 error (ERR_NONFATAL, "WRT not supported by ELF output format");
373 }
374
375 type &= OUT_TYPMASK;
376
377 /*
378 * handle absolute-assembly (structure definitions)
379 */
380 if (segto == NO_SEG) {
381 if (type != OUT_RESERVE)
382 error (ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
383 " space");
384 return;
385 }
386
387 s = NULL;
388 for (i=0; i<nsects; i++)
389 if (segto == sects[i]->index) {
390 s = sects[i];
391 break;
392 }
393 if (!s) {
394 int tempint; /* ignored */
395 if (segto != elf_section_names (".text", 2, &tempint))
396 error (ERR_PANIC, "strange segment conditions in ELF driver");
397 else
398 s = sects[nsects-1];
399 }
400
401 if (s->type == SHT_NOBITS && type != OUT_RESERVE) {
402 error(ERR_WARNING, "attempt to initialise memory in"
403 " BSS section `%s': ignored", s->name);
404 if (type == OUT_REL2ADR)
405 realbytes = 2;
406 else if (type == OUT_REL4ADR)
407 realbytes = 4;
408 s->len += realbytes;
409 return;
410 }
411
412 if (type == OUT_RESERVE) {
413 if (s->type == SHT_PROGBITS) {
414 error(ERR_WARNING, "uninitialised space declared in"
415 " non-BSS section `%s': zeroing", s->name);
416 elf_sect_write (s, NULL, realbytes);
417 } else
418 s->len += realbytes;
419 } else if (type == OUT_RAWDATA) {
420 if (segment != NO_SEG)
421 error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
422 elf_sect_write (s, data, realbytes);
423 } else if (type == OUT_ADDRESS) {
424 if (wrt != NO_SEG)
425 error(ERR_NONFATAL, "ELF format does not support WRT types");
426 if (segment != NO_SEG) {
427 if (segment % 2) {
428 error(ERR_NONFATAL, "ELF format does not support"
429 " segment base references");
430 } else
431 elf_add_reloc (s, segment, FALSE);
432 }
433 p = mydata;
434 if (realbytes == 2 && segment != NO_SEG)
435 error (ERR_NONFATAL, "ELF format does not support 16-bit"
436 " relocations");
437 WRITELONG (p, *(long *)data);
438 elf_sect_write (s, mydata, realbytes);
439 } else if (type == OUT_REL2ADR) {
440 error (ERR_NONFATAL, "ELF format does not support 16-bit"
441 " relocations");
442 } else if (type == OUT_REL4ADR) {
443 if (segment == segto)
444 error(ERR_PANIC, "intra-segment OUT_REL4ADR");
445 if (segment != NO_SEG && segment % 2) {
446 error(ERR_NONFATAL, "ELF format does not support"
447 " segment base references");
448 } else
449 elf_add_reloc (s, segment, TRUE);
450 p = mydata;
451 WRITELONG (p, *(long*)data - realbytes);
452 elf_sect_write (s, mydata, 4L);
453 }
454 }
455
456 static void elf_write(void) {
457 int nsections, align;
458 char *p;
459 int commlen;
460 char comment[64];
461 int i;
462
463 struct SAA *symtab;
464 long symtablen, symtablocal;
465
466 /*
467 * Work out how many sections we will have. We have SHN_UNDEF,
468 * then the flexible user sections, then the four fixed
469 * sections `.comment', `.shstrtab', `.symtab' and `.strtab',
470 * then optionally relocation sections for the user sections.
471 */
472 nsections = 5; /* SHN_UNDEF and the fixed ones */
473 add_sectname ("", ".comment");
474 add_sectname ("", ".shstrtab");
475 add_sectname ("", ".symtab");
476 add_sectname ("", ".strtab");
477 for (i=0; i<nsects; i++) {
478 nsections++; /* for the section itself */
479 if (sects[i]->head) {
480 nsections++; /* for its relocations */
481 add_sectname (".rel", sects[i]->name);
482 }
483 }
484
485 /*
486 * Do the comment.
487 */
488 *comment = '\0';
489 commlen = 2+sprintf(comment+1, "The Netwide Assembler %s", NASM_VER);
490
491 /*
492 * Output the ELF header.
493 */
494 fwrite ("\177ELF\1\1\1\0\0\0\0\0\0\0\0\0", 16, 1, elffp);
495 fwriteshort (1, elffp); /* ET_REL relocatable file */
496 fwriteshort (3, elffp); /* EM_386 processor ID */
497 fwritelong (1L, elffp); /* EV_CURRENT file format version */
498 fwritelong (0L, elffp); /* no entry point */
499 fwritelong (0L, elffp); /* no program header table */
500 fwritelong (0x40L, elffp); /* section headers straight after
501 * ELF header plus alignment */
502 fwritelong (0L, elffp); /* 386 defines no special flags */
503 fwriteshort (0x34, elffp); /* size of ELF header */
504 fwriteshort (0, elffp); /* no program header table, again */
505 fwriteshort (0, elffp); /* still no program header table */
506 fwriteshort (0x28, elffp); /* size of section header */
507 fwriteshort (nsections, elffp); /* number of sections */
508 fwriteshort (nsects+2, elffp); /* string table section index for
509 * section header table */
510 fwritelong (0L, elffp); /* align to 0x40 bytes */
511 fwritelong (0L, elffp);
512 fwritelong (0L, elffp);
513
514 /*
515 * Build the symbol table and relocation tables.
516 */
517 symtab = elf_build_symtab (&symtablen, &symtablocal);
518 for (i=0; i<nsects; i++)
519 if (sects[i]->head)
520 sects[i]->rel = elf_build_reltab (&sects[i]->rellen,
521 sects[i]->head);
522
523 /*
524 * Now output the section header table.
525 */
526
527 elf_foffs = 0x40 + 0x28 * nsections;
528 align = ((elf_foffs+SEG_ALIGN_1) & ~SEG_ALIGN_1) - elf_foffs;
529 elf_foffs += align;
530 elf_nsect = 0;
531
532 elf_section_header (0, 0, 0, NULL, FALSE, 0L, 0, 0, 0, 0); /* SHN_UNDEF */
533 p = shstrtab+1;
534 for (i=0; i<nsects; i++) {
535 elf_section_header (p - shstrtab, sects[i]->type, sects[i]->flags,
536 (sects[i]->type == SHT_PROGBITS ?
537 sects[i]->data : NULL), TRUE,
538 sects[i]->len, 0, 0, sects[i]->align, 0);
539 p += strlen(p)+1;
540 }
541 elf_section_header (p - shstrtab, 1, 0, comment, FALSE,
542 (long)commlen, 0, 0, 1, 0);/* .comment */
543 p += strlen(p)+1;
544 elf_section_header (p - shstrtab, 3, 0, shstrtab, FALSE,
545 (long)shstrtablen, 0, 0, 1, 0);/* .shstrtab */
546 p += strlen(p)+1;
547 elf_section_header (p - shstrtab, 2, 0, symtab, TRUE,
548 symtablen, nsects+4, symtablocal, 4, 16);/* .symtab */
549 p += strlen(p)+1;
550 elf_section_header (p - shstrtab, 3, 0, strs, TRUE,
551 strslen, 0, 0, 1, 0); /* .strtab */
552 for (i=0; i<nsects; i++) if (sects[i]->head) {
553 p += strlen(p)+1;
554 elf_section_header (p - shstrtab, 9, 0, sects[i]->rel, TRUE,
555 sects[i]->rellen, nsects+3, i+1, 4, 8);
556 }
557
558 fwrite (align_str, align, 1, elffp);
559
560 /*
561 * Now output the sections.
562 */
563 elf_write_sections();
564
565 saa_free (symtab);
566 }
567
568 static struct SAA *elf_build_symtab (long *len, long *local) {
569 struct SAA *s = saa_init(1L);
570 struct Symbol *sym;
571 unsigned char entry[16], *p;
572 int i;
573
574 *len = *local = 0;
575
576 /*
577 * First, an all-zeros entry, required by the ELF spec.
578 */
579 saa_wbytes (s, NULL, 16L); /* null symbol table entry */
580 *len += 16;
581 (*local)++;
582
583 /*
584 * Next, an entry for the file name.
585 */
586 p = entry;
587 WRITELONG (p, 1); /* we know it's 1st thing in strtab */
588 WRITELONG (p, 0); /* no value */
589 WRITELONG (p, 0); /* no size either */
590 WRITESHORT (p, 4); /* type FILE */
591 WRITESHORT (p, SHN_ABS);
592 saa_wbytes (s, entry, 16L);
593 *len += 16;
594 (*local)++;
595
596 /*
597 * Now some standard symbols defining the segments, for relocation
598 * purposes.
599 */
600 for (i = 1; i <= nsects+1; i++) {
601 p = entry;
602 WRITELONG (p, 0); /* no symbol name */
603 WRITELONG (p, 0); /* offset zero */
604 WRITELONG (p, 0); /* size zero */
605 WRITESHORT (p, 3); /* local section-type thing */
606 WRITESHORT (p, (i==1 ? SHN_ABS : i-1)); /* the section id */
607 saa_wbytes (s, entry, 16L);
608 *len += 16;
609 (*local)++;
610 }
611
612 /*
613 * Now the other local symbols.
614 */
615 saa_rewind (syms);
616 while ( (sym = saa_rstruct (syms)) ) {
617 if (sym->type == SYM_GLOBAL)
618 continue;
619 p = entry;
620 WRITELONG (p, sym->strpos);
621 WRITELONG (p, sym->value);
622 if (sym->section == SHN_COMMON)
623 WRITELONG (p, sym->value);
624 else
625 WRITELONG (p, 0);
626 WRITESHORT (p, 0); /* local non-typed thing */
627 WRITESHORT (p, sym->section);
628 saa_wbytes (s, entry, 16L);
629 *len += 16;
630 (*local)++;
631 }
632
633 /*
634 * Now the global symbols.
635 */
636 saa_rewind (syms);
637 while ( (sym = saa_rstruct (syms)) ) {
638 if (sym->type != SYM_GLOBAL)
639 continue;
640 p = entry;
641 WRITELONG (p, sym->strpos);
642 WRITELONG (p, sym->value);
643 if (sym->section == SHN_COMMON)
644 WRITELONG (p, sym->value);
645 else
646 WRITELONG (p, 0);
647 WRITESHORT (p, SYM_GLOBAL); /* global non-typed thing */
648 WRITESHORT (p, sym->section);
649 saa_wbytes (s, entry, 16L);
650 *len += 16;
651 }
652
653 return s;
654 }
655
656 static struct SAA *elf_build_reltab (long *len, struct Reloc *r) {
657 struct SAA *s;
658 unsigned char *p, entry[8];
659
660 if (!r)
661 return NULL;
662
663 s = saa_init(1L);
664 *len = 0;
665
666 while (r) {
667 long sym = r->symbol;
668
669 if (sym >= GLOBAL_TEMP_BASE)
670 sym += -GLOBAL_TEMP_BASE + (nsects+3) + nlocals;
671
672 p = entry;
673 WRITELONG (p, r->address);
674 WRITELONG (p, (sym << 8) + (r->relative ? 2 : 1));
675 saa_wbytes (s, entry, 8L);
676 *len += 8;
677
678 r = r->next;
679 }
680
681 return s;
682 }
683
684 static void elf_section_header (int name, int type, int flags,
685 void *data, int is_saa, long datalen,
686 int link, int info, int align, int eltsize) {
687 elf_sects[elf_nsect].data = data;
688 elf_sects[elf_nsect].len = datalen;
689 elf_sects[elf_nsect].is_saa = is_saa;
690 elf_nsect++;
691
692 fwritelong ((long)name, elffp);
693 fwritelong ((long)type, elffp);
694 fwritelong ((long)flags, elffp);
695 fwritelong (0L, elffp); /* no address, ever, in object files */
696 fwritelong (type == 0 ? 0L : elf_foffs, elffp);
697 fwritelong (datalen, elffp);
698 if (data)
699 elf_foffs += (datalen+SEG_ALIGN_1) & ~SEG_ALIGN_1;
700 fwritelong ((long)link, elffp);
701 fwritelong ((long)info, elffp);
702 fwritelong ((long)align, elffp);
703 fwritelong ((long)eltsize, elffp);
704 }
705
706 static void elf_write_sections (void) {
707 int i;
708 for (i = 0; i < elf_nsect; i++)
709 if (elf_sects[i].data) {
710 long len = elf_sects[i].len;
711 long reallen = (len+SEG_ALIGN_1) & ~SEG_ALIGN_1;
712 long align = reallen - len;
713 if (elf_sects[i].is_saa)
714 saa_fpwrite (elf_sects[i].data, elffp);
715 else
716 fwrite (elf_sects[i].data, len, 1, elffp);
717 fwrite (align_str, align, 1, elffp);
718 }
719 }
720
721 static void elf_sect_write (struct Section *sect,
722 unsigned char *data, unsigned long len) {
723 saa_wbytes (sect->data, data, len);
724 sect->len += len;
725 }
726
727 static long elf_segbase (long segment) {
728 return segment;
729 }
730
731 static int elf_directive (char *directive, char *value, int pass) {
732 return 0;
733 }
734
735 static void elf_filename (char *inname, char *outname, efunc error) {
736 strcpy(elf_module, inname);
737 standard_extension (inname, outname, ".o", error);
738 }
739
740 struct ofmt of_elf = {
741 "ELF32 (i386) object files (e.g. Linux)",
742 "elf",
743 elf_init,
744 elf_out,
745 elf_deflabel,
746 elf_section_names,
747 elf_segbase,
748 elf_directive,
749 elf_filename,
750 elf_cleanup
751 };
752
753 #endif /* OF_ELF */
Adding AVX-512 features