?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
output: outmac -- Fix few nits during merge
[nasm.git] / output / outelf64.c
blobf2a192a304cc08e032e72a6cac28711a95e65b37
1 /* ----------------------------------------------------------------------- *
2 *
3 * Copyright 1996-2013 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
9 * conditions are met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 *
32 * ----------------------------------------------------------------------- */
33
34 /*
35 * outelf64.c output routines for the Netwide Assembler to produce
36 * ELF64 (x86_64 of course) object file format
37 */
38
39 #include "compiler.h"
40
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <ctype.h>
45 #include <inttypes.h>
46
47 #include "nasm.h"
48 #include "nasmlib.h"
49 #include "saa.h"
50 #include "raa.h"
51 #include "stdscan.h"
52 #include "eval.h"
53 #include "output/outform.h"
54 #include "output/outlib.h"
55 #include "rbtree.h"
56
57 #include "output/dwarf.h"
58 #include "output/stabs.h"
59 #include "output/outelf.h"
60
61 #ifdef OF_ELF64
62
63 #define SECT_DELTA 32
64 static struct elf_section **sects;
65 static int nsects, sectlen;
66
67 #define SHSTR_DELTA 256
68 static char *shstrtab;
69 static int shstrtablen, shstrtabsize;
70
71 static struct SAA *syms;
72 static uint32_t nlocals, nglobs, ndebugs; /* Symbol counts */
73
74 static int32_t def_seg;
75
76 static struct RAA *bsym;
77
78 static struct SAA *strs;
79 static uint32_t strslen;
80
81 static struct elf_symbol *fwds;
82
83 static char elf_module[FILENAME_MAX];
84
85 extern struct ofmt of_elf64;
86
87 static struct ELF_SECTDATA {
88 void *data;
89 int64_t len;
90 bool is_saa;
91 } *elf_sects;
92 static int elf_nsect, nsections;
93 static int64_t elf_foffs;
94
95 static void elf_write(void);
96 static void elf_sect_write(struct elf_section *, const void *, size_t);
97 static void elf_sect_writeaddr(struct elf_section *, int64_t, size_t);
98 static void elf_section_header(int, int, uint64_t, void *, bool, uint64_t, int, int,
99 int, int);
100 static void elf_write_sections(void);
101 static struct SAA *elf_build_symtab(int32_t *, int32_t *);
102 static struct SAA *elf_build_reltab(uint64_t *, struct elf_reloc *);
103 static void add_sectname(char *, char *);
104
105 struct erel {
106 int offset, info;
107 };
108
109 struct symlininfo {
110 int offset;
111 int section; /* index into sects[] */
112 int segto; /* internal section number */
113 char *name; /* shallow-copied pointer of section name */
114 };
115
116 struct linelist {
117 struct linelist *next;
118 struct linelist *last;
119 struct symlininfo info;
120 char *filename;
121 int line;
122 };
123
124 struct sectlist {
125 struct SAA *psaa;
126 int section;
127 int line;
128 int offset;
129 int file;
130 struct sectlist *next;
131 struct sectlist *last;
132 };
133
134 /* common debug variables */
135 static int currentline = 1;
136 static int debug_immcall = 0;
137
138 /* stabs debug variables */
139 static struct linelist *stabslines = 0;
140 static int numlinestabs = 0;
141 static char *stabs_filename = 0;
142 static int symtabsection;
143 static uint8_t *stabbuf = 0, *stabstrbuf = 0, *stabrelbuf = 0;
144 static int stablen, stabstrlen, stabrellen;
145
146 /* dwarf debug variables */
147 static struct linelist *dwarf_flist = 0, *dwarf_clist = 0, *dwarf_elist = 0;
148 static struct sectlist *dwarf_fsect = 0, *dwarf_csect = 0, *dwarf_esect = 0;
149 static int dwarf_numfiles = 0, dwarf_nsections;
150 static uint8_t *arangesbuf = 0, *arangesrelbuf = 0, *pubnamesbuf = 0, *infobuf = 0, *inforelbuf = 0,
151 *abbrevbuf = 0, *linebuf = 0, *linerelbuf = 0, *framebuf = 0, *locbuf = 0;
152 static int8_t line_base = -5, line_range = 14, opcode_base = 13;
153 static int arangeslen, arangesrellen, pubnameslen, infolen, inforellen,
154 abbrevlen, linelen, linerellen, framelen, loclen;
155 static int64_t dwarf_infosym, dwarf_abbrevsym, dwarf_linesym;
156
157
158 static struct dfmt df_dwarf;
159 static struct dfmt df_stabs;
160 static struct elf_symbol *lastsym;
161
162 /* common debugging routines */
163 static void debug64_typevalue(int32_t);
164 static void debug64_deflabel(char *, int32_t, int64_t, int, char *);
165 static void debug64_directive(const char *, const char *);
166
167 /* stabs debugging routines */
168 static void stabs64_linenum(const char *filename, int32_t linenumber, int32_t);
169 static void stabs64_output(int, void *);
170 static void stabs64_generate(void);
171 static void stabs64_cleanup(void);
172
173 /* dwarf debugging routines */
174 static void dwarf64_init(void);
175 static void dwarf64_linenum(const char *filename, int32_t linenumber, int32_t);
176 static void dwarf64_output(int, void *);
177 static void dwarf64_generate(void);
178 static void dwarf64_cleanup(void);
179 static void dwarf64_findfile(const char *);
180 static void dwarf64_findsect(const int);
181
182 /*
183 * Special section numbers which are used to define ELF special
184 * symbols, which can be used with WRT to provide PIC relocation
185 * types.
186 */
187 static int32_t elf_gotpc_sect, elf_gotoff_sect;
188 static int32_t elf_got_sect, elf_plt_sect;
189 static int32_t elf_sym_sect;
190 static int32_t elf_gottpoff_sect;
191
192 static void elf_init(void)
193 {
194 sects = NULL;
195 nsects = sectlen = 0;
196 syms = saa_init((int32_t)sizeof(struct elf_symbol));
197 nlocals = nglobs = ndebugs = 0;
198 bsym = raa_init();
199 strs = saa_init(1L);
200 saa_wbytes(strs, "\0", 1L);
201 saa_wbytes(strs, elf_module, strlen(elf_module)+1);
202 strslen = 2 + strlen(elf_module);
203 shstrtab = NULL;
204 shstrtablen = shstrtabsize = 0;;
205 add_sectname("", "");
206
207 fwds = NULL;
208
209 elf_gotpc_sect = seg_alloc();
210 define_label("..gotpc", elf_gotpc_sect + 1, 0L, NULL, false, false);
211 elf_gotoff_sect = seg_alloc();
212 define_label("..gotoff", elf_gotoff_sect + 1, 0L, NULL, false, false);
213 elf_got_sect = seg_alloc();
214 define_label("..got", elf_got_sect + 1, 0L, NULL, false, false);
215 elf_plt_sect = seg_alloc();
216 define_label("..plt", elf_plt_sect + 1, 0L, NULL, false, false);
217 elf_sym_sect = seg_alloc();
218 define_label("..sym", elf_sym_sect + 1, 0L, NULL, false, false);
219 elf_gottpoff_sect = seg_alloc();
220 define_label("..gottpoff", elf_gottpoff_sect + 1, 0L, NULL, false, false);
221
222 def_seg = seg_alloc();
223
224 }
225
226 static void elf_cleanup(int debuginfo)
227 {
228 struct elf_reloc *r;
229 int i;
230
231 (void)debuginfo;
232
233 elf_write();
234 for (i = 0; i < nsects; i++) {
235 if (sects[i]->type != SHT_NOBITS)
236 saa_free(sects[i]->data);
237 if (sects[i]->head)
238 saa_free(sects[i]->rel);
239 while (sects[i]->head) {
240 r = sects[i]->head;
241 sects[i]->head = sects[i]->head->next;
242 nasm_free(r);
243 }
244 }
245 nasm_free(sects);
246 saa_free(syms);
247 raa_free(bsym);
248 saa_free(strs);
249 if (of_elf64.current_dfmt) {
250 of_elf64.current_dfmt->cleanup();
251 }
252 }
253
254 /* add entry to the elf .shstrtab section */
255 static void add_sectname(char *firsthalf, char *secondhalf)
256 {
257 int len = strlen(firsthalf) + strlen(secondhalf);
258 while (shstrtablen + len + 1 > shstrtabsize)
259 shstrtab = nasm_realloc(shstrtab, (shstrtabsize += SHSTR_DELTA));
260 strcpy(shstrtab + shstrtablen, firsthalf);
261 strcat(shstrtab + shstrtablen, secondhalf);
262 shstrtablen += len + 1;
263 }
264
265 static int elf_make_section(char *name, int type, int flags, int align)
266 {
267 struct elf_section *s;
268
269 s = nasm_zalloc(sizeof(*s));
270
271 if (type != SHT_NOBITS)
272 s->data = saa_init(1L);
273 s->tail = &s->head;
274 if (!strcmp(name, ".text"))
275 s->index = def_seg;
276 else
277 s->index = seg_alloc();
278 add_sectname("", name);
279
280 s->name = nasm_strdup(name);
281 s->type = type;
282 s->flags = flags;
283 s->align = align;
284
285 if (nsects >= sectlen)
286 sects = nasm_realloc(sects, (sectlen += SECT_DELTA) * sizeof(*sects));
287 sects[nsects++] = s;
288
289 return nsects - 1;
290 }
291
292 static int32_t elf_section_names(char *name, int pass, int *bits)
293 {
294 char *p;
295 uint32_t flags, flags_and, flags_or;
296 uint64_t align;
297 int type, i;
298
299 /*
300 * Default is 64 bits.
301 */
302 if (!name) {
303 *bits = 64;
304 return def_seg;
305 }
306
307 p = nasm_skip_word(name);
308 if (*p)
309 *p++ = '\0';
310 flags_and = flags_or = type = align = 0;
311
312 elf_section_attrib(name, p, pass, &flags_and,
313 &flags_or, &align, &type);
314
315 if (!strcmp(name, ".shstrtab") ||
316 !strcmp(name, ".symtab") ||
317 !strcmp(name, ".strtab")) {
318 nasm_error(ERR_NONFATAL, "attempt to redefine reserved section"
319 "name `%s'", name);
320 return NO_SEG;
321 }
322
323 for (i = 0; i < nsects; i++)
324 if (!strcmp(name, sects[i]->name))
325 break;
326 if (i == nsects) {
327 const struct elf_known_section *ks = elf_known_sections;
328
329 while (ks->name) {
330 if (!strcmp(name, ks->name))
331 break;
332 ks++;
333 }
334
335 type = type ? type : ks->type;
336 align = align ? align : ks->align;
337 flags = (ks->flags & ~flags_and) | flags_or;
338
339 i = elf_make_section(name, type, flags, align);
340 } else if (pass == 1) {
341 if ((type && sects[i]->type != type)
342 || (align && sects[i]->align != align)
343 || (flags_and && ((sects[i]->flags & flags_and) != flags_or)))
344 nasm_error(ERR_WARNING, "incompatible section attributes ignored on"
345 " redeclaration of section `%s'", name);
346 }
347
348 return sects[i]->index;
349 }
350
351 static void elf_deflabel(char *name, int32_t segment, int64_t offset,
352 int is_global, char *special)
353 {
354 int pos = strslen;
355 struct elf_symbol *sym;
356 bool special_used = false;
357
358 #if defined(DEBUG) && DEBUG>2
359 nasm_error(ERR_DEBUG,
360 " elf_deflabel: %s, seg=%"PRIx32", off=%"PRIx64", is_global=%d, %s\n",
361 name, segment, offset, is_global, special);
362 #endif
363 if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
364 /*
365 * This is a NASM special symbol. We never allow it into
366 * the ELF symbol table, even if it's a valid one. If it
367 * _isn't_ a valid one, we should barf immediately.
368 */
369 if (strcmp(name, "..gotpc") && strcmp(name, "..gotoff") &&
370 strcmp(name, "..got") && strcmp(name, "..plt") &&
371 strcmp(name, "..sym") && strcmp(name, "..gottpoff"))
372 nasm_error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
373 return;
374 }
375
376 if (is_global == 3) {
377 struct elf_symbol **s;
378 /*
379 * Fix up a forward-reference symbol size from the first
380 * pass.
381 */
382 for (s = &fwds; *s; s = &(*s)->nextfwd)
383 if (!strcmp((*s)->name, name)) {
384 struct tokenval tokval;
385 expr *e;
386 char *p = nasm_skip_spaces(nasm_skip_word(special));
387
388 stdscan_reset();
389 stdscan_set(p);
390 tokval.t_type = TOKEN_INVALID;
391 e = evaluate(stdscan, NULL, &tokval, NULL, 1, nasm_error, NULL);
392 if (e) {
393 if (!is_simple(e))
394 nasm_error(ERR_NONFATAL, "cannot use relocatable"
395 " expression as symbol size");
396 else
397 (*s)->size = reloc_value(e);
398 }
399
400 /*
401 * Remove it from the list of unresolved sizes.
402 */
403 nasm_free((*s)->name);
404 *s = (*s)->nextfwd;
405 return;
406 }
407 return; /* it wasn't an important one */
408 }
409
410 saa_wbytes(strs, name, (int32_t)(1 + strlen(name)));
411 strslen += 1 + strlen(name);
412
413 lastsym = sym = saa_wstruct(syms);
414
415 memset(&sym->symv, 0, sizeof(struct rbtree));
416
417 sym->strpos = pos;
418 sym->type = is_global ? SYM_GLOBAL : SYM_LOCAL;
419 sym->other = STV_DEFAULT;
420 sym->size = 0;
421 if (segment == NO_SEG)
422 sym->section = SHN_ABS;
423 else {
424 int i;
425 sym->section = SHN_UNDEF;
426 if (segment == def_seg) {
427 /* we have to be sure at least text section is there */
428 int tempint;
429 if (segment != elf_section_names(".text", 2, &tempint))
430 nasm_error(ERR_PANIC, "strange segment conditions in ELF driver");
431 }
432 for (i = 0; i < nsects; i++) {
433 if (segment == sects[i]->index) {
434 sym->section = i + 1;
435 break;
436 }
437 }
438 }
439
440 if (is_global == 2) {
441 sym->size = offset;
442 sym->symv.key = 0;
443 sym->section = SHN_COMMON;
444 /*
445 * We have a common variable. Check the special text to see
446 * if it's a valid number and power of two; if so, store it
447 * as the alignment for the common variable.
448 */
449 if (special) {
450 bool err;
451 sym->symv.key = readnum(special, &err);
452 if (err)
453 nasm_error(ERR_NONFATAL, "alignment constraint `%s' is not a"
454 " valid number", special);
455 else if ((sym->symv.key | (sym->symv.key - 1)) != 2 * sym->symv.key - 1)
456 nasm_error(ERR_NONFATAL, "alignment constraint `%s' is not a"
457 " power of two", special);
458 }
459 special_used = true;
460 } else
461 sym->symv.key = (sym->section == SHN_UNDEF ? 0 : offset);
462
463 if (sym->type == SYM_GLOBAL) {
464 /*
465 * If sym->section == SHN_ABS, then the first line of the
466 * else section would cause a core dump, because its a reference
467 * beyond the end of the section array.
468 * This behaviour is exhibited by this code:
469 * GLOBAL crash_nasm
470 * crash_nasm equ 0
471 * To avoid such a crash, such requests are silently discarded.
472 * This may not be the best solution.
473 */
474 if (sym->section == SHN_UNDEF || sym->section == SHN_COMMON) {
475 bsym = raa_write(bsym, segment, nglobs);
476 } else if (sym->section != SHN_ABS) {
477 /*
478 * This is a global symbol; so we must add it to the rbtree
479 * of global symbols in its section.
480 *
481 * In addition, we check the special text for symbol
482 * type and size information.
483 */
484 sects[sym->section-1]->gsyms =
485 rb_insert(sects[sym->section-1]->gsyms, &sym->symv);
486
487 if (special) {
488 int n = strcspn(special, " \t");
489
490 if (!nasm_strnicmp(special, "function", n))
491 sym->type |= STT_FUNC;
492 else if (!nasm_strnicmp(special, "data", n) ||
493 !nasm_strnicmp(special, "object", n))
494 sym->type |= STT_OBJECT;
495 else if (!nasm_strnicmp(special, "notype", n))
496 sym->type |= STT_NOTYPE;
497 else
498 nasm_error(ERR_NONFATAL, "unrecognised symbol type `%.*s'",
499 n, special);
500 special += n;
501
502 special = nasm_skip_spaces(special);
503 if (*special) {
504 n = strcspn(special, " \t");
505 if (!nasm_strnicmp(special, "default", n))
506 sym->other = STV_DEFAULT;
507 else if (!nasm_strnicmp(special, "internal", n))
508 sym->other = STV_INTERNAL;
509 else if (!nasm_strnicmp(special, "hidden", n))
510 sym->other = STV_HIDDEN;
511 else if (!nasm_strnicmp(special, "protected", n))
512 sym->other = STV_PROTECTED;
513 else
514 n = 0;
515 special += n;
516 }
517
518 if (*special) {
519 struct tokenval tokval;
520 expr *e;
521 int fwd = 0;
522 char *saveme = stdscan_get();
523
524 while (special[n] && nasm_isspace(special[n]))
525 n++;
526 /*
527 * We have a size expression; attempt to
528 * evaluate it.
529 */
530 stdscan_reset();
531 stdscan_set(special + n);
532 tokval.t_type = TOKEN_INVALID;
533 e = evaluate(stdscan, NULL, &tokval, &fwd, 0, nasm_error,
534 NULL);
535 if (fwd) {
536 sym->nextfwd = fwds;
537 fwds = sym;
538 sym->name = nasm_strdup(name);
539 } else if (e) {
540 if (!is_simple(e))
541 nasm_error(ERR_NONFATAL, "cannot use relocatable"
542 " expression as symbol size");
543 else
544 sym->size = reloc_value(e);
545 }
546 stdscan_set(saveme);
547 }
548 special_used = true;
549 }
550 /*
551 * If TLS segment, mark symbol accordingly.
552 */
553 if (sects[sym->section - 1]->flags & SHF_TLS) {
554 sym->type &= 0xf0;
555 sym->type |= STT_TLS;
556 }
557 }
558 sym->globnum = nglobs;
559 nglobs++;
560 } else
561 nlocals++;
562
563 if (special && !special_used)
564 nasm_error(ERR_NONFATAL, "no special symbol features supported here");
565 }
566
567 static void elf_add_reloc(struct elf_section *sect, int32_t segment,
568 int64_t offset, int type)
569 {
570 struct elf_reloc *r;
571
572 r = *sect->tail = nasm_zalloc(sizeof(struct elf_reloc));
573 sect->tail = &r->next;
574
575 r->address = sect->len;
576 r->offset = offset;
577
578 if (segment != NO_SEG) {
579 int i;
580 for (i = 0; i < nsects; i++)
581 if (segment == sects[i]->index)
582 r->symbol = i + 2;
583 if (!r->symbol)
584 r->symbol = GLOBAL_TEMP_BASE + raa_read(bsym, segment);
585 }
586 r->type = type;
587
588 sect->nrelocs++;
589 }
590
591 /*
592 * This routine deals with ..got and ..sym relocations: the more
593 * complicated kinds. In shared-library writing, some relocations
594 * with respect to global symbols must refer to the precise symbol
595 * rather than referring to an offset from the base of the section
596 * _containing_ the symbol. Such relocations call to this routine,
597 * which searches the symbol list for the symbol in question.
598 *
599 * R_386_GOT32 references require the _exact_ symbol address to be
600 * used; R_386_32 references can be at an offset from the symbol.
601 * The boolean argument `exact' tells us this.
602 *
603 * Return value is the adjusted value of `addr', having become an
604 * offset from the symbol rather than the section. Should always be
605 * zero when returning from an exact call.
606 *
607 * Limitation: if you define two symbols at the same place,
608 * confusion will occur.
609 *
610 * Inefficiency: we search, currently, using a linked list which
611 * isn't even necessarily sorted.
612 */
613 static void elf_add_gsym_reloc(struct elf_section *sect,
614 int32_t segment, uint64_t offset, int64_t pcrel,
615 int type, bool exact)
616 {
617 struct elf_reloc *r;
618 struct elf_section *s;
619 struct elf_symbol *sym;
620 struct rbtree *srb;
621 int i;
622
623 /*
624 * First look up the segment/offset pair and find a global
625 * symbol corresponding to it. If it's not one of our segments,
626 * then it must be an external symbol, in which case we're fine
627 * doing a normal elf_add_reloc after first sanity-checking
628 * that the offset from the symbol is zero.
629 */
630 s = NULL;
631 for (i = 0; i < nsects; i++)
632 if (segment == sects[i]->index) {
633 s = sects[i];
634 break;
635 }
636
637 if (!s) {
638 if (exact && offset)
639 nasm_error(ERR_NONFATAL, "invalid access to an external symbol");
640 else
641 elf_add_reloc(sect, segment, offset - pcrel, type);
642 return;
643 }
644
645 srb = rb_search(s->gsyms, offset);
646 if (!srb || (exact && srb->key != offset)) {
647 nasm_error(ERR_NONFATAL, "unable to find a suitable global symbol"
648 " for this reference");
649 return;
650 }
651 sym = container_of(srb, struct elf_symbol, symv);
652
653 r = *sect->tail = nasm_malloc(sizeof(struct elf_reloc));
654 sect->tail = &r->next;
655 r->next = NULL;
656
657 r->address = sect->len;
658 r->offset = offset - pcrel - sym->symv.key;
659 r->symbol = GLOBAL_TEMP_BASE + sym->globnum;
660 r->type = type;
661
662 sect->nrelocs++;
663 }
664
665 static void elf_out(int32_t segto, const void *data,
666 enum out_type type, uint64_t size,
667 int32_t segment, int32_t wrt)
668 {
669 struct elf_section *s;
670 int64_t addr;
671 int reltype, bytes;
672 int i;
673 static struct symlininfo sinfo;
674
675 #if defined(DEBUG) && DEBUG>2
676 if (data)
677 nasm_error(ERR_DEBUG,
678 " elf_out line: %d type: %x seg: %"PRIx32" segto: %"PRIx32" bytes: %"PRIx64" data: %"PRIx64"\n",
679 currentline, type, segment, segto, size, *(int64_t *)data);
680 else
681 nasm_error(ERR_DEBUG,
682 " elf_out line: %d type: %x seg: %"PRIx32" segto: %"PRIx32" bytes: %"PRIx64"\n",
683 currentline, type, segment, segto, size);
684 #endif
685
686 /*
687 * handle absolute-assembly (structure definitions)
688 */
689 if (segto == NO_SEG) {
690 if (type != OUT_RESERVE)
691 nasm_error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
692 " space");
693 return;
694 }
695
696 s = NULL;
697 for (i = 0; i < nsects; i++)
698 if (segto == sects[i]->index) {
699 s = sects[i];
700 break;
701 }
702 if (!s) {
703 int tempint; /* ignored */
704 if (segto != elf_section_names(".text", 2, &tempint))
705 nasm_error(ERR_PANIC, "strange segment conditions in ELF driver");
706 else {
707 s = sects[nsects - 1];
708 i = nsects - 1;
709 }
710 }
711
712 /* again some stabs debugging stuff */
713 if (of_elf64.current_dfmt) {
714 sinfo.offset = s->len;
715 sinfo.section = i;
716 sinfo.segto = segto;
717 sinfo.name = s->name;
718 of_elf64.current_dfmt->debug_output(TY_DEBUGSYMLIN, &sinfo);
719 }
720 /* end of debugging stuff */
721
722 if (s->type == SHT_NOBITS && type != OUT_RESERVE) {
723 nasm_error(ERR_WARNING, "attempt to initialize memory in"
724 " BSS section `%s': ignored", s->name);
725 s->len += realsize(type, size);
726 return;
727 }
728
729 switch (type) {
730 case OUT_RESERVE:
731 if (s->type == SHT_PROGBITS) {
732 nasm_error(ERR_WARNING, "uninitialized space declared in"
733 " non-BSS section `%s': zeroing", s->name);
734 elf_sect_write(s, NULL, size);
735 } else
736 s->len += size;
737 break;
738
739 case OUT_RAWDATA:
740 if (segment != NO_SEG)
741 nasm_error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
742 elf_sect_write(s, data, size);
743 break;
744
745 case OUT_ADDRESS:
746 {
747 int isize = (int)size;
748 int asize = abs((int)size);
749
750 addr = *(int64_t *)data;
751 if (segment == NO_SEG) {
752 /* Do nothing */
753 } else if (segment % 2) {
754 nasm_error(ERR_NONFATAL, "ELF format does not support"
755 " segment base references");
756 } else {
757 if (wrt == NO_SEG) {
758 switch (isize) {
759 case 1:
760 case -1:
761 elf_add_reloc(s, segment, addr, R_X86_64_8);
762 break;
763 case 2:
764 case -2:
765 elf_add_reloc(s, segment, addr, R_X86_64_16);
766 break;
767 case 4:
768 elf_add_reloc(s, segment, addr, R_X86_64_32);
769 break;
770 case -4:
771 elf_add_reloc(s, segment, addr, R_X86_64_32S);
772 break;
773 case 8:
774 case -8:
775 elf_add_reloc(s, segment, addr, R_X86_64_64);
776 break;
777 default:
778 nasm_error(ERR_PANIC, "internal error elf64-hpa-871");
779 break;
780 }
781 addr = 0;
782 } else if (wrt == elf_gotpc_sect + 1) {
783 /*
784 * The user will supply GOT relative to $$. ELF
785 * will let us have GOT relative to $. So we
786 * need to fix up the data item by $-$$.
787 */
788 addr += s->len;
789 elf_add_reloc(s, segment, addr, R_X86_64_GOTPC32);
790 addr = 0;
791 } else if (wrt == elf_gotoff_sect + 1) {
792 if (asize != 8) {
793 nasm_error(ERR_NONFATAL, "ELF64 requires ..gotoff "
794 "references to be qword");
795 } else {
796 elf_add_reloc(s, segment, addr, R_X86_64_GOTOFF64);
797 addr = 0;
798 }
799 } else if (wrt == elf_got_sect + 1) {
800 switch (asize) {
801 case 4:
802 elf_add_gsym_reloc(s, segment, addr, 0,
803 R_X86_64_GOT32, true);
804 addr = 0;
805 break;
806 case 8:
807 elf_add_gsym_reloc(s, segment, addr, 0,
808 R_X86_64_GOT64, true);
809 addr = 0;
810 break;
811 default:
812 nasm_error(ERR_NONFATAL, "invalid ..got reference");
813 break;
814 }
815 } else if (wrt == elf_sym_sect + 1) {
816 switch (isize) {
817 case 1:
818 case -1:
819 elf_add_gsym_reloc(s, segment, addr, 0,
820 R_X86_64_8, false);
821 addr = 0;
822 break;
823 case 2:
824 case -2:
825 elf_add_gsym_reloc(s, segment, addr, 0,
826 R_X86_64_16, false);
827 addr = 0;
828 break;
829 case 4:
830 elf_add_gsym_reloc(s, segment, addr, 0,
831 R_X86_64_32, false);
832 addr = 0;
833 break;
834 case -4:
835 elf_add_gsym_reloc(s, segment, addr, 0,
836 R_X86_64_32S, false);
837 addr = 0;
838 break;
839 case 8:
840 case -8:
841 elf_add_gsym_reloc(s, segment, addr, 0,
842 R_X86_64_64, false);
843 addr = 0;
844 break;
845 default:
846 nasm_error(ERR_PANIC, "internal error elf64-hpa-903");
847 break;
848 }
849 } else if (wrt == elf_plt_sect + 1) {
850 nasm_error(ERR_NONFATAL, "ELF format cannot produce non-PC-"
851 "relative PLT references");
852 } else {
853 nasm_error(ERR_NONFATAL, "ELF format does not support this"
854 " use of WRT");
855 }
856 }
857 elf_sect_writeaddr(s, addr, asize);
858 break;
859 }
860
861 case OUT_REL1ADR:
862 reltype = R_X86_64_PC8;
863 bytes = 1;
864 goto rel12adr;
865
866 case OUT_REL2ADR:
867 reltype = R_X86_64_PC16;
868 bytes = 2;
869 goto rel12adr;
870
871 rel12adr:
872 addr = *(int64_t *)data - size;
873 if (segment == segto)
874 nasm_error(ERR_PANIC, "intra-segment OUT_REL1ADR");
875 if (segment == NO_SEG) {
876 /* Do nothing */
877 } else if (segment % 2) {
878 nasm_error(ERR_NONFATAL, "ELF format does not support"
879 " segment base references");
880 } else {
881 if (wrt == NO_SEG) {
882 elf_add_reloc(s, segment, addr, reltype);
883 addr = 0;
884 } else {
885 nasm_error(ERR_NONFATAL,
886 "Unsupported non-32-bit ELF relocation");
887 }
888 }
889 elf_sect_writeaddr(s, addr, bytes);
890 break;
891
892 case OUT_REL4ADR:
893 addr = *(int64_t *)data - size;
894 if (segment == segto)
895 nasm_error(ERR_PANIC, "intra-segment OUT_REL4ADR");
896 if (segment == NO_SEG) {
897 /* Do nothing */
898 } else if (segment % 2) {
899 nasm_error(ERR_NONFATAL, "ELF64 format does not support"
900 " segment base references");
901 } else {
902 if (wrt == NO_SEG) {
903 elf_add_reloc(s, segment, addr, R_X86_64_PC32);
904 addr = 0;
905 } else if (wrt == elf_plt_sect + 1) {
906 elf_add_gsym_reloc(s, segment, addr+size, size,
907 R_X86_64_PLT32, true);
908 addr = 0;
909 } else if (wrt == elf_gotpc_sect + 1 ||
910 wrt == elf_got_sect + 1) {
911 elf_add_gsym_reloc(s, segment, addr+size, size,
912 R_X86_64_GOTPCREL, true);
913 addr = 0;
914 } else if (wrt == elf_gotoff_sect + 1 ||
915 wrt == elf_got_sect + 1) {
916 nasm_error(ERR_NONFATAL, "ELF64 requires ..gotoff references to be "
917 "qword absolute");
918 } else if (wrt == elf_gottpoff_sect + 1) {
919 elf_add_gsym_reloc(s, segment, addr+size, size,
920 R_X86_64_GOTTPOFF, true);
921 addr = 0;
922 } else {
923 nasm_error(ERR_NONFATAL, "ELF64 format does not support this"
924 " use of WRT");
925 }
926 }
927 elf_sect_writeaddr(s, addr, 4);
928 break;
929
930 case OUT_REL8ADR:
931 addr = *(int64_t *)data - size;
932 if (segment == segto)
933 nasm_error(ERR_PANIC, "intra-segment OUT_REL8ADR");
934 if (segment == NO_SEG) {
935 /* Do nothing */
936 } else if (segment % 2) {
937 nasm_error(ERR_NONFATAL, "ELF64 format does not support"
938 " segment base references");
939 } else {
940 if (wrt == NO_SEG) {
941 elf_add_reloc(s, segment, addr, R_X86_64_PC64);
942 addr = 0;
943 } else if (wrt == elf_gotpc_sect + 1 ||
944 wrt == elf_got_sect + 1) {
945 elf_add_gsym_reloc(s, segment, addr+size, size,
946 R_X86_64_GOTPCREL64, true);
947 addr = 0;
948 } else if (wrt == elf_gotoff_sect + 1 ||
949 wrt == elf_got_sect + 1) {
950 nasm_error(ERR_NONFATAL, "ELF64 requires ..gotoff references to be "
951 "absolute");
952 } else if (wrt == elf_gottpoff_sect + 1) {
953 nasm_error(ERR_NONFATAL, "ELF64 requires ..gottpoff references to be "
954 "dword");
955 } else {
956 nasm_error(ERR_NONFATAL, "ELF64 format does not support this"
957 " use of WRT");
958 }
959 }
960 elf_sect_writeaddr(s, addr, 8);
961 break;
962 }
963 }
964
965 static void elf_write(void)
966 {
967 int align;
968 char *p;
969 int i;
970
971 struct SAA *symtab;
972 int32_t symtablen, symtablocal;
973
974 /*
975 * Work out how many sections we will have. We have SHN_UNDEF,
976 * then the flexible user sections, then the fixed sections
977 * `.shstrtab', `.symtab' and `.strtab', then optionally
978 * relocation sections for the user sections.
979 */
980 nsections = sec_numspecial + 1;
981 if (of_elf64.current_dfmt == &df_stabs)
982 nsections += 3;
983 else if (of_elf64.current_dfmt == &df_dwarf)
984 nsections += 10;
985
986 add_sectname("", ".shstrtab");
987 add_sectname("", ".symtab");
988 add_sectname("", ".strtab");
989 for (i = 0; i < nsects; i++) {
990 nsections++; /* for the section itself */
991 if (sects[i]->head) {
992 nsections++; /* for its relocations */
993 add_sectname(".rela", sects[i]->name);
994 }
995 }
996
997 if (of_elf64.current_dfmt == &df_stabs) {
998 /* in case the debug information is wanted, just add these three sections... */
999 add_sectname("", ".stab");
1000 add_sectname("", ".stabstr");
1001 add_sectname(".rel", ".stab");
1002 }
1003
1004 else if (of_elf64.current_dfmt == &df_dwarf) {
1005 /* the dwarf debug standard specifies the following ten sections,
1006 not all of which are currently implemented,
1007 although all of them are defined. */
1008 #define debug_aranges (int64_t) (nsections-10)
1009 #define debug_info (int64_t) (nsections-7)
1010 #define debug_abbrev (int64_t) (nsections-5)
1011 #define debug_line (int64_t) (nsections-4)
1012 add_sectname("", ".debug_aranges");
1013 add_sectname(".rela", ".debug_aranges");
1014 add_sectname("", ".debug_pubnames");
1015 add_sectname("", ".debug_info");
1016 add_sectname(".rela", ".debug_info");
1017 add_sectname("", ".debug_abbrev");
1018 add_sectname("", ".debug_line");
1019 add_sectname(".rela", ".debug_line");
1020 add_sectname("", ".debug_frame");
1021 add_sectname("", ".debug_loc");
1022 }
1023
1024 /*
1025 * Output the ELF header.
1026 */
1027 nasm_write("\177ELF\2\1\1", 7, ofile);
1028 fputc(elf_osabi, ofile);
1029 fputc(elf_abiver, ofile);
1030 fwritezero(7, ofile);
1031 fwriteint16_t(ET_REL, ofile); /* relocatable file */
1032 fwriteint16_t(EM_X86_64, ofile); /* processor ID */
1033 fwriteint32_t(1L, ofile); /* EV_CURRENT file format version */
1034 fwriteint64_t(0L, ofile); /* no entry point */
1035 fwriteint64_t(0L, ofile); /* no program header table */
1036 fwriteint64_t(0x40L, ofile); /* section headers straight after
1037 * ELF header plus alignment */
1038 fwriteint32_t(0L, ofile); /* 386 defines no special flags */
1039 fwriteint16_t(0x40, ofile); /* size of ELF header */
1040 fwriteint16_t(0, ofile); /* no program header table, again */
1041 fwriteint16_t(0, ofile); /* still no program header table */
1042 fwriteint16_t(sizeof(Elf64_Shdr), ofile); /* size of section header */
1043 fwriteint16_t(nsections, ofile); /* number of sections */
1044 fwriteint16_t(sec_shstrtab, ofile); /* string table section index for
1045 * section header table */
1046
1047 /*
1048 * Build the symbol table and relocation tables.
1049 */
1050 symtab = elf_build_symtab(&symtablen, &symtablocal);
1051 for (i = 0; i < nsects; i++)
1052 if (sects[i]->head)
1053 sects[i]->rel = elf_build_reltab(&sects[i]->rellen,
1054 sects[i]->head);
1055
1056 /*
1057 * Now output the section header table.
1058 */
1059
1060 elf_foffs = 0x40 + sizeof(Elf64_Shdr) * nsections;
1061 align = ALIGN(elf_foffs, SEC_FILEALIGN) - elf_foffs;
1062 elf_foffs += align;
1063 elf_nsect = 0;
1064 elf_sects = nasm_malloc(sizeof(*elf_sects) * nsections);
1065
1066 /* SHN_UNDEF */
1067 elf_section_header(0, SHT_NULL, 0, NULL, false, 0, SHN_UNDEF, 0, 0, 0);
1068 p = shstrtab + 1;
1069
1070 /* The normal sections */
1071 for (i = 0; i < nsects; i++) {
1072 elf_section_header(p - shstrtab, sects[i]->type, sects[i]->flags,
1073 (sects[i]->type == SHT_PROGBITS ?
1074 sects[i]->data : NULL), true,
1075 sects[i]->len, 0, 0, sects[i]->align, 0);
1076 p += strlen(p) + 1;
1077 }
1078
1079 /* .shstrtab */
1080 elf_section_header(p - shstrtab, SHT_STRTAB, 0, shstrtab, false,
1081 shstrtablen, 0, 0, 1, 0);
1082 p += strlen(p) + 1;
1083
1084 /* .symtab */
1085 elf_section_header(p - shstrtab, SHT_SYMTAB, 0, symtab, true,
1086 symtablen, sec_strtab, symtablocal, 8, 24);
1087 p += strlen(p) + 1;
1088
1089 /* .strtab */
1090 elf_section_header(p - shstrtab, SHT_STRTAB, 0, strs, true,
1091 strslen, 0, 0, 1, 0);
1092 p += strlen(p) + 1;
1093
1094 /* The relocation sections */
1095 for (i = 0; i < nsects; i++)
1096 if (sects[i]->head) {
1097 elf_section_header(p - shstrtab, SHT_RELA, 0, sects[i]->rel, true,
1098 sects[i]->rellen, sec_symtab, i + 1, 8, 24);
1099 p += strlen(p) + 1;
1100 }
1101
1102 if (of_elf64.current_dfmt == &df_stabs) {
1103 /* for debugging information, create the last three sections
1104 which are the .stab , .stabstr and .rel.stab sections respectively */
1105
1106 /* this function call creates the stab sections in memory */
1107 stabs64_generate();
1108
1109 if (stabbuf && stabstrbuf && stabrelbuf) {
1110 elf_section_header(p - shstrtab, SHT_PROGBITS, 0, stabbuf, false,
1111 stablen, sec_stabstr, 0, 4, 12);
1112 p += strlen(p) + 1;
1113
1114 elf_section_header(p - shstrtab, SHT_STRTAB, 0, stabstrbuf, false,
1115 stabstrlen, 0, 0, 4, 0);
1116 p += strlen(p) + 1;
1117
1118 /* link -> symtable info -> section to refer to */
1119 elf_section_header(p - shstrtab, SHT_REL, 0, stabrelbuf, false,
1120 stabrellen, symtabsection, sec_stab, 4, 16);
1121 p += strlen(p) + 1;
1122 }
1123 } else if (of_elf64.current_dfmt == &df_dwarf) {
1124 /* for dwarf debugging information, create the ten dwarf sections */
1125
1126 /* this function call creates the dwarf sections in memory */
1127 if (dwarf_fsect)
1128 dwarf64_generate();
1129
1130 elf_section_header(p - shstrtab, SHT_PROGBITS, 0, arangesbuf, false,
1131 arangeslen, 0, 0, 1, 0);
1132 p += strlen(p) + 1;
1133
1134 elf_section_header(p - shstrtab, SHT_RELA, 0, arangesrelbuf, false,
1135 arangesrellen, symtabsection, debug_aranges, 1, 24);
1136 p += strlen(p) + 1;
1137
1138 elf_section_header(p - shstrtab, SHT_PROGBITS, 0, pubnamesbuf, false,
1139 pubnameslen, 0, 0, 1, 0);
1140 p += strlen(p) + 1;
1141
1142 elf_section_header(p - shstrtab, SHT_PROGBITS, 0, infobuf, false,
1143 infolen, 0, 0, 1, 0);
1144 p += strlen(p) + 1;
1145
1146 elf_section_header(p - shstrtab, SHT_RELA, 0, inforelbuf, false,
1147 inforellen, symtabsection, debug_info, 1, 24);
1148 p += strlen(p) + 1;
1149
1150 elf_section_header(p - shstrtab, SHT_PROGBITS, 0, abbrevbuf, false,
1151 abbrevlen, 0, 0, 1, 0);
1152 p += strlen(p) + 1;
1153
1154 elf_section_header(p - shstrtab, SHT_PROGBITS, 0, linebuf, false,
1155 linelen, 0, 0, 1, 0);
1156 p += strlen(p) + 1;
1157
1158 elf_section_header(p - shstrtab, SHT_RELA, 0, linerelbuf, false,
1159 linerellen, symtabsection, debug_line, 1, 24);
1160 p += strlen(p) + 1;
1161
1162 elf_section_header(p - shstrtab, SHT_PROGBITS, 0, framebuf, false,
1163 framelen, 0, 0, 8, 0);
1164 p += strlen(p) + 1;
1165
1166 elf_section_header(p - shstrtab, SHT_PROGBITS, 0, locbuf, false,
1167 loclen, 0, 0, 1, 0);
1168 p += strlen(p) + 1;
1169 }
1170 fwritezero(align, ofile);
1171
1172 /*
1173 * Now output the sections.
1174 */
1175 elf_write_sections();
1176
1177 nasm_free(elf_sects);
1178 saa_free(symtab);
1179 }
1180
1181 static struct SAA *elf_build_symtab(int32_t *len, int32_t *local)
1182 {
1183 struct SAA *s = saa_init(1L);
1184 struct elf_symbol *sym;
1185 uint8_t entry[24], *p;
1186 int i;
1187
1188 *len = *local = 0;
1189
1190 /*
1191 * First, an all-zeros entry, required by the ELF spec.
1192 */
1193 saa_wbytes(s, NULL, 24L); /* null symbol table entry */
1194 *len += 24;
1195 (*local)++;
1196
1197 /*
1198 * Next, an entry for the file name.
1199 */
1200 p = entry;
1201 WRITELONG(p, 1); /* we know it's 1st entry in strtab */
1202 WRITESHORT(p, STT_FILE); /* type FILE */
1203 WRITESHORT(p, SHN_ABS);
1204 WRITEDLONG(p, (uint64_t) 0); /* no value */
1205 WRITEDLONG(p, (uint64_t) 0); /* no size either */
1206 saa_wbytes(s, entry, 24L);
1207 *len += 24;
1208 (*local)++;
1209
1210 /*
1211 * Now some standard symbols defining the segments, for relocation
1212 * purposes.
1213 */
1214 for (i = 1; i <= nsects; i++) {
1215 p = entry;
1216 WRITELONG(p, 0); /* no symbol name */
1217 WRITESHORT(p, STT_SECTION); /* type, binding, and visibility */
1218 WRITESHORT(p, i); /* section id */
1219 WRITEDLONG(p, (uint64_t) 0); /* offset zero */
1220 WRITEDLONG(p, (uint64_t) 0); /* size zero */
1221 saa_wbytes(s, entry, 24L);
1222 *len += 24;
1223 (*local)++;
1224 }
1225
1226
1227 /*
1228 * Now the other local symbols.
1229 */
1230 saa_rewind(syms);
1231 while ((sym = saa_rstruct(syms))) {
1232 if (sym->type & SYM_GLOBAL)
1233 continue;
1234 p = entry;
1235 WRITELONG(p, sym->strpos); /* index into symbol string table */
1236 WRITECHAR(p, sym->type); /* type and binding */
1237 WRITECHAR(p, sym->other); /* visibility */
1238 WRITESHORT(p, sym->section); /* index into section header table */
1239 WRITEDLONG(p, (int64_t)sym->symv.key); /* value of symbol */
1240 WRITEDLONG(p, (int64_t)sym->size); /* size of symbol */
1241 saa_wbytes(s, entry, 24L);
1242 *len += 24;
1243 (*local)++;
1244 }
1245 /*
1246 * dwarf needs symbols for debug sections
1247 * which are relocation targets.
1248 */
1249 if (of_elf64.current_dfmt == &df_dwarf) {
1250 dwarf_infosym = *local;
1251 p = entry;
1252 WRITELONG(p, 0); /* no symbol name */
1253 WRITESHORT(p, STT_SECTION); /* type, binding, and visibility */
1254 WRITESHORT(p, debug_info); /* section id */
1255 WRITEDLONG(p, (uint64_t) 0); /* offset zero */
1256 WRITEDLONG(p, (uint64_t) 0); /* size zero */
1257 saa_wbytes(s, entry, 24L);
1258 *len += 24;
1259 (*local)++;
1260 dwarf_abbrevsym = *local;
1261 p = entry;
1262 WRITELONG(p, 0); /* no symbol name */
1263 WRITESHORT(p, STT_SECTION); /* type, binding, and visibility */
1264 WRITESHORT(p, debug_abbrev); /* section id */
1265 WRITEDLONG(p, (uint64_t) 0); /* offset zero */
1266 WRITEDLONG(p, (uint64_t) 0); /* size zero */
1267 saa_wbytes(s, entry, 24L);
1268 *len += 24;
1269 (*local)++;
1270 dwarf_linesym = *local;
1271 p = entry;
1272 WRITELONG(p, 0); /* no symbol name */
1273 WRITESHORT(p, STT_SECTION); /* type, binding, and visibility */
1274 WRITESHORT(p, debug_line); /* section id */
1275 WRITEDLONG(p, (uint64_t) 0); /* offset zero */
1276 WRITEDLONG(p, (uint64_t) 0); /* size zero */
1277 saa_wbytes(s, entry, 24L);
1278 *len += 24;
1279 (*local)++;
1280 }
1281
1282 /*
1283 * Now the global symbols.
1284 */
1285 saa_rewind(syms);
1286 while ((sym = saa_rstruct(syms))) {
1287 if (!(sym->type & SYM_GLOBAL))
1288 continue;
1289 p = entry;
1290 WRITELONG(p, sym->strpos);
1291 WRITECHAR(p, sym->type); /* type and binding */
1292 WRITECHAR(p, sym->other); /* visibility */
1293 WRITESHORT(p, sym->section);
1294 WRITEDLONG(p, (int64_t)sym->symv.key);
1295 WRITEDLONG(p, (int64_t)sym->size);
1296 saa_wbytes(s, entry, 24L);
1297 *len += 24;
1298 }
1299
1300 return s;
1301 }
1302
1303 static struct SAA *elf_build_reltab(uint64_t *len, struct elf_reloc *r)
1304 {
1305 struct SAA *s;
1306 uint8_t *p, entry[24];
1307 int32_t global_offset;
1308
1309 if (!r)
1310 return NULL;
1311
1312 s = saa_init(1L);
1313 *len = 0;
1314
1315 /*
1316 * How to onvert from a global placeholder to a real symbol index;
1317 * the +2 refers to the two special entries, the null entry and
1318 * the filename entry.
1319 */
1320 global_offset = -GLOBAL_TEMP_BASE + nsects + nlocals + ndebugs + 2;
1321
1322 while (r) {
1323 int32_t sym = r->symbol;
1324
1325 if (sym >= GLOBAL_TEMP_BASE)
1326 sym += global_offset;
1327
1328 p = entry;
1329 WRITEDLONG(p, r->address);
1330 WRITELONG(p, r->type);
1331 WRITELONG(p, sym);
1332 WRITEDLONG(p, r->offset);
1333 saa_wbytes(s, entry, 24L);
1334 *len += 24;
1335
1336 r = r->next;
1337 }
1338
1339 return s;
1340 }
1341
1342 static void elf_section_header(int name, int type, uint64_t flags,
1343 void *data, bool is_saa, uint64_t datalen,
1344 int link, int info, int align, int eltsize)
1345 {
1346 elf_sects[elf_nsect].data = data;
1347 elf_sects[elf_nsect].len = datalen;
1348 elf_sects[elf_nsect].is_saa = is_saa;
1349 elf_nsect++;
1350
1351 fwriteint32_t((int32_t)name, ofile);
1352 fwriteint32_t((int32_t)type, ofile);
1353 fwriteint64_t((int64_t)flags, ofile);
1354 fwriteint64_t(0L, ofile); /* no address, ever, in object files */
1355 fwriteint64_t(type == 0 ? 0L : elf_foffs, ofile);
1356 fwriteint64_t(datalen, ofile);
1357 if (data)
1358 elf_foffs += ALIGN(datalen, SEC_FILEALIGN);
1359 fwriteint32_t((int32_t)link, ofile);
1360 fwriteint32_t((int32_t)info, ofile);
1361 fwriteint64_t((int64_t)align, ofile);
1362 fwriteint64_t((int64_t)eltsize, ofile);
1363 }
1364
1365 static void elf_write_sections(void)
1366 {
1367 int i;
1368 for (i = 0; i < elf_nsect; i++)
1369 if (elf_sects[i].data) {
1370 int32_t len = elf_sects[i].len;
1371 int32_t reallen = ALIGN(len, SEC_FILEALIGN);
1372 int32_t align = reallen - len;
1373 if (elf_sects[i].is_saa)
1374 saa_fpwrite(elf_sects[i].data, ofile);
1375 else
1376 nasm_write(elf_sects[i].data, len, ofile);
1377 fwritezero(align, ofile);
1378 }
1379 }
1380
1381 static void elf_sect_write(struct elf_section *sect, const void *data, size_t len)
1382 {
1383 saa_wbytes(sect->data, data, len);
1384 sect->len += len;
1385 }
1386
1387 static void elf_sect_writeaddr(struct elf_section *sect, int64_t data, size_t len)
1388 {
1389 saa_writeaddr(sect->data, data, len);
1390 sect->len += len;
1391 }
1392
1393 static void elf_sectalign(int32_t seg, unsigned int value)
1394 {
1395 struct elf_section *s = NULL;
1396 int i;
1397
1398 for (i = 0; i < nsects; i++) {
1399 if (sects[i]->index == seg) {
1400 s = sects[i];
1401 break;
1402 }
1403 }
1404 if (!s || !is_power2(value))
1405 return;
1406
1407 if (value > s->align)
1408 s->align = value;
1409 }
1410
1411 static int32_t elf_segbase(int32_t segment)
1412 {
1413 return segment;
1414 }
1415
1416 static void elf_filename(char *inname, char *outname)
1417 {
1418 strcpy(elf_module, inname);
1419 standard_extension(inname, outname, ".o");
1420 }
1421
1422 extern macros_t elf_stdmac[];
1423
1424 static int elf_set_info(enum geninfo type, char **val)
1425 {
1426 (void)type;
1427 (void)val;
1428 return 0;
1429 }
1430 static struct dfmt df_dwarf = {
1431 "ELF64 (x86-64) dwarf debug format for Linux/Unix",
1432 "dwarf",
1433 dwarf64_init,
1434 dwarf64_linenum,
1435 debug64_deflabel,
1436 debug64_directive,
1437 debug64_typevalue,
1438 dwarf64_output,
1439 dwarf64_cleanup
1440 };
1441 static struct dfmt df_stabs = {
1442 "ELF64 (x86-64) stabs debug format for Linux/Unix",
1443 "stabs",
1444 null_debug_init,
1445 stabs64_linenum,
1446 debug64_deflabel,
1447 debug64_directive,
1448 debug64_typevalue,
1449 stabs64_output,
1450 stabs64_cleanup
1451 };
1452
1453 struct dfmt *elf64_debugs_arr[3] = { &df_dwarf, &df_stabs, NULL };
1454
1455 struct ofmt of_elf64 = {
1456 "ELF64 (x86_64) object files (e.g. Linux)",
1457 "elf64",
1458 0,
1459 64,
1460 elf64_debugs_arr,
1461 &df_stabs,
1462 elf_stdmac,
1463 elf_init,
1464 elf_set_info,
1465 elf_out,
1466 elf_deflabel,
1467 elf_section_names,
1468 elf_sectalign,
1469 elf_segbase,
1470 elf_directive,
1471 elf_filename,
1472 elf_cleanup
1473 };
1474
1475 /* common debugging routines */
1476 static void debug64_deflabel(char *name, int32_t segment, int64_t offset,
1477 int is_global, char *special)
1478 {
1479 (void)name;
1480 (void)segment;
1481 (void)offset;
1482 (void)is_global;
1483 (void)special;
1484 }
1485
1486 static void debug64_directive(const char *directive, const char *params)
1487 {
1488 (void)directive;
1489 (void)params;
1490 }
1491
1492 static void debug64_typevalue(int32_t type)
1493 {
1494 int32_t stype, ssize;
1495 switch (TYM_TYPE(type)) {
1496 case TY_LABEL:
1497 ssize = 0;
1498 stype = STT_NOTYPE;
1499 break;
1500 case TY_BYTE:
1501 ssize = 1;
1502 stype = STT_OBJECT;
1503 break;
1504 case TY_WORD:
1505 ssize = 2;
1506 stype = STT_OBJECT;
1507 break;
1508 case TY_DWORD:
1509 ssize = 4;
1510 stype = STT_OBJECT;
1511 break;
1512 case TY_FLOAT:
1513 ssize = 4;
1514 stype = STT_OBJECT;
1515 break;
1516 case TY_QWORD:
1517 ssize = 8;
1518 stype = STT_OBJECT;
1519 break;
1520 case TY_TBYTE:
1521 ssize = 10;
1522 stype = STT_OBJECT;
1523 break;
1524 case TY_OWORD:
1525 ssize = 16;
1526 stype = STT_OBJECT;
1527 break;
1528 case TY_YWORD:
1529 ssize = 32;
1530 stype = STT_OBJECT;
1531 break;
1532 case TY_COMMON:
1533 ssize = 0;
1534 stype = STT_COMMON;
1535 break;
1536 case TY_SEG:
1537 ssize = 0;
1538 stype = STT_SECTION;
1539 break;
1540 case TY_EXTERN:
1541 ssize = 0;
1542 stype = STT_NOTYPE;
1543 break;
1544 case TY_EQU:
1545 ssize = 0;
1546 stype = STT_NOTYPE;
1547 break;
1548 default:
1549 ssize = 0;
1550 stype = STT_NOTYPE;
1551 break;
1552 }
1553 if (stype == STT_OBJECT && lastsym && !lastsym->type) {
1554 lastsym->size = ssize;
1555 lastsym->type = stype;
1556 }
1557 }
1558
1559 /* stabs debugging routines */
1560
1561 static void stabs64_linenum(const char *filename, int32_t linenumber, int32_t segto)
1562 {
1563 (void)segto;
1564 if (!stabs_filename) {
1565 stabs_filename = (char *)nasm_malloc(strlen(filename) + 1);
1566 strcpy(stabs_filename, filename);
1567 } else {
1568 if (strcmp(stabs_filename, filename)) {
1569 /* yep, a memory leak...this program is one-shot anyway, so who cares...
1570 in fact, this leak comes in quite handy to maintain a list of files
1571 encountered so far in the symbol lines... */
1572
1573 /* why not nasm_free(stabs_filename); we're done with the old one */
1574
1575 stabs_filename = (char *)nasm_malloc(strlen(filename) + 1);
1576 strcpy(stabs_filename, filename);
1577 }
1578 }
1579 debug_immcall = 1;
1580 currentline = linenumber;
1581 }
1582
1583
1584 static void stabs64_output(int type, void *param)
1585 {
1586 struct symlininfo *s;
1587 struct linelist *el;
1588 if (type == TY_DEBUGSYMLIN) {
1589 if (debug_immcall) {
1590 s = (struct symlininfo *)param;
1591 if (!(sects[s->section]->flags & SHF_EXECINSTR))
1592 return; /* line info is only collected for executable sections */
1593 numlinestabs++;
1594 el = (struct linelist *)nasm_malloc(sizeof(struct linelist));
1595 el->info.offset = s->offset;
1596 el->info.section = s->section;
1597 el->info.name = s->name;
1598 el->line = currentline;
1599 el->filename = stabs_filename;
1600 el->next = 0;
1601 if (stabslines) {
1602 stabslines->last->next = el;
1603 stabslines->last = el;
1604 } else {
1605 stabslines = el;
1606 stabslines->last = el;
1607 }
1608 }
1609 }
1610 debug_immcall = 0;
1611 }
1612
1613 /* for creating the .stab , .stabstr and .rel.stab sections in memory */
1614
1615 static void stabs64_generate(void)
1616 {
1617 int i, numfiles, strsize, numstabs = 0, currfile, mainfileindex;
1618 uint8_t *sbuf, *ssbuf, *rbuf, *sptr, *rptr;
1619 char **allfiles;
1620 int *fileidx;
1621
1622 struct linelist *ptr;
1623
1624 ptr = stabslines;
1625
1626 allfiles = (char **)nasm_zalloc(numlinestabs * sizeof(char *));
1627 numfiles = 0;
1628 while (ptr) {
1629 if (numfiles == 0) {
1630 allfiles[0] = ptr->filename;
1631 numfiles++;
1632 } else {
1633 for (i = 0; i < numfiles; i++) {
1634 if (!strcmp(allfiles[i], ptr->filename))
1635 break;
1636 }
1637 if (i >= numfiles) {
1638 allfiles[i] = ptr->filename;
1639 numfiles++;
1640 }
1641 }
1642 ptr = ptr->next;
1643 }
1644 strsize = 1;
1645 fileidx = (int *)nasm_malloc(numfiles * sizeof(int));
1646 for (i = 0; i < numfiles; i++) {
1647 fileidx[i] = strsize;
1648 strsize += strlen(allfiles[i]) + 1;
1649 }
1650 mainfileindex = 0;
1651 for (i = 0; i < numfiles; i++) {
1652 if (!strcmp(allfiles[i], elf_module)) {
1653 mainfileindex = i;
1654 break;
1655 }
1656 }
1657
1658 /*
1659 * worst case size of the stab buffer would be:
1660 * the sourcefiles changes each line, which would mean 1 SOL, 1 SYMLIN per line
1661 * plus one "ending" entry
1662 */
1663 sbuf = (uint8_t *)nasm_malloc((numlinestabs * 2 + 4) *
1664 sizeof(struct stabentry));
1665 ssbuf = (uint8_t *)nasm_malloc(strsize);
1666 rbuf = (uint8_t *)nasm_malloc(numlinestabs * 16 * (2 + 3));
1667 rptr = rbuf;
1668
1669 for (i = 0; i < numfiles; i++)
1670 strcpy((char *)ssbuf + fileidx[i], allfiles[i]);
1671 ssbuf[0] = 0;
1672
1673 stabstrlen = strsize; /* set global variable for length of stab strings */
1674
1675 sptr = sbuf;
1676 ptr = stabslines;
1677 numstabs = 0;
1678
1679 if (ptr) {
1680 /*
1681 * this is the first stab, its strx points to the filename of the
1682 * the source-file, the n_desc field should be set to the number
1683 * of remaining stabs
1684 */
1685 WRITE_STAB(sptr, fileidx[0], 0, 0, 0, stabstrlen);
1686
1687 /* this is the stab for the main source file */
1688 WRITE_STAB(sptr, fileidx[mainfileindex], N_SO, 0, 0, 0);
1689
1690 /* relocation table entry */
1691
1692 /*
1693 * Since the symbol table has two entries before
1694 * the section symbols, the index in the info.section
1695 * member must be adjusted by adding 2
1696 */
1697
1698 WRITEDLONG(rptr, (int64_t)(sptr - sbuf) - 4);
1699 WRITELONG(rptr, R_X86_64_32);
1700 WRITELONG(rptr, ptr->info.section + 2);
1701
1702 numstabs++;
1703 currfile = mainfileindex;
1704 }
1705
1706 while (ptr) {
1707 if (strcmp(allfiles[currfile], ptr->filename)) {
1708 /* oops file has changed... */
1709 for (i = 0; i < numfiles; i++)
1710 if (!strcmp(allfiles[i], ptr->filename))
1711 break;
1712 currfile = i;
1713 WRITE_STAB(sptr, fileidx[currfile], N_SOL, 0, 0,
1714 ptr->info.offset);
1715 numstabs++;
1716
1717 /* relocation table entry */
1718
1719 WRITEDLONG(rptr, (int64_t)(sptr - sbuf) - 4);
1720 WRITELONG(rptr, R_X86_64_32);
1721 WRITELONG(rptr, ptr->info.section + 2);
1722 }
1723
1724 WRITE_STAB(sptr, 0, N_SLINE, 0, ptr->line, ptr->info.offset);
1725 numstabs++;
1726
1727 /* relocation table entry */
1728
1729 WRITEDLONG(rptr, (int64_t)(sptr - sbuf) - 4);
1730 WRITELONG(rptr, R_X86_64_32);
1731 WRITELONG(rptr, ptr->info.section + 2);
1732
1733 ptr = ptr->next;
1734
1735 }
1736
1737 /* this is an "ending" token */
1738 WRITE_STAB(sptr, 0, N_SO, 0, 0, 0);
1739 numstabs++;
1740
1741 ((struct stabentry *)sbuf)->n_desc = numstabs;
1742
1743 nasm_free(allfiles);
1744 nasm_free(fileidx);
1745
1746 stablen = (sptr - sbuf);
1747 stabrellen = (rptr - rbuf);
1748 stabrelbuf = rbuf;
1749 stabbuf = sbuf;
1750 stabstrbuf = ssbuf;
1751 }
1752
1753 static void stabs64_cleanup(void)
1754 {
1755 struct linelist *ptr, *del;
1756 if (!stabslines)
1757 return;
1758
1759 ptr = stabslines;
1760 while (ptr) {
1761 del = ptr;
1762 ptr = ptr->next;
1763 nasm_free(del);
1764 }
1765
1766 nasm_free(stabbuf);
1767 nasm_free(stabrelbuf);
1768 nasm_free(stabstrbuf);
1769 }
1770
1771 /* dwarf routines */
1772
1773 static void dwarf64_init(void)
1774 {
1775 ndebugs = 3; /* 3 debug symbols */
1776 }
1777
1778 static void dwarf64_linenum(const char *filename, int32_t linenumber,
1779 int32_t segto)
1780 {
1781 (void)segto;
1782 dwarf64_findfile(filename);
1783 debug_immcall = 1;
1784 currentline = linenumber;
1785 }
1786
1787 /* called from elf_out with type == TY_DEBUGSYMLIN */
1788 static void dwarf64_output(int type, void *param)
1789 {
1790 int ln, aa, inx, maxln, soc;
1791 struct symlininfo *s;
1792 struct SAA *plinep;
1793
1794 (void)type;
1795
1796 s = (struct symlininfo *)param;
1797
1798 /* line number info is only gathered for executable sections */
1799 if (!(sects[s->section]->flags & SHF_EXECINSTR))
1800 return;
1801
1802 /* Check if section index has changed */
1803 if (!(dwarf_csect && (dwarf_csect->section) == (s->section)))
1804 dwarf64_findsect(s->section);
1805
1806 /* do nothing unless line or file has changed */
1807 if (!debug_immcall)
1808 return;
1809
1810 ln = currentline - dwarf_csect->line;
1811 aa = s->offset - dwarf_csect->offset;
1812 inx = dwarf_clist->line;
1813 plinep = dwarf_csect->psaa;
1814 /* check for file change */
1815 if (!(inx == dwarf_csect->file)) {
1816 saa_write8(plinep,DW_LNS_set_file);
1817 saa_write8(plinep,inx);
1818 dwarf_csect->file = inx;
1819 }
1820 /* check for line change */
1821 if (ln) {
1822 /* test if in range of special op code */
1823 maxln = line_base + line_range;
1824 soc = (ln - line_base) + (line_range * aa) + opcode_base;
1825 if (ln >= line_base && ln < maxln && soc < 256) {
1826 saa_write8(plinep,soc);
1827 } else {
1828 saa_write8(plinep,DW_LNS_advance_line);
1829 saa_wleb128s(plinep,ln);
1830 if (aa) {
1831 saa_write8(plinep,DW_LNS_advance_pc);
1832 saa_wleb128u(plinep,aa);
1833 }
1834 }
1835 dwarf_csect->line = currentline;
1836 dwarf_csect->offset = s->offset;
1837 }
1838
1839 /* show change handled */
1840 debug_immcall = 0;
1841 }
1842
1843
1844 static void dwarf64_generate(void)
1845 {
1846 uint8_t *pbuf;
1847 int indx;
1848 struct linelist *ftentry;
1849 struct SAA *paranges, *ppubnames, *pinfo, *pabbrev, *plines, *plinep;
1850 struct SAA *parangesrel, *plinesrel, *pinforel;
1851 struct sectlist *psect;
1852 size_t saalen, linepoff, totlen, highaddr;
1853
1854 /* write epilogues for each line program range */
1855 /* and build aranges section */
1856 paranges = saa_init(1L);
1857 parangesrel = saa_init(1L);
1858 saa_write16(paranges,3); /* dwarf version */
1859 saa_write64(parangesrel, paranges->datalen+4);
1860 saa_write64(parangesrel, (dwarf_infosym << 32) + R_X86_64_32); /* reloc to info */
1861 saa_write64(parangesrel, 0);
1862 saa_write32(paranges,0); /* offset into info */
1863 saa_write8(paranges,8); /* pointer size */
1864 saa_write8(paranges,0); /* not segmented */
1865 saa_write32(paranges,0); /* padding */
1866 /* iterate though sectlist entries */
1867 psect = dwarf_fsect;
1868 totlen = 0;
1869 highaddr = 0;
1870 for (indx = 0; indx < dwarf_nsections; indx++)
1871 {
1872 plinep = psect->psaa;
1873 /* Line Number Program Epilogue */
1874 saa_write8(plinep,2); /* std op 2 */
1875 saa_write8(plinep,(sects[psect->section]->len)-psect->offset);
1876 saa_write8(plinep,DW_LNS_extended_op);
1877 saa_write8(plinep,1); /* operand length */
1878 saa_write8(plinep,DW_LNE_end_sequence);
1879 totlen += plinep->datalen;
1880 /* range table relocation entry */
1881 saa_write64(parangesrel, paranges->datalen + 4);
1882 saa_write64(parangesrel, ((uint64_t) (psect->section + 2) << 32) + R_X86_64_64);
1883 saa_write64(parangesrel, (uint64_t) 0);
1884 /* range table entry */
1885 saa_write64(paranges,0x0000); /* range start */
1886 saa_write64(paranges,sects[psect->section]->len); /* range length */
1887 highaddr += sects[psect->section]->len;
1888 /* done with this entry */
1889 psect = psect->next;
1890 }
1891 saa_write64(paranges,0); /* null address */
1892 saa_write64(paranges,0); /* null length */
1893 saalen = paranges->datalen;
1894 arangeslen = saalen + 4;
1895 arangesbuf = pbuf = nasm_malloc(arangeslen);
1896 WRITELONG(pbuf,saalen); /* initial length */
1897 saa_rnbytes(paranges, pbuf, saalen);
1898 saa_free(paranges);
1899
1900 /* build rela.aranges section */
1901 arangesrellen = saalen = parangesrel->datalen;
1902 arangesrelbuf = pbuf = nasm_malloc(arangesrellen);
1903 saa_rnbytes(parangesrel, pbuf, saalen);
1904 saa_free(parangesrel);
1905
1906 /* build pubnames section */
1907 ppubnames = saa_init(1L);
1908 saa_write16(ppubnames,3); /* dwarf version */
1909 saa_write32(ppubnames,0); /* offset into info */
1910 saa_write32(ppubnames,0); /* space used in info */
1911 saa_write32(ppubnames,0); /* end of list */
1912 saalen = ppubnames->datalen;
1913 pubnameslen = saalen + 4;
1914 pubnamesbuf = pbuf = nasm_malloc(pubnameslen);
1915 WRITELONG(pbuf,saalen); /* initial length */
1916 saa_rnbytes(ppubnames, pbuf, saalen);
1917 saa_free(ppubnames);
1918
1919 /* build info section */
1920 pinfo = saa_init(1L);
1921 pinforel = saa_init(1L);
1922 saa_write16(pinfo,3); /* dwarf version */
1923 saa_write64(pinforel, pinfo->datalen + 4);
1924 saa_write64(pinforel, (dwarf_abbrevsym << 32) + R_X86_64_32); /* reloc to abbrev */
1925 saa_write64(pinforel, 0);
1926 saa_write32(pinfo,0); /* offset into abbrev */
1927 saa_write8(pinfo,8); /* pointer size */
1928 saa_write8(pinfo,1); /* abbrviation number LEB128u */
1929 saa_write64(pinforel, pinfo->datalen + 4);
1930 saa_write64(pinforel, ((uint64_t)(dwarf_fsect->section + 2) << 32) + R_X86_64_64);
1931 saa_write64(pinforel, 0);
1932 saa_write64(pinfo,0); /* DW_AT_low_pc */
1933 saa_write64(pinforel, pinfo->datalen + 4);
1934 saa_write64(pinforel, ((uint64_t)(dwarf_fsect->section + 2) << 32) + R_X86_64_64);
1935 saa_write64(pinforel, 0);
1936 saa_write64(pinfo,highaddr); /* DW_AT_high_pc */
1937 saa_write64(pinforel, pinfo->datalen + 4);
1938 saa_write64(pinforel, (dwarf_linesym << 32) + R_X86_64_32); /* reloc to line */
1939 saa_write64(pinforel, 0);
1940 saa_write32(pinfo,0); /* DW_AT_stmt_list */
1941 saa_wbytes(pinfo, elf_module, strlen(elf_module)+1);
1942 saa_wbytes(pinfo, nasm_signature, strlen(nasm_signature)+1);
1943 saa_write16(pinfo,DW_LANG_Mips_Assembler);
1944 saa_write8(pinfo,2); /* abbrviation number LEB128u */
1945 saa_write64(pinforel, pinfo->datalen + 4);
1946 saa_write64(pinforel, ((uint64_t)(dwarf_fsect->section + 2) << 32) + R_X86_64_64);
1947 saa_write64(pinforel, 0);
1948 saa_write64(pinfo,0); /* DW_AT_low_pc */
1949 saa_write64(pinfo,0); /* DW_AT_frame_base */
1950 saa_write8(pinfo,0); /* end of entries */
1951 saalen = pinfo->datalen;
1952 infolen = saalen + 4;
1953 infobuf = pbuf = nasm_malloc(infolen);
1954 WRITELONG(pbuf,saalen); /* initial length */
1955 saa_rnbytes(pinfo, pbuf, saalen);
1956 saa_free(pinfo);
1957
1958 /* build rela.info section */
1959 inforellen = saalen = pinforel->datalen;
1960 inforelbuf = pbuf = nasm_malloc(inforellen);
1961 saa_rnbytes(pinforel, pbuf, saalen);
1962 saa_free(pinforel);
1963
1964 /* build abbrev section */
1965 pabbrev = saa_init(1L);
1966 saa_write8(pabbrev,1); /* entry number LEB128u */
1967 saa_write8(pabbrev,DW_TAG_compile_unit); /* tag LEB128u */
1968 saa_write8(pabbrev,1); /* has children */
1969 /* the following attributes and forms are all LEB128u values */
1970 saa_write8(pabbrev,DW_AT_low_pc);
1971 saa_write8(pabbrev,DW_FORM_addr);
1972 saa_write8(pabbrev,DW_AT_high_pc);
1973 saa_write8(pabbrev,DW_FORM_addr);
1974 saa_write8(pabbrev,DW_AT_stmt_list);
1975 saa_write8(pabbrev,DW_FORM_data4);
1976 saa_write8(pabbrev,DW_AT_name);
1977 saa_write8(pabbrev,DW_FORM_string);
1978 saa_write8(pabbrev,DW_AT_producer);
1979 saa_write8(pabbrev,DW_FORM_string);
1980 saa_write8(pabbrev,DW_AT_language);
1981 saa_write8(pabbrev,DW_FORM_data2);
1982 saa_write16(pabbrev,0); /* end of entry */
1983 /* LEB128u usage same as above */
1984 saa_write8(pabbrev,2); /* entry number */
1985 saa_write8(pabbrev,DW_TAG_subprogram);
1986 saa_write8(pabbrev,0); /* no children */
1987 saa_write8(pabbrev,DW_AT_low_pc);
1988 saa_write8(pabbrev,DW_FORM_addr);
1989 saa_write8(pabbrev,DW_AT_frame_base);
1990 saa_write8(pabbrev,DW_FORM_data4);
1991 saa_write16(pabbrev,0); /* end of entry */
1992 abbrevlen = saalen = pabbrev->datalen;
1993 abbrevbuf = pbuf = nasm_malloc(saalen);
1994 saa_rnbytes(pabbrev, pbuf, saalen);
1995 saa_free(pabbrev);
1996
1997 /* build line section */
1998 /* prolog */
1999 plines = saa_init(1L);
2000 saa_write8(plines,1); /* Minimum Instruction Length */
2001 saa_write8(plines,1); /* Initial value of 'is_stmt' */
2002 saa_write8(plines,line_base); /* Line Base */
2003 saa_write8(plines,line_range); /* Line Range */
2004 saa_write8(plines,opcode_base); /* Opcode Base */
2005 /* standard opcode lengths (# of LEB128u operands) */
2006 saa_write8(plines,0); /* Std opcode 1 length */
2007 saa_write8(plines,1); /* Std opcode 2 length */
2008 saa_write8(plines,1); /* Std opcode 3 length */
2009 saa_write8(plines,1); /* Std opcode 4 length */
2010 saa_write8(plines,1); /* Std opcode 5 length */
2011 saa_write8(plines,0); /* Std opcode 6 length */
2012 saa_write8(plines,0); /* Std opcode 7 length */
2013 saa_write8(plines,0); /* Std opcode 8 length */
2014 saa_write8(plines,1); /* Std opcode 9 length */
2015 saa_write8(plines,0); /* Std opcode 10 length */
2016 saa_write8(plines,0); /* Std opcode 11 length */
2017 saa_write8(plines,1); /* Std opcode 12 length */
2018 /* Directory Table */
2019 saa_write8(plines,0); /* End of table */
2020 /* File Name Table */
2021 ftentry = dwarf_flist;
2022 for (indx = 0;indx<dwarf_numfiles;indx++)
2023 {
2024 saa_wbytes(plines, ftentry->filename, (int32_t)(strlen(ftentry->filename) + 1));
2025 saa_write8(plines,0); /* directory LEB128u */
2026 saa_write8(plines,0); /* time LEB128u */
2027 saa_write8(plines,0); /* size LEB128u */
2028 ftentry = ftentry->next;
2029 }
2030 saa_write8(plines,0); /* End of table */
2031 linepoff = plines->datalen;
2032 linelen = linepoff + totlen + 10;
2033 linebuf = pbuf = nasm_malloc(linelen);
2034 WRITELONG(pbuf,linelen-4); /* initial length */
2035 WRITESHORT(pbuf,3); /* dwarf version */
2036 WRITELONG(pbuf,linepoff); /* offset to line number program */
2037 /* write line header */
2038 saalen = linepoff;
2039 saa_rnbytes(plines, pbuf, saalen); /* read a given no. of bytes */
2040 pbuf += linepoff;
2041 saa_free(plines);
2042 /* concatonate line program ranges */
2043 linepoff += 13;
2044 plinesrel = saa_init(1L);
2045 psect = dwarf_fsect;
2046 for (indx = 0; indx < dwarf_nsections; indx++) {
2047 saa_write64(plinesrel, linepoff);
2048 saa_write64(plinesrel, ((uint64_t) (psect->section + 2) << 32) + R_X86_64_64);
2049 saa_write64(plinesrel, (uint64_t) 0);
2050 plinep = psect->psaa;
2051 saalen = plinep->datalen;
2052 saa_rnbytes(plinep, pbuf, saalen);
2053 pbuf += saalen;
2054 linepoff += saalen;
2055 saa_free(plinep);
2056 /* done with this entry */
2057 psect = psect->next;
2058 }
2059
2060
2061 /* build rela.lines section */
2062 linerellen =saalen = plinesrel->datalen;
2063 linerelbuf = pbuf = nasm_malloc(linerellen);
2064 saa_rnbytes(plinesrel, pbuf, saalen);
2065 saa_free(plinesrel);
2066
2067 /* build frame section */
2068 framelen = 4;
2069 framebuf = pbuf = nasm_malloc(framelen);
2070 WRITELONG(pbuf,framelen-4); /* initial length */
2071
2072 /* build loc section */
2073 loclen = 16;
2074 locbuf = pbuf = nasm_malloc(loclen);
2075 WRITEDLONG(pbuf,0); /* null beginning offset */
2076 WRITEDLONG(pbuf,0); /* null ending offset */
2077 }
2078
2079 static void dwarf64_cleanup(void)
2080 {
2081 nasm_free(arangesbuf);
2082 nasm_free(arangesrelbuf);
2083 nasm_free(pubnamesbuf);
2084 nasm_free(infobuf);
2085 nasm_free(inforelbuf);
2086 nasm_free(abbrevbuf);
2087 nasm_free(linebuf);
2088 nasm_free(linerelbuf);
2089 nasm_free(framebuf);
2090 nasm_free(locbuf);
2091 }
2092
2093 static void dwarf64_findfile(const char * fname)
2094 {
2095 int finx;
2096 struct linelist *match;
2097
2098 /* return if fname is current file name */
2099 if (dwarf_clist && !(strcmp(fname, dwarf_clist->filename)))
2100 return;
2101
2102 /* search for match */
2103 match = 0;
2104 if (dwarf_flist) {
2105 match = dwarf_flist;
2106 for (finx = 0; finx < dwarf_numfiles; finx++) {
2107 if (!(strcmp(fname, match->filename))) {
2108 dwarf_clist = match;
2109 return;
2110 }
2111 }
2112 }
2113
2114 /* add file name to end of list */
2115 dwarf_clist = (struct linelist *)nasm_malloc(sizeof(struct linelist));
2116 dwarf_numfiles++;
2117 dwarf_clist->line = dwarf_numfiles;
2118 dwarf_clist->filename = nasm_malloc(strlen(fname) + 1);
2119 strcpy(dwarf_clist->filename,fname);
2120 dwarf_clist->next = 0;
2121 if (!dwarf_flist) { /* if first entry */
2122 dwarf_flist = dwarf_elist = dwarf_clist;
2123 dwarf_clist->last = 0;
2124 } else { /* chain to previous entry */
2125 dwarf_elist->next = dwarf_clist;
2126 dwarf_elist = dwarf_clist;
2127 }
2128 }
2129
2130 static void dwarf64_findsect(const int index)
2131 {
2132 int sinx;
2133 struct sectlist *match;
2134 struct SAA *plinep;
2135
2136 /* return if index is current section index */
2137 if (dwarf_csect && (dwarf_csect->section == index))
2138 return;
2139
2140 /* search for match */
2141 match = 0;
2142 if (dwarf_fsect) {
2143 match = dwarf_fsect;
2144 for (sinx = 0; sinx < dwarf_nsections; sinx++) {
2145 if (match->section == index) {
2146 dwarf_csect = match;
2147 return;
2148 }
2149 match = match->next;
2150 }
2151 }
2152
2153 /* add entry to end of list */
2154 dwarf_csect = (struct sectlist *)nasm_malloc(sizeof(struct sectlist));
2155 dwarf_nsections++;
2156 dwarf_csect->psaa = plinep = saa_init(1L);
2157 dwarf_csect->line = 1;
2158 dwarf_csect->offset = 0;
2159 dwarf_csect->file = 1;
2160 dwarf_csect->section = index;
2161 dwarf_csect->next = 0;
2162 /* set relocatable address at start of line program */
2163 saa_write8(plinep,DW_LNS_extended_op);
2164 saa_write8(plinep,9); /* operand length */
2165 saa_write8(plinep,DW_LNE_set_address);
2166 saa_write64(plinep,0); /* Start Address */
2167
2168 if (!dwarf_fsect) { /* if first entry */
2169 dwarf_fsect = dwarf_esect = dwarf_csect;
2170 dwarf_csect->last = 0;
2171 } else { /* chain to previous entry */
2172 dwarf_esect->next = dwarf_csect;
2173 dwarf_esect = dwarf_csect;
2174 }
2175 }
2176
2177 #endif /* OF_ELF */
The Netwide Assembler