| /* |
| * NASM-style list format |
| * |
| * Copyright (C) 2004-2007 Peter Johnson |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS'' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <util.h> |
| |
| #include <libyasm.h> |
| |
| /* NOTE: For this code to generate relocation information, the relocations |
| * have to be added by the object format to each section in program source |
| * order. |
| * |
| * This should not be an issue, as program source order == section bytecode |
| * order, so unless the object formats are very obtuse with their bytecode |
| * iteration, this should just happen. |
| */ |
| |
| #define REGULAR_BUF_SIZE 1024 |
| |
| yasm_listfmt_module yasm_nasm_LTX_listfmt; |
| |
| typedef struct sectreloc { |
| /*@reldef@*/ SLIST_ENTRY(sectreloc) link; |
| yasm_section *sect; |
| /*@null@*/ yasm_reloc *next_reloc; /* next relocation in section */ |
| unsigned long next_reloc_addr; |
| } sectreloc; |
| |
| typedef struct bcreloc { |
| /*@reldef@*/ STAILQ_ENTRY(bcreloc) link; |
| unsigned long offset; /* start of reloc from start of bytecode */ |
| size_t size; /* size of reloc in bytes */ |
| int rel; /* PC/IP-relative or "absolute" */ |
| } bcreloc; |
| |
| typedef struct nasm_listfmt_output_info { |
| yasm_arch *arch; |
| /*@reldef@*/ STAILQ_HEAD(bcrelochead, bcreloc) bcrelocs; |
| /*@null@*/ yasm_reloc *next_reloc; /* next relocation in section */ |
| unsigned long next_reloc_addr; |
| } nasm_listfmt_output_info; |
| |
| |
| static /*@null@*/ /*@only@*/ yasm_listfmt * |
| nasm_listfmt_create(const char *in_filename, const char *obj_filename) |
| { |
| yasm_listfmt_base *listfmt = yasm_xmalloc(sizeof(yasm_listfmt_base)); |
| listfmt->module = &yasm_nasm_LTX_listfmt; |
| return (yasm_listfmt *)listfmt; |
| } |
| |
| static void |
| nasm_listfmt_destroy(/*@only@*/ yasm_listfmt *listfmt) |
| { |
| yasm_xfree(listfmt); |
| } |
| |
| static int |
| nasm_listfmt_output_value(yasm_value *value, unsigned char *buf, |
| unsigned int destsize, unsigned long offset, |
| yasm_bytecode *bc, int warn, /*@null@*/ void *d) |
| { |
| /*@null@*/ nasm_listfmt_output_info *info = (nasm_listfmt_output_info *)d; |
| /*@dependent@*/ /*@null@*/ yasm_intnum *intn; |
| unsigned int valsize = value->size; |
| |
| assert(info != NULL); |
| |
| /* Output */ |
| switch (yasm_value_output_basic(value, buf, destsize, bc, warn, |
| info->arch)) { |
| case -1: |
| return 1; |
| case 0: |
| break; |
| default: |
| return 0; |
| } |
| |
| /* Generate reloc if needed */ |
| if (info->next_reloc && info->next_reloc_addr == bc->offset+offset) { |
| bcreloc *reloc = yasm_xmalloc(sizeof(bcreloc)); |
| reloc->offset = offset; |
| reloc->size = destsize; |
| reloc->rel = value->curpos_rel; |
| STAILQ_INSERT_TAIL(&info->bcrelocs, reloc, link); |
| |
| /* Get next reloc's info */ |
| info->next_reloc = yasm_section_reloc_next(info->next_reloc); |
| if (info->next_reloc) { |
| yasm_intnum *addr; |
| yasm_symrec *sym; |
| yasm_reloc_get(info->next_reloc, &addr, &sym); |
| info->next_reloc_addr = yasm_intnum_get_uint(addr); |
| } |
| } |
| |
| if (value->abs) { |
| intn = yasm_expr_get_intnum(&value->abs, 0); |
| if (intn) |
| return yasm_arch_intnum_tobytes(info->arch, intn, buf, destsize, |
| valsize, 0, bc, 0); |
| else { |
| yasm_error_set(YASM_ERROR_TOO_COMPLEX, |
| N_("relocation too complex")); |
| return 1; |
| } |
| } else { |
| int retval; |
| intn = yasm_intnum_create_uint(0); |
| retval = yasm_arch_intnum_tobytes(info->arch, intn, buf, destsize, |
| valsize, 0, bc, 0); |
| yasm_intnum_destroy(intn); |
| return retval; |
| } |
| |
| return 0; |
| } |
| |
| static void |
| nasm_listfmt_output(yasm_listfmt *listfmt, FILE *f, yasm_linemap *linemap, |
| yasm_arch *arch) |
| { |
| yasm_bytecode *bc; |
| const char *source; |
| unsigned long line = 1; |
| unsigned long listline = 1; |
| /*@only@*/ unsigned char *buf; |
| nasm_listfmt_output_info info; |
| /*@reldef@*/ SLIST_HEAD(sectrelochead, sectreloc) reloc_hist; |
| /*@null@*/ sectreloc *last_hist = NULL; |
| /*@null@*/ bcreloc *reloc = NULL; |
| yasm_section *sect; |
| |
| SLIST_INIT(&reloc_hist); |
| |
| info.arch = arch; |
| |
| buf = yasm_xmalloc(REGULAR_BUF_SIZE); |
| |
| while (!yasm_linemap_get_source(linemap, line, &bc, &source)) { |
| if (!bc) { |
| fprintf(f, "%6lu %*s%s\n", listline++, 32, "", source); |
| } else { |
| /* get the next relocation for the bytecode's section */ |
| sect = yasm_bc_get_section(bc); |
| if (!last_hist || last_hist->sect != sect) { |
| int found = 0; |
| |
| /* look through reloc_hist for matching section */ |
| SLIST_FOREACH(last_hist, &reloc_hist, link) { |
| if (last_hist->sect == sect) { |
| found = 1; |
| break; |
| } |
| } |
| |
| if (!found) { |
| /* not found, add to list*/ |
| last_hist = yasm_xmalloc(sizeof(sectreloc)); |
| last_hist->sect = sect; |
| last_hist->next_reloc = yasm_section_relocs_first(sect); |
| |
| if (last_hist->next_reloc) { |
| yasm_intnum *addr; |
| yasm_symrec *sym; |
| yasm_reloc_get(last_hist->next_reloc, &addr, &sym); |
| last_hist->next_reloc_addr = |
| yasm_intnum_get_uint(addr); |
| } |
| |
| SLIST_INSERT_HEAD(&reloc_hist, last_hist, link); |
| } |
| } |
| |
| info.next_reloc = last_hist->next_reloc; |
| info.next_reloc_addr = last_hist->next_reloc_addr; |
| STAILQ_INIT(&info.bcrelocs); |
| |
| /* loop over bytecodes on this line (usually only one) */ |
| while (bc && bc->line == line) { |
| /*@null@*/ /*@only@*/ unsigned char *bigbuf; |
| unsigned long size = REGULAR_BUF_SIZE; |
| long multiple; |
| unsigned long offset = bc->offset; |
| unsigned char *origp, *p; |
| int gap; |
| |
| /* convert bytecode into bytes, recording relocs along the |
| * way |
| */ |
| bigbuf = yasm_bc_tobytes(bc, buf, &size, &gap, &info, |
| nasm_listfmt_output_value, NULL); |
| yasm_bc_get_multiple(bc, &multiple, 1); |
| if (multiple <= 0) |
| size = 0; |
| else |
| size /= multiple; |
| |
| /* output bytes with reloc information */ |
| origp = bigbuf ? bigbuf : buf; |
| p = origp; |
| reloc = STAILQ_FIRST(&info.bcrelocs); |
| if (gap) { |
| fprintf(f, "%6lu %08lX <gap>%*s%s\n", listline++, offset, |
| 18, "", source ? source : ""); |
| } else while (size > 0) { |
| int i; |
| |
| fprintf(f, "%6lu %08lX ", listline++, offset); |
| for (i=0; i<18 && size > 0; size--) { |
| if (reloc && (unsigned long)(p-origp) == |
| reloc->offset) { |
| fprintf(f, "%c", reloc->rel ? '(' : '['); |
| i++; |
| } |
| fprintf(f, "%02X", *(p++)); |
| i+=2; |
| if (reloc && (unsigned long)(p-origp) == |
| reloc->offset+reloc->size) { |
| fprintf(f, "%c", reloc->rel ? ')' : ']'); |
| i++; |
| reloc = STAILQ_NEXT(reloc, link); |
| } |
| } |
| if (size > 0) |
| fprintf(f, "-"); |
| else { |
| if (multiple > 1) { |
| fprintf(f, "<rept>"); |
| i += 6; |
| } |
| fprintf(f, "%*s", 18-i+1, ""); |
| } |
| if (source) { |
| fprintf(f, " %s", source); |
| source = NULL; |
| } |
| fprintf(f, "\n"); |
| } |
| |
| if (bigbuf) |
| yasm_xfree(bigbuf); |
| bc = STAILQ_NEXT(bc, link); |
| } |
| |
| /* delete bcrelocs (newly generated next bytecode if any) */ |
| reloc = STAILQ_FIRST(&info.bcrelocs); |
| while (reloc) { |
| bcreloc *reloc2 = STAILQ_NEXT(reloc, link); |
| yasm_xfree(reloc); |
| reloc = reloc2; |
| } |
| |
| /* save reloc context */ |
| last_hist->next_reloc = info.next_reloc; |
| last_hist->next_reloc_addr = info.next_reloc_addr; |
| } |
| line++; |
| } |
| |
| /* delete reloc history */ |
| while (!SLIST_EMPTY(&reloc_hist)) { |
| last_hist = SLIST_FIRST(&reloc_hist); |
| SLIST_REMOVE_HEAD(&reloc_hist, link); |
| yasm_xfree(last_hist); |
| } |
| |
| yasm_xfree(buf); |
| } |
| |
| /* Define listfmt structure -- see listfmt.h for details */ |
| yasm_listfmt_module yasm_nasm_LTX_listfmt = { |
| "NASM-style list format", |
| "nasm", |
| nasm_listfmt_create, |
| nasm_listfmt_destroy, |
| nasm_listfmt_output |
| }; |
