path: root/lib/linker.c

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#include "config.h"
#include "linker.h"
#include "types.h"
#include "exceptions.h"
#include "hash.h"

/* Les quelques structures de données utiles */

typedef struct object_t {
	Uint32 s_text, s_data, s_bss, *text, *data, textstart, datastart, bssstart;
} object_t;

typedef struct symbol_t {
	char *name;
	int objindex;
	Uint32 offset;
	int type;
	struct symbol_t *next;
} symbol_t;

/* Et les variables globales */

Uint32 startpoint = -1, textsize = 0, datasize = 0, bsssize = 0;

object_t **objects;
symbol_t *symbols, *psymbols;
int objindex = 0, nbrsymbs = 0;

_TableauVariable symbs;

/* Quelques fonctions pour nous simplifier la vie... */

static FILE *openfilewriting(char *name)
{
	FILE *f;

	if (!(f = fopen(name, "wb"))) {
		pushcontext(strerror(errno));
		exception(1, _("Error writing file"));
	}
	return f;
}

static FILE *openfilereading(char *name)
{
	FILE *f;

	if (!(f = fopen(name, "rb"))) {
		pushcontext(strerror(errno));
		exception(1, _("Error reading file"));
	}
	return f;
}

static void writeword(Uint32 a, FILE * f)
{
	if (fwrite(&a, sizeof(unsigned long int), 1, f) != 1) {
		if (ferror(f)) {
			pushcontext(strerror(errno));
		}
		exception(1, _("Error writing file"));
	}
}

static Uint32 readword(FILE * f)
{
	Uint32 a;

	if (fread(&a, sizeof(a), 1, f) != 1) {
		exception(1, _("premature end of file"));
	}
	return a;
}

static char *readstring(FILE * f)
{
	Uint32 s;
	char *r;
	int i;

	s = readword(f);
	r = (char *) Emalloc(s + 1);
	for (i = 0; i < s; i++) {
		r[i] = readword(f);
	}
	r[i] = '\0';
	return r;
}

/* Rajoute un symbole dans la pile */

static void addsymbol(char *name, int offset, int type)
{
	symbol_t *newsymbol;

	newsymbol = (symbol_t *) Emalloc(sizeof(symbol_t));
	newsymbol->next = NULL;
	newsymbol->type = type;
	newsymbol->offset = offset;
	newsymbol->objindex = objindex;
	newsymbol->name = name;

	psymbols->next = newsymbol;
	psymbols = newsymbol;

	if (newsymbol->type & 1) {
		nbrsymbs++;
	} else {
		InsererVarDansTab(&symbs, CreerElement(name, newsymbol));
	}
}

/* Rajoute un fichier dans les structures */

void addfile(char *nom)
{
	FILE *f;
	Uint32 start, nbsymbols, type, offset;
	int i;
	char *snom, errctx[BUFSIZ];

	f = openfilereading(nom);
	sprintf(errctx, _("Processing file %s"), nom);
	pushcontext(errctx);

	if (readword(f) != 0x4f424e4e) {
		exception(1, _("Bad signature"));
	}

	readword(f);		/* Taille du fichier */
	start = readword(f);
	if ((startpoint != -1) && (start != -1)) {
		exception(1, _("Startpoint already defined."));
	}
	startpoint = start + textsize;

	objects[objindex]->s_text = readword(f);
	objects[objindex]->s_data = readword(f);
	objects[objindex]->s_bss = readword(f);
	readword(f);		/* Taille de la table des symboles */
	nbsymbols = readword(f);

	pushcontext(_("Reading symbols"));
	for (i = 0; i < nbsymbols; i++) {
		type = readword(f);
		offset = readword(f);
		snom = readstring(f);
		addsymbol(snom, offset, type);
	}
	popcontext();

	objects[objindex]->textstart = textsize;
	objects[objindex]->datastart = datasize;
	objects[objindex]->bssstart = bsssize;

	objects[objindex]->text = (Uint32 *) Emalloc(objects[objindex]->s_text * sizeof(Uint32));
	objects[objindex]->data = (Uint32 *) Emalloc(objects[objindex]->s_data * sizeof(Uint32));

	pushcontext(_("Reading text and data segments"));
	for (i = 0; i < objects[objindex]->s_text; i++) {
		objects[objindex]->text[i] = readword(f);
	}

	for (i = 0; i < objects[objindex]->s_data; i++) {
		objects[objindex]->data[i] = readword(f);
	}
	popcontext();
	fclose(f);

	textsize += objects[objindex]->s_text;
	datasize += objects[objindex]->s_data;
	bsssize += objects[objindex]->s_bss;

	objindex++;
	popcontext();
}

/* Simplification de vie... */

static void dumptab(Uint32 * tab, int s, FILE * f)
{
	int i;

	for (i = 0; i < s; i++) {
		writeword(tab[i], f);
	}
}

/* Nous dumpons la mémoire dans le fichier */

static void dumptext(object_t * obj, FILE * f)
{
	dumptab(obj->text, obj->s_text, f);
}

static void dumpdata(object_t * obj, FILE * f)
{
	dumptab(obj->data, obj->s_data, f);
}

/* Cette fonction va calculer les quelques relogements statiques et dynamiques que nous a laissé l'assembleur */

static void dumprelog(FILE * f)
{
	symbol_t *s = symbols, *t;
	char trouve, err[BUFSIZ];
	Uint32 decal;

	for (s = s->next; s; s = s->next) {
		if (s->type & 1) {
			t = (symbol_t *) NomVarToVar(s->name, symbs, &trouve);
			if (!trouve) {
				sprintf(err, _("Symbol %s not found"), s->name);
				exception(1, err);
			}
			switch (s->type) {
			case 1:	/* text */
				switch (t->type) {
				case 0:
					decal = objects[t->objindex]->textstart + t->offset;
					break;
				case 2:
					decal = textsize + objects[t->objindex]->datastart + t->offset;
					break;
				case 4:
					decal = textsize + datasize + objects[t->objindex]->bssstart + t->offset;
					break;
				default:
					exception(1, _("Internal error"));
					break;
				}
#ifdef DEBUG
				fprintf(stderr, "Relogement effectué sur %i (text), de %i octets pour le symbole %s\n",
					s->offset, decal, s->name);
#endif
				objects[s->objindex]->text[s->offset] += decal;
				writeword(objects[s->objindex]->textstart + s->offset, f);
				break;
			case 3:	/* data */
				switch (t->type) {
				case 0:
					decal = objects[t->objindex]->textstart + t->offset;
					break;
				case 2:
					decal = textsize + objects[t->objindex]->datastart + t->offset;
					break;
				case 4:
					decal = textsize + datasize + objects[t->objindex]->bssstart + t->offset;
					break;
				default:
					exception(1, _("Internal error"));
					break;
				}
#ifdef DEBUG
				fprintf(stderr, "Relogement effectué sur %i (data), de %i octets pour le symbole %s\n",
					s->offset, decal, s->name);
#endif
				objects[s->objindex]->data[s->offset] += decal;
				writeword(textsize + objects[s->objindex]->datastart + s->offset, f);
				break;
			default:
				exception(1, _("Internal error"));
				break;
			}
		}
	}
}

/* Cette fonction sert à écrire le fichier de sortie. */

void dumpfile(char *nom)
{
	FILE *f;
	int i;

	pushcontext(_("Writing output file"));
	f = openfilewriting(nom);

	if (startpoint == -1) {
		exception(1, _("No startpoint defined."));
	}

	pushcontext(_("Writing headers"));
	writeword(0x58454e4e, f);
	writeword(nbrsymbs + textsize + datasize + 7, f);
	writeword(startpoint, f);
	writeword(textsize, f);
	writeword(datasize, f);
	writeword(bsssize, f);
	writeword(nbrsymbs, f);
	popcontext();
	pushcontext(_("Writing relocating informations"));
	dumprelog(f);
	popcontext();
	pushcontext(_("Writing text segments"));
	for (i = 0; i < objindex; i++) {
		dumptext(objects[i], f);
	}
	popcontext();
	pushcontext(_("Writing data segments"));
	for (i = 0; i < objindex; i++) {
		dumpdata(objects[i], f);
	}
	popcontext();

	popcontext();
	fprintf(stderr, _("Statistics: %i words of text, %i words of data and reserving %i words\n"), textsize,
		datasize, bsssize);
	fprintf(stderr, _("Output file size: %i words containing %i relocating offsets.\n"), ftell(f), nbrsymbs);
	fclose(f);
}

/* Fonctions d'initialisations et de libération de mémoire */

void init(int n)
{
	int i;

	Initialise(&symbs);

	objects = (object_t **) Emalloc(n * sizeof(object_t *));
	psymbols = symbols = (symbol_t *) Emalloc(sizeof(symbol_t));

	for (i = 0; i < n; i++) {
		objects[i] = (object_t *) Emalloc(sizeof(object_t));
		objects[i]->s_text = objects[i]->s_data = objects[i]->s_bss = objects[i]->textstart =
			objects[i]->datastart = 0;
		objects[i]->text = objects[i]->data = NULL;
	}

	symbols->next = NULL;
}

void free_symbol(symbol_t * s)
{
	if (s->next)
		free_symbol(s);

	free(s->name);
	free(s);
}

void flush(void)
{
	int i;

	DetruitTab(&symbs);

	for (i = 0; i < objindex; i++) {
		if (objects[i]->text)
			free(objects[i]->text);
		if (objects[i]->data) ;
		free(objects[i]->data);
		free(objects[i]);
	}
	free(objects);
}