summaryrefslogtreecommitdiff
path: root/output/outlib.c
diff options
context:
space:
mode:
Diffstat (limited to 'output/outlib.c')
-rw-r--r--output/outlib.c278
1 files changed, 272 insertions, 6 deletions
diff --git a/output/outlib.c b/output/outlib.c
index c60de055..fa7db15e 100644
--- a/output/outlib.c
+++ b/output/outlib.c
@@ -1,6 +1,6 @@
/* ----------------------------------------------------------------------- *
- *
- * Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *
+ * Copyright 1996-2020 The NASM Authors - All Rights Reserved
* See the file AUTHORS included with the NASM distribution for
* the specific copyright holders.
*
@@ -14,7 +14,7 @@
* 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 COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
@@ -32,14 +32,13 @@
* ----------------------------------------------------------------------- */
/*
- * libout.c
+ * outlib.c
*
* Common routines for the output backends.
*/
-#include "compiler.h"
-#include "nasm.h"
#include "outlib.h"
+#include "raa.h"
uint64_t realsize(enum out_type type, uint64_t size)
{
@@ -56,3 +55,270 @@ uint64_t realsize(enum out_type type, uint64_t size)
return size;
}
}
+
+/* Common section/symbol handling */
+
+struct ol_sect *_ol_sect_list;
+uint64_t _ol_nsects; /* True sections, not external symbols */
+static struct ol_sect **ol_sect_tail = &_ol_sect_list;
+static struct hash_table ol_secthash;
+static struct RAA *ol_sect_index_tbl;
+
+struct ol_sym *_ol_sym_list;
+uint64_t _ol_nsyms;
+static struct ol_sym **ol_sym_tail = &_ol_sym_list;
+static struct hash_table ol_symhash;
+
+void ol_init(void)
+{
+}
+
+static void ol_free_symbols(void)
+{
+ struct ol_sym *s, *stmp;
+
+ hash_free(&ol_symhash);
+
+ list_for_each_safe(s, stmp, _ol_sym_list) {
+ nasm_free((char *)s->name);
+ nasm_free(s);
+ }
+
+ _ol_nsyms = 0;
+ _ol_sym_list = NULL;
+ ol_sym_tail = &_ol_sym_list;
+}
+
+static void ol_free_sections(void)
+{
+ struct ol_sect *s, *stmp;
+
+ hash_free(&ol_secthash);
+ raa_free(ol_sect_index_tbl);
+ ol_sect_index_tbl = NULL;
+
+ list_for_each_safe(s, stmp, _ol_sect_list) {
+ saa_free(s->data);
+ saa_free(s->reloc);
+ nasm_free((char *)s->name);
+ nasm_free(s);
+ }
+
+ _ol_nsects = 0;
+ _ol_sect_list = NULL;
+ ol_sect_tail = &_ol_sect_list;
+}
+
+void ol_cleanup(void)
+{
+ ol_free_symbols();
+ ol_free_sections();
+}
+
+/*
+ * Allocate a section index and add a section, subsection, or external
+ * symbol to the section-by-index table. If the index provided is zero,
+ * allocate a new index via seg_alloc().
+ */
+static uint32_t ol_seg_alloc(void *s, uint32_t ix)
+{
+ if (!ix)
+ ix = seg_alloc();
+ ol_sect_index_tbl = raa_write_ptr(ol_sect_index_tbl, ix >> 1, s);
+ return ix;
+}
+
+/*
+ * Find a section or create a new section structure if it does not exist
+ * and allocate it an index value via seg_alloc().
+ */
+struct ol_sect *_ol_get_sect(const char *name, size_t ssize, size_t rsize)
+{
+ struct ol_sect *s, **sp;
+ struct hash_insert hi;
+
+ sp = (struct ol_sect **)hash_find(&ol_secthash, name, &hi);
+ if (sp)
+ return *sp;
+
+ s = nasm_zalloc(ssize);
+ s->syml.tail = &s->syml.head;
+ s->name = nasm_strdup(name);
+ s->data = saa_init(1);
+ s->reloc = saa_init(rsize);
+ *ol_sect_tail = s;
+ ol_sect_tail = &s->next;
+ _ol_nsects++;
+ s->index = s->subindex = ol_seg_alloc(s, 0);
+
+ hash_add(&hi, s->name, s);
+ return s;
+}
+
+/* Find a section by name without creating one */
+struct ol_sect *_ol_sect_by_name(const char *name)
+{
+ struct ol_sect **sp;
+
+ sp = (struct ol_sect **)hash_find(&ol_secthash, name, NULL);
+ return sp ? *sp : NULL;
+}
+
+/* Find a section or external symbol by index; NULL if not valid */
+struct ol_sect *_ol_sect_by_index(int32_t index)
+{
+ uint32_t ix = index;
+
+ if (unlikely(ix >= SEG_ABS))
+ return NULL;
+
+ return raa_read_ptr(ol_sect_index_tbl, ix >> 1);
+}
+
+/*
+ * Start a new subsection for the given section. At the moment, once a
+ * subsection has been created, it is not possible to revert to an
+ * earlier subsection. ol_sect_by_index() will return the main section
+ * structure. Returns the new section index. This is used to prevent
+ * the front end from optimizing across subsection boundaries.
+ */
+int32_t _ol_new_subsection(struct ol_sect *sect)
+{
+ if (unlikely(!sect))
+ return NO_SEG;
+
+ return sect->subindex = ol_seg_alloc(sect, 0);
+}
+
+/*
+ * Insert a symbol into a list; need to use upcasting using container_of()
+ * to walk the list later.
+ */
+void ol_add_sym_to(struct ol_symlist *syml, struct ol_symhead *head,
+ uint64_t offset)
+{
+ syml->tree.key = offset;
+ head->tree = rb_insert(head->tree, &syml->tree);
+ *head->tail = syml;
+ head->tail = &syml->next;
+ head->n++;
+}
+
+/*
+ * Create a location structure from seg:offs
+ */
+void ol_mkloc(struct ol_loc *loc, int64_t offs, int32_t seg)
+{
+ nasm_zero(*loc);
+ loc->offs = offs;
+
+ if (unlikely((uint32_t)seg >= SEG_ABS)) {
+ if (likely(seg == NO_SEG)) {
+ loc->seg.t = OS_NOSEG;
+ } else {
+ loc->seg.t = OS_ABS;
+ loc->seg.index = seg - SEG_ABS;
+ }
+ } else {
+ loc->seg.index = seg & ~1;
+ loc->seg.t = OS_SECT | (seg & 1);
+ loc->seg.s.sect = _ol_sect_by_index(loc->seg.index);
+ }
+}
+
+/*
+ * Create a new symbol. If this symbol is OS_OFFS, add it to the relevant
+ * section, too. If the symbol already exists, return NULL; this is
+ * different from ol_get_section() as a single section may be invoked
+ * many times. On the contrary, the front end will prevent a single symbol
+ * from being defined more than once.
+ *
+ * If flags has OF_GLOBAL set, add it to the global symbol hash for
+ * the containing section if applicable.
+ *
+ * If flags has OF_IMPSEC set, allocate a segment index for it via
+ * seg_alloc() unless v->index is already set, and add it to the
+ * section by index list.
+ */
+struct ol_sym *_ol_new_sym(const char *name, const struct ol_loc *v,
+ uint32_t flags, size_t size)
+{
+ struct hash_insert hi;
+ struct ol_sym *sym;
+
+ if (hash_find(&ol_symhash, name, &hi))
+ return NULL; /* Symbol already exists */
+
+ flags |= OF_SYMBOL;
+
+ sym = nasm_zalloc(size);
+ sym->name = nasm_strdup(name);
+ sym->v = *v;
+
+ if (sym->v.seg.t & OS_SECT) {
+ struct ol_sect *sect = sym->v.seg.s.sect;
+
+ if (!sect || (sect->flags & OF_SYMBOL))
+ /* Must be an external or common reference */
+ flags |= OF_IMPSEC;
+
+ if (flags & OF_IMPSEC) {
+ /* Metasection */
+ if (!sym->v.seg.s.sym) {
+ sym->v.seg.s.sym = sym;
+ sym->v.seg.index = ol_seg_alloc(sym, sym->v.seg.index);
+ }
+ } else if (sym->v.seg.t == OS_OFFS) {
+ struct ol_sect * const sect = sym->v.seg.s.sect;
+ const uint64_t offs = sym->v.offs;
+
+ ol_add_sym_to(&sym->syml, &sect->syml, offs);
+ if (flags & OF_GLOBAL)
+ ol_add_sym_to(&sym->symg, &sect->symg, offs);
+ }
+ }
+ sym->flags = flags;
+
+ *ol_sym_tail = sym;
+ ol_sym_tail = &sym->next;
+ _ol_nsyms++;
+
+ hash_add(&hi, sym->name, sym);
+ return sym;
+}
+
+/* Find a symbol in the global namespace */
+struct ol_sym *_ol_sym_by_name(const char *name)
+{
+ struct ol_sym **symp;
+
+ symp = (struct ol_sym **)hash_find(&ol_symhash, name, NULL);
+ return symp ? *symp : NULL;
+}
+
+/*
+ * Find a symbol by address in a specific section. If no symbol is defined
+ * at that exact address, return the immediately previously defined one.
+ * If global is set, then only return global symbols.
+ */
+struct ol_sym *_ol_sym_by_address(struct ol_sect *sect, int64_t addr,
+ bool global)
+{
+ struct ol_symhead *head;
+ size_t t_offs;
+ struct rbtree *t;
+
+ if (global) {
+ head = &sect->symg;
+ t_offs = offsetof(struct ol_sym, symg.tree);
+ } else {
+ head = &sect->syml;
+ t_offs = offsetof(struct ol_sym, syml.tree);
+ }
+
+ t = rb_search(head->tree, addr);
+ if (!t)
+ return NULL;
+
+ return (struct ol_sym *)((char *)t - t_offs);
+}