From: Michael Urman Date: Sun, 3 Aug 2003 01:13:14 +0000 (-0000) Subject: ELF objfmt size agnosticism: X-Git-Tag: v0.3.0~6^2~14 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=e2808bab9a9e8c96ef6ddd68f6a0476628c60aa2;p=yasm ELF objfmt size agnosticism: * Replace ulongs secthead.size, secthead.align, reloc.addr with intnums * Calculate relocation size with intnums * Create macros YASM_WRITE_32I_L, YASM_WRITE_64I_L to write 32/64bit intnums to buffer This doesn't quite cover everything, particularly due to various calls to yasm_intnum_get_uint for various bits of processing, but it's close! Miscellany: * Fix non-call to elf_reloc_delete() * Remove unused secthead.addr, secthead_set_addr * Create macro YASM_WRITE_64Z_L to write zero-extended 32bit value to 64bits of buffer svn path=/trunk/yasm/; revision=1030 --- diff --git a/modules/objfmts/elf/elf-objfmt.c b/modules/objfmts/elf/elf-objfmt.c index de10a5bf..605f8842 100644 --- a/modules/objfmts/elf/elf-objfmt.c +++ b/modules/objfmts/elf/elf-objfmt.c @@ -56,7 +56,6 @@ typedef struct { elf_secthead *shead; yasm_section *sect; unsigned long sindex; - unsigned long addr; } elf_objfmt_output_info; static unsigned int elf_objfmt_parse_scnum; /* sect numbering in parser */ @@ -234,7 +233,8 @@ elf_objfmt_output_expr(yasm_expr **ep, unsigned char *buf, size_t destsize, *ep = yasm_expr_simplify(*ep, yasm_common_calc_bc_dist); } - reloc = elf_reloc_entry_new(sym, bc->offset + offset, rel, valsize); + reloc = elf_reloc_entry_new(sym, + yasm_intnum_new_uint(bc->offset + offset), rel, valsize); if (reloc == NULL) { yasm__error(bc->line, N_("elf: invalid relocation size")); return 1; @@ -283,8 +283,16 @@ elf_objfmt_output_bytecode(yasm_bytecode *bc, /*@null@*/ void *d) yasm_xfree(bigbuf); return 0; } + else { + yasm_intnum *bcsize = yasm_intnum_new_uint(size); + yasm_intnum *mult = yasm_intnum_new_uint(multiple); + + yasm_intnum_calc(bcsize, YASM_EXPR_MUL, mult, 0); + elf_secthead_add_size(info->shead, bcsize); - elf_secthead_add_size(info->shead, multiple * size); + yasm_intnum_delete(bcsize); + yasm_intnum_delete(mult); + } /* Warn that gaps are converted to 0 and write out the 0's. */ if (gap) { @@ -333,14 +341,16 @@ elf_objfmt_output_section(yasm_section *sect, /*@null@*/ void *d) if (shead == NULL) yasm_internal_error("no section header attached to section"); - /*elf_secthead_set_addr(shead, info->addr);*/ - /* don't output header-only sections */ if ((elf_secthead_get_type(shead) & SHT_NOBITS) == SHT_NOBITS) { yasm_bytecode *last = yasm_bcs_last(yasm_section_get_bytecodes(sect)); - if (last) - elf_secthead_add_size(shead, last->offset + last->len); + if (last) { + yasm_intnum *sectsize; + sectsize = yasm_intnum_new_uint(last->offset + last->len); + elf_secthead_add_size(shead, sectsize); + yasm_intnum_delete(sectsize); + } elf_secthead_set_index(shead, ++info->sindex); return 0; } @@ -362,10 +372,9 @@ elf_objfmt_output_section(yasm_section *sect, /*@null@*/ void *d) elf_objfmt_output_bytecode); /* Empty? Go on to next section */ - if (elf_secthead_get_size(shead) == 0) + if (elf_secthead_is_empty(shead)) return 0; - info->addr += elf_secthead_get_size(shead); elf_secthead_set_index(shead, ++info->sindex); /* No relocations to output? Go on to next section */ @@ -428,7 +437,6 @@ elf_objfmt_output(FILE *f, yasm_sectionhead *sections, int all_syms) unsigned long elf_symtab_nlocal; info.f = f; - info.addr = 0; /* Allocate space for Ehdr by seeking forward */ if (fseek(f, (long)(elf_proghead_get_size()), SEEK_SET) < 0) { @@ -444,7 +452,6 @@ elf_objfmt_output(FILE *f, yasm_sectionhead *sections, int all_syms) /* output known sections - includes reloc sections which aren't in yasm's * list. Assign indices as we go. */ info.sindex = 3; - info.addr = 0; if (yasm_sections_traverse(sections, &info, elf_objfmt_output_section)) return; @@ -535,6 +542,7 @@ elf_objfmt_sections_switch(yasm_sectionhead *headp, unsigned long type = SHT_PROGBITS; unsigned long flags = SHF_ALLOC; unsigned long align = 4; + yasm_intnum *align_intn = NULL; int flags_override = 0; char *sectname; int resonly = 0; @@ -602,17 +610,17 @@ elf_objfmt_sections_switch(yasm_sectionhead *headp, } else if (yasm__strcasecmp(vp->val, "align") == 0 && vp->param) { if (0 /* win32 */) { - /*@dependent@*/ /*@null@*/ const yasm_intnum *align_inum; + /*@dependent@*/ /*@null@*/ const yasm_intnum *align_expr; unsigned long addralign; - align_inum = yasm_expr_get_intnum(&vp->param, NULL); - if (!align_inum) { + align_expr = yasm_expr_get_intnum(&vp->param, NULL); + if (!align_expr) { yasm__error(lindex, N_("argument to `%s' is not a power of two"), vp->val); return NULL; } - addralign = yasm_intnum_get_uint(align_inum); + addralign = yasm_intnum_get_uint(align_expr); /* Alignments must be a power of two. */ if ((addralign & (addralign - 1)) != 0) { @@ -622,8 +630,7 @@ elf_objfmt_sections_switch(yasm_sectionhead *headp, return NULL; } - /* Convert alignment into flags setting */ - align = addralign; + align_intn = yasm_intnum_copy(align_expr); } } else yasm__warning(YASM_WARN_GENERAL, lindex, @@ -640,7 +647,10 @@ elf_objfmt_sections_switch(yasm_sectionhead *headp, esd = elf_secthead_new(name, type, flags, elf_objfmt_parse_scnum++, 0, 0); - if (align) elf_secthead_set_align(esd, align); + if (!align_intn) + align_intn = yasm_intnum_new_uint(align); + if (align_intn) + elf_secthead_set_align(esd, align_intn); yasm_section_set_of_data(retval, &yasm_elf_LTX_objfmt, esd); sym = yasm_symrec_define_label(sectname, retval, (yasm_bytecode *)NULL, 1, lindex); diff --git a/modules/objfmts/elf/elf.c b/modules/objfmts/elf/elf.c index b071dfb4..d4b06d2f 100644 --- a/modules/objfmts/elf/elf.c +++ b/modules/objfmts/elf/elf.c @@ -34,9 +34,21 @@ #define YASM_OBJFMT_ELF_INTERNAL #include "elf.h" -#define YASM_WRITE_64C_L(p,hi,lo) \ +#define YASM_WRITE_32I_L(p, i) do {\ + assert(yasm_intnum_check_size(i, 32, 0, 2)); \ + yasm_intnum_get_sized(i, p, 4, 32, 0, 0, 0, 0); \ + p += 4; } while (0) + +#define YASM_WRITE_64I_L(p, i) do {\ + assert(yasm_intnum_check_size(i, 64, 0, 2)); \ + yasm_intnum_get_sized(i, p, 8, 64, 0, 0, 0, 0); \ + p += 8; } while (0) + +#define YASM_WRITE_64C_L(p, hi, lo) do {\ YASM_WRITE_32_L(p, lo); \ - YASM_WRITE_32_L(p, hi) + YASM_WRITE_32_L(p, hi); } while (0) + +#define YASM_WRITE_64Z_L(p, i) YASM_WRITE_64C_L(p, 0, i) static /*@dependent@*/ yasm_arch *cur_arch; static enum { @@ -73,22 +85,30 @@ elf_set_arch(yasm_arch *arch, const char *machine) } /* reloc functions */ +/* takes ownership of addr */ elf_reloc_entry * elf_reloc_entry_new(yasm_symrec *sym, - elf_address addr, + yasm_intnum *addr, int rel, size_t valsize) { elf_reloc_entry *entry; switch (cur_machine) { case M_X86_32: - if (valsize != 32) + if (valsize != 32) { + if (addr) + yasm_intnum_delete(addr); return NULL; + } break; case M_X86_64: if (valsize != 8 && valsize != 16 && valsize != 32 && valsize != 64) + { + if (addr) + yasm_intnum_delete(addr); return NULL; + } break; default: @@ -110,6 +130,8 @@ elf_reloc_entry_new(yasm_symrec *sym, void elf_reloc_entry_delete(elf_reloc_entry *entry) { + if (entry->addr) + yasm_intnum_delete(entry->addr); yasm_xfree(entry); } @@ -392,19 +414,19 @@ elf_symtab_write_to_file(FILE *f, elf_symtab_head *symtab) prev = NULL; STAILQ_FOREACH(entry, symtab, qlink) { - const yasm_intnum *size_intn; + yasm_intnum *size_intn=NULL, *value_intn=NULL; bufp = buf; /* get size (if specified); expr overrides stored integer */ if (entry->xsize) { - size_intn = yasm_expr_get_intnum(&entry->xsize, - yasm_common_calc_bc_dist); - if (size_intn) - entry->size = yasm_intnum_get_uint(size_intn); - else + size_intn = yasm_intnum_copy( + yasm_expr_get_intnum(&entry->xsize, yasm_common_calc_bc_dist)); + if (!size_intn) yasm__error(entry->xsize->line, - N_("size specifier not an integer expression")); + N_("size specifier not an integer expression")); } + else + size_intn = yasm_intnum_new_uint(entry->size); /* get EQU value for constants */ if (entry->sym) { @@ -422,17 +444,20 @@ elf_symtab_write_to_file(FILE *f, elf_symtab_head *symtab) N_("EQU value not an integer expression")); } - entry->value = yasm_intnum_get_uint(equ_intn); + value_intn = yasm_intnum_copy(equ_intn); entry->index = SHN_ABS; yasm_expr_delete(equ_expr); } } + if (value_intn == NULL) + value_intn = yasm_intnum_new_uint(entry->value); switch (cur_elf) { case ELF32: YASM_WRITE_32_L(bufp, entry->name ? entry->name->index : 0); - YASM_WRITE_32_L(bufp, entry->value); - YASM_WRITE_32_L(bufp, entry->size); + YASM_WRITE_32I_L(bufp, value_intn); + YASM_WRITE_32I_L(bufp, size_intn); + YASM_WRITE_8(bufp, ELF32_ST_INFO(entry->bind, entry->type)); YASM_WRITE_8(bufp, 0); if (entry->sect) { @@ -461,14 +486,16 @@ elf_symtab_write_to_file(FILE *f, elf_symtab_head *symtab) } else { YASM_WRITE_16_L(bufp, entry->index); } - /* XXX: instead of turning arbitrary sized intnums to 32-bit - * values above, write them directly here */ - YASM_WRITE_64C_L(bufp, 0, entry->value); - YASM_WRITE_64C_L(bufp, 0, entry->size); + YASM_WRITE_64I_L(bufp, value_intn); + YASM_WRITE_64I_L(bufp, size_intn); fwrite(buf, SYMTAB64_SIZE, 1, f); size += SYMTAB64_SIZE; break; } + + yasm_intnum_delete(size_intn); + yasm_intnum_delete(value_intn); + prev = entry; } return size; @@ -505,12 +532,11 @@ elf_secthead_new(elf_strtab_entry *name, esd->type = type; esd->flags = flags; - esd->addr = 0; esd->offset = offset; - esd->size = size; + esd->size = yasm_intnum_new_uint(size); esd->link = 0; esd->info = 0; - esd->align = 0; + esd->align = NULL; esd->entsize = 0; esd->index = idx; @@ -524,14 +550,15 @@ elf_secthead_new(elf_strtab_entry *name, esd->nreloc = 0; if (name && (strcmp(name->str, ".symtab") == 0)) { - esd->align = 4; switch (cur_elf) { case ELF32: esd->entsize = SYMTAB32_SIZE; + esd->align = yasm_intnum_new_uint(SYMTAB32_ALIGN); break; case ELF64: esd->entsize = SYMTAB64_SIZE; + esd->align = yasm_intnum_new_uint(SYMTAB64_ALIGN); break; default: @@ -548,15 +575,12 @@ elf_secthead_delete(elf_secthead *shead) if (shead == NULL) yasm_internal_error(N_("shead is null")); - if (shead->relocs) { - elf_reloc_entry *r1, *r2; - r1 = STAILQ_FIRST(shead->relocs); - while (r1 != NULL) { - r2 = STAILQ_NEXT(r1, qlink); - yasm_xfree(r1); - r1 = r2; - } - } + if (shead->align) + yasm_intnum_delete(shead->align); + + if (shead->relocs) + elf_reloc_delete(shead->relocs); + yasm_xfree(shead); } @@ -576,11 +600,12 @@ void elf_secthead_print(FILE *f, int indent_level, elf_secthead *sect) fprintf(f, "EXEC "); /*if (sect->flags & SHF_MASKPROC) fprintf(f, "PROC-SPECIFIC"); */ - fprintf(f, "\n%*saddr=0x%lx\n", indent_level, "", sect->addr); fprintf(f, "%*soffset=0x%lx\n", indent_level, "", sect->offset); - fprintf(f, "%*ssize=0x%lx\n", indent_level, "", sect->size); + fprintf(f, "%*ssize=0x%lx\n", indent_level, "", + yasm_intnum_get_uint(sect->size)); fprintf(f, "%*slink=0x%x\n", indent_level, "", sect->link); - fprintf(f, "%*salign=%ld\n", indent_level, "", sect->align); + fprintf(f, "%*salign=%ld\n", indent_level, "", + yasm_intnum_get_uint(sect->align)); fprintf(f, "%*snreloc=%ld\n", indent_level, "", sect->nreloc); if (sect->nreloc) { elf_reloc_entry *reloc; @@ -592,7 +617,8 @@ void elf_secthead_print(FILE *f, int indent_level, elf_secthead *sect) fprintf(f, "%*soffset=0x%lx\n", indent_level+1, "", sect->rel_offset); STAILQ_FOREACH(reloc, sect->relocs, qlink) { fprintf(f, "%*s%s at 0x%lx\n", indent_level+2, "", - yasm_symrec_get_name(reloc->sym), reloc->addr); + yasm_symrec_get_name(reloc->sym), + yasm_intnum_get_uint(reloc->addr)); } } } @@ -612,14 +638,17 @@ elf_secthead_write_to_file(FILE *f, elf_secthead *shead, YASM_WRITE_32_L(bufp, shead->name ? shead->name->index : 0); YASM_WRITE_32_L(bufp, shead->type); YASM_WRITE_32_L(bufp, shead->flags); - YASM_WRITE_32_L(bufp, shead->addr); + YASM_WRITE_32_L(bufp, 0); /* vmem address */ YASM_WRITE_32_L(bufp, shead->offset); - YASM_WRITE_32_L(bufp, shead->size); + YASM_WRITE_32I_L(bufp, shead->size); YASM_WRITE_32_L(bufp, shead->link); YASM_WRITE_32_L(bufp, shead->info); - YASM_WRITE_32_L(bufp, shead->align); + if (shead->align) + YASM_WRITE_32I_L(bufp, shead->align); + else + YASM_WRITE_32_L(bufp, 0); YASM_WRITE_32_L(bufp, shead->entsize); if (fwrite(buf, SHDR32_SIZE, 1, f)) @@ -629,16 +658,19 @@ elf_secthead_write_to_file(FILE *f, elf_secthead *shead, case ELF64: YASM_WRITE_32_L(bufp, shead->name ? shead->name->index : 0); YASM_WRITE_32_L(bufp, shead->type); - YASM_WRITE_64C_L(bufp, 0, shead->flags); - YASM_WRITE_64C_L(bufp, 0, shead->addr); - YASM_WRITE_64C_L(bufp, 0, shead->offset); - YASM_WRITE_64C_L(bufp, 0, shead->size); + YASM_WRITE_64Z_L(bufp, shead->flags); + YASM_WRITE_64Z_L(bufp, 0); /* vmem address */ + YASM_WRITE_64Z_L(bufp, shead->offset); + YASM_WRITE_64I_L(bufp, shead->size); YASM_WRITE_32_L(bufp, shead->link); YASM_WRITE_32_L(bufp, shead->info); - YASM_WRITE_64C_L(bufp, 0, shead->align); - YASM_WRITE_64C_L(bufp, 0, shead->entsize); + if (shead->align) + YASM_WRITE_64I_L(bufp, shead->align); + else + YASM_WRITE_64Z_L(bufp, 0); + YASM_WRITE_64Z_L(bufp, shead->entsize); if (fwrite(buf, SHDR64_SIZE, 1, f)) return SHDR64_SIZE; @@ -684,6 +716,9 @@ elf_secthead_write_rel_to_file(FILE *f, elf_section_index symtab_idx, shead->rel_index = sindex; switch (cur_elf) { + yasm_intnum *nreloc; + yasm_intnum *relocsize; + case ELF32: YASM_WRITE_32_L(bufp, shead->rel_name ? shead->rel_name->index : 0); YASM_WRITE_32_L(bufp, SHT_REL); @@ -695,7 +730,7 @@ elf_secthead_write_rel_to_file(FILE *f, elf_section_index symtab_idx, YASM_WRITE_32_L(bufp, symtab_idx); /* link: symtab index */ YASM_WRITE_32_L(bufp, shead->index); /* info: relocated's index */ - YASM_WRITE_32_L(bufp, 4); /* align */ + YASM_WRITE_32_L(bufp, RELOC32_ALIGN); /* align */ YASM_WRITE_32_L(bufp, RELOC32_SIZE); /* entity size */ if (fwrite(buf, SHDR32_SIZE, 1, f)) @@ -705,15 +740,21 @@ elf_secthead_write_rel_to_file(FILE *f, elf_section_index symtab_idx, case ELF64: YASM_WRITE_32_L(bufp, shead->rel_name ? shead->rel_name->index : 0); YASM_WRITE_32_L(bufp, SHT_REL); - YASM_WRITE_64C_L(bufp, 0, 0); - YASM_WRITE_64C_L(bufp, 0, 0); - YASM_WRITE_64C_L(bufp, 0, shead->rel_offset); - YASM_WRITE_64C_L(bufp, 0, RELOC64_SIZE * shead->nreloc); /* size */ + YASM_WRITE_64Z_L(bufp, 0); + YASM_WRITE_64Z_L(bufp, 0); + YASM_WRITE_64Z_L(bufp, shead->rel_offset); + + nreloc = yasm_intnum_new_uint(shead->nreloc); + relocsize = yasm_intnum_new_uint(RELOC64_SIZE); + yasm_intnum_calc(relocsize, YASM_EXPR_MUL, nreloc, 0); + YASM_WRITE_64I_L(bufp, relocsize); /* size */ + yasm_intnum_delete(nreloc); + yasm_intnum_delete(relocsize); YASM_WRITE_32_L(bufp, symtab_idx); /* link: symtab index */ YASM_WRITE_32_L(bufp, shead->index); /* info: relocated's index */ - YASM_WRITE_64C_L(bufp, 0, 8); /* align */ - YASM_WRITE_64C_L(bufp, 0, RELOC64_SIZE); /* entity size */ + YASM_WRITE_64Z_L(bufp, RELOC64_ALIGN); /* align */ + YASM_WRITE_64Z_L(bufp, RELOC64_SIZE); /* entity size */ if (fwrite(buf, SHDR64_SIZE, 1, f)) return SHDR64_SIZE; @@ -810,14 +851,14 @@ elf_secthead_write_relocs_to_file(FILE *f, elf_secthead *shead) bufp = buf; switch (cur_elf) { case ELF32: - YASM_WRITE_32_L(bufp, reloc->addr); + YASM_WRITE_32I_L(bufp, reloc->addr); YASM_WRITE_32_L(bufp, ELF32_R_INFO(r_sym, r_type)); fwrite(buf, RELOC32_SIZE, 1, f); size += RELOC32_SIZE; break; case ELF64: - YASM_WRITE_64C_L(bufp, 0, reloc->addr); + YASM_WRITE_64I_L(bufp, reloc->addr); /*YASM_WRITE_64_L(bufp, ELF64_R_INFO(r_sym, r_type));*/ YASM_WRITE_64C_L(bufp, r_sym, r_type); fwrite(buf, RELOC64_SIZE, 1, f); @@ -838,10 +879,10 @@ elf_secthead_get_type(elf_secthead *shead) return shead->type; } -elf_size -elf_secthead_get_size(elf_secthead *shead) +int +elf_secthead_is_empty(elf_secthead *shead) { - return shead->size; + return yasm_intnum_is_zero(shead->size); } yasm_symrec * @@ -850,15 +891,12 @@ elf_secthead_get_sym(elf_secthead *shead) return shead->sym; } -elf_address -elf_secthead_set_addr(elf_secthead *shead, elf_address addr) -{ - return shead->addr = addr; -} - -elf_address -elf_secthead_set_align(elf_secthead *shead, elf_address align) +const yasm_intnum * +elf_secthead_set_align(elf_secthead *shead, yasm_intnum *align) { + if (shead->align != NULL) + yasm_intnum_delete(shead->align); + return shead->align = align; } @@ -898,16 +936,18 @@ elf_secthead_set_sym(elf_secthead *shead, yasm_symrec *sym) return shead->sym = sym; } -unsigned long -elf_secthead_add_size(elf_secthead *shead, unsigned long size) +void +elf_secthead_add_size(elf_secthead *shead, yasm_intnum *size) { - return shead->size += size; + if (size) { + yasm_intnum_calc(shead->size, YASM_EXPR_ADD, size, 0); + } } long elf_secthead_set_file_offset(elf_secthead *shead, long pos) { - unsigned long align = shead->align; + unsigned long align = yasm_intnum_get_uint(shead->align); if (align == 0 || align == 1) { shead->offset = (unsigned long)pos; @@ -982,16 +1022,16 @@ elf_proghead_write_to_file(FILE *f, YASM_WRITE_8(bufp, ELFDATA2LSB); /* data encoding :: MSB? */ YASM_WRITE_8(bufp, EV_CURRENT); /* elf version */ YASM_WRITE_8(bufp, ELFOSABI_SYSV); /* os/abi */ - YASM_WRITE_8(bufp, 0); /* SYSV v3 ABI=0 */ - while (bufp-buf < EI_NIDENT) /* e_ident padding */ + YASM_WRITE_8(bufp, 0); /* SYSV v3 ABI=0 */ + while (bufp-buf < EI_NIDENT) /* e_ident padding */ YASM_WRITE_8(bufp, 0); YASM_WRITE_16_L(bufp, ET_REL); /* e_type - object file */ YASM_WRITE_16_L(bufp, EM_X86_64); /* e_machine - or others */ YASM_WRITE_32_L(bufp, EV_CURRENT); /* elf version */ - YASM_WRITE_64C_L(bufp, 0, 0); /* e_entry */ - YASM_WRITE_64C_L(bufp, 0, 0); /* e_phoff */ - YASM_WRITE_64C_L(bufp, 0, secthead_addr);/* e_shoff secthead off */ + YASM_WRITE_64Z_L(bufp, 0); /* e_entry */ + YASM_WRITE_64Z_L(bufp, 0); /* e_phoff */ + YASM_WRITE_64Z_L(bufp, secthead_addr); /* e_shoff secthead off */ YASM_WRITE_32_L(bufp, 0); /* e_flags */ YASM_WRITE_16_L(bufp, EHDR64_SIZE); /* e_ehsize */ diff --git a/modules/objfmts/elf/elf.h b/modules/objfmts/elf/elf.h index 887ac3da..9a825973 100644 --- a/modules/objfmts/elf/elf.h +++ b/modules/objfmts/elf/elf.h @@ -218,10 +218,16 @@ typedef enum { #define SYMTAB64_SIZE 24 #define SYMTAB_MAXSIZE 24 +#define SYMTAB32_ALIGN 4 +#define SYMTAB64_ALIGN 8 + #define RELOC32_SIZE 8 #define RELOC64_SIZE 16 #define RELOC_MAXSIZE 16 +#define RELOC32_ALIGN 4 +#define RELOC64_ALIGN 8 + /* elf relocation type - index of semantics */ typedef enum { @@ -260,12 +266,11 @@ typedef enum { struct elf_secthead { elf_section_type type; elf_section_flags flags; - elf_address addr; elf_address offset; - elf_size size; + yasm_intnum *size; elf_section_index link; elf_section_info info; /* see note ESD1 */ - elf_address align; + yasm_intnum *align; elf_size entsize; yasm_symrec *sym; @@ -300,7 +305,7 @@ struct elf_secthead { STAILQ_HEAD(elf_reloc_head, elf_reloc_entry); struct elf_reloc_entry { STAILQ_ENTRY(elf_reloc_entry) qlink; - elf_address addr; + yasm_intnum *addr; yasm_symrec *sym; int rtype_rel; size_t valsize; @@ -336,7 +341,7 @@ int elf_set_arch(struct yasm_arch *arch, const char *machine); /* reloc functions */ elf_reloc_entry *elf_reloc_entry_new(yasm_symrec *sym, - elf_address addr, + yasm_intnum *addr, int rel, size_t valsize); void elf_reloc_entry_delete(elf_reloc_entry *entry); @@ -386,10 +391,10 @@ unsigned long elf_secthead_write_to_file(FILE *f, elf_secthead *esd, void elf_secthead_print(FILE *f, int indent_level, elf_secthead *esh); int elf_secthead_append_reloc(elf_secthead *shead, elf_reloc_entry *reloc); elf_section_type elf_secthead_get_type(elf_secthead *shead); -elf_size elf_secthead_get_size(elf_secthead *shead); +int elf_secthead_is_empty(elf_secthead *shead); struct yasm_symrec *elf_secthead_get_sym(elf_secthead *shead); -elf_address elf_secthead_set_addr(elf_secthead *shead, elf_address addr); -elf_address elf_secthead_set_align(elf_secthead *shead, elf_address align); +const struct yasm_intnum *elf_secthead_set_align(elf_secthead *shead, + struct yasm_intnum *align); elf_section_info elf_secthead_set_info(elf_secthead *shead, elf_section_info info); elf_section_index elf_secthead_set_index(elf_secthead *shead, @@ -402,7 +407,7 @@ elf_strtab_entry *elf_secthead_set_rel_name(elf_secthead *shead, elf_strtab_entry *entry); struct yasm_symrec *elf_secthead_set_sym(elf_secthead *shead, struct yasm_symrec *sym); -unsigned long elf_secthead_add_size(elf_secthead *shead, unsigned long size); +void elf_secthead_add_size(elf_secthead *shead, yasm_intnum *size); unsigned long elf_secthead_write_rel_to_file(FILE *f, elf_section_index symtab, elf_secthead *esd, elf_section_index sindex);