# Author: L.J. Bekema @ VU Informatica, Amsterdam
#
-.SUFFIXES: .c,v .h .h,v
-
-.c,v.o:
- co -q $*.c
- $(CC) $(CFLAGS) -c $*.c
- rm -f $*.c
-
-.h,v.h:
- co -q $*.h
-
# Definitions for the making programs.
-LIBDIR=../../lib
-PREFLAGS= -DNDEBUG -DNASSERT
-CFLAGS = -O $(PREFLAGS)
+EM = ../..
+LIBDIR= $(EM)/lib
+PREFLAGS= -I$(EM)/h -DNDEBUG -DNASSERT
+CFLAGS = $(PREFLAGS) -O
LDFLAGS =
-LINTFLAGS=-phbxac $(PREFLAGS)
+LDLIBS = $(EM)/modules/lib/libstr.a $(EM)/modules/lib/libobj.a
+LINTFLAGS=-phbxa $(PREFLAGS)
PR = pr
PRFLAGS =
# Some convenient macro definitions.
-CFILES = archive.c byte_order.c error.c extract.c finish.c main.c memory.c\
+CFILES = archive.c error.c extract.c finish.c main.c memory.c\
output.c read.c relocate.c save.c scan.c sym.c write.c
-CVFILES = archive.c,v byte_order.c,v error.c,v extract.c,v finish.c,v main.c,v\
- memory.c,v output.c,v read.c,v relocate.c,v save.c,v scan.c,v\
- sym.c,v write.c,v
HFILES = assert.h const.h debug.h defs.h memory.h orig.h scan.h
-HVFILES = assert.h,v const.h,v debug.h,v defs.h,v memory.h,v orig.h,v scan.h,v
-OFILES = archive.o byte_order.o error.o extract.o finish.o main.o memory.o\
+OFILES = archive.o error.o extract.o finish.o main.o memory.o\
output.o read.o relocate.o save.o scan.o sym.o write.o
# Things that can be made.
led: $(OFILES)
$(CC) $(LDFLAGS) $(OFILES) $(LDLIBS) -o led
-mach.c: mach.c,v
- co -q mach.c
-
install:led
cp led $(LIBDIR)/em_led
cmp led $(LIBDIR)/em_led
lint:
- -for i in $(CFILES) $(HFILES) mach.c; do\
- if test ! -f $$i; then\
- echo $$i >> checked.out;\
- co -q $$i;\
- fi;\
- done
lint $(LINTFLAGS) $(CFILES)
- rm -f `cat checked.out` checked.out
-pr: $(CVFILES) $(HVFILES) mach.c
- @-for i in $?; do\
- co -q -p $$i | $(PR) $(PRFLAGS) -h `basename $$i ,v`;\
- done
+pr: $(CFILES) $(HFILES) mach.c
+ $(PR) $(PRFLAGS) $?
@touch pr
opr:
make pr | opr
clean:
- rm *.o led
+ rm -f Out *.o led nohup.out
depend:
- -for i in $(CFILES); do\
- if test ! -f $$i; then\
- echo $$i >> checked.out;\
- co -q $$i;\
- fi;\
- done
makedepend $(CFILES)
- rm -f `cat checked.out` checked.out
# The next lines are generated automatically.
# AUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTO
-archive.o: ../../h/arch.h
-archive.o: ../../h/out.h
-archive.o: ../../h/ranlib.h
archive.o: const.h
archive.o: debug.h
archive.o: defs.h
archive.o: memory.h
-byte_order.o: assert.h
-byte_order.o: const.h
-error.o: ../../h/out.h
error.o: const.h
-extract.o: ../../h/out.h
extract.o: const.h
extract.o: debug.h
extract.o: defs.h
extract.o: memory.h
extract.o: orig.h
extract.o: scan.h
-finish.o: ../../h/out.h
finish.o: const.h
finish.o: defs.h
finish.o: memory.h
finish.o: orig.h
finish.o: scan.h
-main.o: ../../h/out.h
main.o: const.h
main.o: debug.h
main.o: defs.h
main.o: memory.h
main.o: orig.h
-memory.o: ../../h/out.h
memory.o: assert.h
memory.o: const.h
memory.o: debug.h
memory.o: mach.c
memory.o: memory.h
-output.o: ../../h/out.h
output.o: const.h
output.o: memory.h
-read.o: ../../h/arch.h
-read.o: ../../h/out.h
-read.o: ../../h/ranlib.h
read.o: assert.h
read.o: const.h
-relocate.o: ../../h/out.h
relocate.o: const.h
relocate.o: debug.h
relocate.o: defs.h
relocate.o: orig.h
-save.o: ../../h/arch.h
-save.o: ../../h/out.h
save.o: assert.h
save.o: const.h
save.o: memory.h
-scan.o: ../../h/arch.h
-scan.o: ../../h/out.h
-scan.o: ../../h/ranlib.h
scan.o: assert.h
scan.o: const.h
scan.o: memory.h
scan.o: scan.h
-sym.o: ../../h/out.h
sym.o: const.h
sym.o: memory.h
-write.o: ../../h/out.h
write.o: assert.h
write.o: const.h
write.o: memory.h
This file contains a summary of the bugs/features/inconsistencies
Robbert and Ed found while making the linker usable for the 68000 and amoeba.
+I (Ceriel Jacobs) took the liberty of removing the ones that I fixed from
+this list.
-There is something wrong with the way the combination of
-assembler and linker handle bss.
-In the original (Duk's) the assembler translated .space and, worse, .align
-to a sequence of zero's. If this sequence was at the end of a segment
-within a module the assembler didn't put zero in the segment but sets
-os_flen to the amount of space initialized before the zero space
-and os_size to the segements size. (os_size - os_flen) is then the
-size of the space filled by zeroes.
-For the sake of clarity, let us call 0...os_flen-1 initialized space
-and os_flen..os_size-1 uninitialized space.
-Now the linker, it does a nasty trick. It gathers the uninitialized space
-of all modules within a segment and puts it consequtively at the end
-of the segment. I think that I understand the reason: This way you can keep
-your resultant a.out smaller and you don't need a special bss segment
-(a la unix). But it is incorrect, the net effect is that the .align's
-at the end of segments within a module do have the desired effect,
-the space thus allocated is removed to 'higher spheres' thereby
-leaving the first items of that segment in the inmediatly following
-modules at unaligned boundaries.
-What should be done is that the linker leaves the initialized and
-the unitialized code alone and regards the whole a a chunk that can be
-relocated. Only producing a difference of os_size and os_flen for
-the zeroes at the very end of the segment. Thereby collapsing all
-.space (and .align) commands into zero space only if they
-are in consequtive modules at the end of the segment, with modules
-NOT containing any initialized data.
-I already, ad-hoc, changed the code of the assembler to producing 'hard'
-zeroes when aligning. The trick could also be done for .space
-but is a bit harder here.
-The reason: .space is also used to allocate space in the BSS segment
-if that produced zeroes in the a.out file (0..bss_size) we would
-have a.out files that are far too large.
-This feature of the linker also caused weird effects for names that
-are defined as the very last in a section within a module, without
-any data (initialized or uninitialezed) after it.
-The names a regarded as pointing into the uninitialized space and
-thus relocated to the end of the section.
-The sequence
- .sect .data
-begdata:
- .sect ....
-in an head_em.s resulted in the relocation of begdata to the END
-of the .data segment.
Another problem form the commons:
1 - Local commons are not handled by led and not produced by as.
- using .comm for unitialized data is not correct because (from C)
- two uninitialized static declarations for the same name in
- different modules will be handled as external commons and thus
- be overlayed.
+ Must, and will be handled by as.
2 - The commons are allocated at the very end of the first pass, after the
initialezed data has been allocated in the segments. The order on which
the commons are allocated seems to be random. That way it is impossible
with incorrect ranlib entries.
The major troublemaker seems to be the extra padding byte at the end
of odd sized modules.
-
-Led should return a non-zero value when it has found Undefined symbols
-or has another reason for not being able to produce a correct output file.
static char rcsid[] = "$Header$";
#endif
-#include "../../h/arch.h"
-#include "../../h/out.h"
-#include "../../h/ranlib.h"
+#include <arch.h>
+#include <out.h>
+#include <ranlib.h>
#include "const.h"
#include "debug.h"
#include "defs.h"
register struct ranlib *ran;
register long count;
register long nran, nchar;
- extern long getlong();
+ extern long rd_long();
+ extern int infile;
- count = nran = getlong();
+ count = nran = rd_long(infile);
debug("%ld ranlib structs, ", nran, 0, 0, 0);
off = hard_alloc(ALLORANL, nran * sizeof(struct ranlib));
if (off == BADOFF)
fatal("no space for ranlib structs");
ran = (struct ranlib *)address(ALLORANL, off);
- read_table(ran, count);
- nchar = getlong();
+ rd_ranlib(infile, ran, count);
+ nchar = rd_long(infile);
debug("%ld ranlib chars\n", nchar, 0, 0, 0);
if ((off = hard_alloc(ALLORANL, nchar)) == BADOFF)
fatal("no space for ranlib strings");
- read_char(address(ALLORANL, off), nchar);
+ rd_bytes(infile, address(ALLORANL, off), nchar);
ran = (struct ranlib *)address(ALLORANL, (ind_t)0);
while (count--) {
/*
}
extern char *modulname;
-extern long position;
/*
* Process archive with table of contents. The table of contents tells
get_archive_header(&arhdr);
modulname = arhdr.ar_name;
debug("%s defines %s\n", modulname, string, 0, 0);
- position = ran->ran_pos + AR_SIZE;
resolved = TRUE;
/*
* This archive member is going to be linked,
get_archive_header(&arhdr);
modulname = arhdr.ar_name;
debug("%s: archive member\n", modulname, 0, 0, 0);
- position = *pos + AR_SIZE;
finish();
}
localpos += sizeof(long); /* Skip ENDLIB. */
#define FALSE 0
#define TRUE 1
-#define S_ZER 0x2000 /* Internal use only. */
-
#define WIDTH 8 /* Number of bits in a byte. */
#define BYTEMASK 0xFF /* Mask to get low order byte. */
-#define MININT (1 << (sizeof(int) * WIDTH - 1))
-#define MAXCHUNK (-(MININT + 1)) /* Highest count we write(2). */
#define RFLAG 0x01 /* -r flag given. */
#define SFLAG 0x02 /* -s flag given. */
-#define MAXSECT 64 /* Maximum number of sections. */
-
#define PLAIN 0 /* Input file is a normal file. */
#define ARCHIVE 1 /* Input file is an archive. */
#ifdef NDEBUG
-#define debug(s, a1, a2, a3, a4) dummy()
+#define debug(s, a1, a2, a3, a4)
#else
+extern int DEB;
-#define debug(s, a1, a2, a3, a4) printf(s, a1, a2, a3, a4)
+#define debug(s, a1, a2, a3, a4) (DEB && printf(s, a1, a2, a3, a4))
#endif
#include <stdio.h>
#include <signal.h>
-#include "../../h/out.h"
+#include <out.h>
#include "const.h"
static short nerrors = 0;
stop()
{
extern char *outputname;
+ extern int exitstatus;
- if (nerrors)
+ if (nerrors) {
unlink(outputname);
+ exit(nerrors);
+ }
- exit(nerrors);
+ exit(exitstatus);
}
trap_signals()
static char rcsid[] = "$Header$";
#endif
-#include "../../h/out.h"
+#include <out.h>
#include "const.h"
#include "debug.h"
#include "defs.h"
register struct outhead *head;
{
register int nnames;
- register ind_t sectindex, nameindex, charindex;
+ register ind_t nameindex, charindex;
register ind_t charoff;
extern int flagword;
nnames = head->oh_nname;
- sectindex = IND_SECT(*head);
nameindex = IND_NAME(*head);
charindex = IND_CHAR(*head);
charoff = OFF_CHAR(*head);
while (nnames--) {
- register struct outsect *sects;
struct outname name; /* A local copy. */
/*
* Because savelocal/getexternal might relocate the modules
* we have to compute the core addresses again.
*/
- sects = (struct outsect *)modulptr(sectindex);
name = *(struct outname *)modulptr(nameindex);
/*
* Change the offset in file into an offset in the memory area.
*/
if (name.on_foff)
name.on_foff += charindex - charoff;
- namerelocate(&name, sects);
+ namerelocate(&name);
if (name.on_type & S_EXT) {
getexternal(&name);
} else {
nsect = head->oh_nsect;
outsp = outsect;
while (nsect--) {
+ if (sects->os_flen) {
+ /* contains non-zero stuff */
+ outsp->os_flen = outsp->os_size + sects->os_flen;
+ }
+ else {
+ outsp->os_flen += sects->os_flen;
+ }
outsp->os_size += sects->os_size;
- outsp->os_flen += sects->os_flen;
/*
* Add all flen's and all (size - flen == zero)'s of
* preceding sections with the same number.
*/
- orig->org_flen += sects->os_flen;
- orig->org_zero += sects->os_size - sects->os_flen;
+ orig->org_size = outsp->os_size;
orig++; outsp++; sects++;
}
}
* Add relocation constant for names in user defined sections.
* The value of a common name indicates a size instead of an offset,
* and hence shouldn't be relocated.
- * The value of a name in the zero part of a section is relative from the
- * beginning of the section, not from the beginning of the zero part; but
- * all zero parts will be put after the normal section contents, so we
- * must subtract the flen of its section from the value (and later on add
- * the total flen of its section) and add the accumulated size of all
- * zero parts in preceding sections with the same number.
* Otherwise we just add the accumulated size of all normal parts in preceding
* sections with the same size.
*/
-namerelocate(name, sects)
+namerelocate(name)
register struct outname *name;
- struct outsect *sects;
{
register int type = name->on_type;
- register int sectindex;
if ((type & S_TYP) == S_UND || (type & S_TYP) == S_ABS)
return;
return;
}
- sectindex = (type & S_TYP) - S_MIN;
- if (name->on_valu >= sects[sectindex].os_flen) {
- name->on_type |= S_ZER;
- name->on_valu -= sects[sectindex].os_flen;
- name->on_valu += relorig[sectindex].org_zero;
- } else {
- name->on_valu += relorig[sectindex].org_flen;
- }
+ name->on_valu += relorig[(type & S_TYP) - S_MIN].org_size;
}
/*
static char rcsid[] = "$Header$";
#endif
-#include "../../h/out.h"
+#include <out.h>
#include "const.h"
#include "defs.h"
#include "memory.h"
adjust_names(names, head, chars);
handle_relos(head, sects, names);
if (!incore && !(flagword & SFLAG)) {
- put_locals(names, head->oh_nname, sects);
+ put_locals(names, head->oh_nname);
#ifdef SYMDBUG
put_dbug(OFF_DBUG(*head));
#endif SYMDBUG
register char *emit;
extern char *getemit();
extern struct outrelo *nextrelo();
+ static long zeros[MAXSECT];
if (incore) {
nrelo = head->oh_nrelo; sectindex = -1;
sectindex = relo->or_sect - S_MIN;
emit = getemit(head, sects, sectindex);
}
- relocate(head, emit, names, relo, sects);
+ relocate(head, emit, names, relo);
relo++;
}
} else {
while (nrelo--) {
relo = nextrelo();
if (relo->or_sect - S_MIN == sectindex) {
- relocate(head,emit,names,relo,sects);
+ relocate(head,emit,names,relo);
/*
* Write out the (probably changed)
* relocation information.
*/
if (flagword & RFLAG)
- wrt_relo(relo);
+ wr_relo(relo, 1);
}
}
- wrt_emit(emit, sectindex, sects[sectindex].os_flen);
+ if (sects[sectindex].os_flen) {
+ wrt_nulls(sectindex, zeros[sectindex]);
+ zeros[sectindex] = 0;
+ wrt_emit(emit, sectindex, sects[sectindex].os_flen);
+ }
+ zeros[sectindex] += sects[sectindex].os_size -
+ sects[sectindex].os_flen;
/*
* XXX We should be able to free the emitted bytes.
*/
* Write out the local names that must be saved.
*/
static
-put_locals(name, nnames, sects)
+put_locals(name, nnames)
register struct outname *name;
register ushort nnames;
- register struct outsect *sects;
{
while (nnames--) {
if ((name->on_type & S_EXT) == 0 && mustsavelocal(name)) {
- namerelocate(name, sects);
+ namerelocate(name);
addbase(name);
wrt_name(name);
}
register struct orig *orig = relorig;
while (nsect--) {
- orig->org_flen += sect->os_flen;
- orig->org_zero += sect->os_size - sect->os_flen;
+
+ orig->org_size += sect->os_size;
orig++; sect++;
}
}
register int nbytes;
register long dbugsize;
extern long objectsize;
- extern long position;
dbugsize = objectsize - offdbug;
- seek(position + offdbug);
while (dbugsize) {
nbytes = dbugsize > 512 ? 512 : dbugsize;
- read_char(buf, (long)nbytes);
- wrt_dbug(buf, nbytes);
+ rd_dbug(buf, (long)nbytes);
+ wr_dbug(buf, (long) nbytes);
dbugsize -= nbytes;
}
}
*/
#include <stdio.h>
-#include "../../h/out.h"
+#include <out.h>
#include "const.h"
#include "debug.h"
#include "defs.h"
#include "orig.h"
extern bool incore;
+#ifndef NDEBUG
+int DEB = 0;
+#endif
static initializations();
static first_pass();
progname = argv[0];
passnumber = FIRST;
- determine_ordering();
init_core();
init_symboltable();
outhead.oh_magic = O_MAGIC;
int flagword = 0; /* To store command-line options. */
char *outputname = "a.out"; /* Name of the resulting object file. */
+int exitstatus = 0;
/*
* Scan the arguments.
int sectno;
int h;
extern int atoi();
- extern char *index();
+ extern char *strindex();
extern int hash();
extern struct outname *searchname();
* section <section number>.
*/
sectno = atoi(++argp);
- if ((argp = index(argp, ':')) == (char *)0)
+ if ((argp = strindex(argp, ':')) == (char *)0)
fatal("usage: -a<section number>:<alignment>");
setlign(sectno, number(++argp));
break;
* <section number>.
*/
sectno = atoi(++argp);
- if ((argp = index(argp, ':')) == (char *)0)
+ if ((argp = strindex(argp, ':')) == (char *)0)
fatal("usage: -b<section number>:<base>");
setbase(sectno, number(++argp));
break;
+#ifndef NDEBUG
+ case 'd':
+ DEB = 1;
+ break;
+#endif
case 'o':
/*
* The `name' argument after -o is used as name
static
evaluate()
{
- if (!(flagword & RFLAG))
- norm_commons();
+ norm_commons();
complete_sections();
if (!(flagword & RFLAG))
change_names();
* Sect_comm[N] is the number of common bytes in section N.
* It is computed after pass 1.
*/
-static long sect_comm[MAXSECT];
+long sect_comm[MAXSECT];
/*
* If there are undefined names, we print them and we set a flag so that
if (ISUNDEFINED(name)) {
if (!und) {
und = TRUE;
+ if (!(flagword & RFLAG)) {
+ exitstatus = 1;
+ fprintf(stderr, "Undefined:\n");
+ }
outhead.oh_flags |= HF_LINK;
+ if (flagword & RFLAG) break;
flagword = (flagword & ~SFLAG) | RFLAG;
- fprintf(stderr, "Undefined:\n");
}
fprintf(stderr, "\t%s\n",
address(ALLOGCHR, (ind_t)name->on_foff)
foff = SZ_HEAD + outhead.oh_nsect * SZ_SECT;
for (sectindex = 0; sectindex < outhead.oh_nsect; sectindex++) {
- relorig[sectindex].org_flen = (long)0;
- relorig[sectindex].org_zero = (long)0;
+ relorig[sectindex].org_size = (long)0;
outsect[sectindex].os_foff = foff;
foff += outsect[sectindex].os_flen;
}
/*
- * Add the base of the section of a name to its value. For a name in the zero
- * part, the size of the normal part is also a "base".
+ * Add the base of the section of a name to its value.
*/
addbase(name)
struct outname *name;
if (name->on_type & S_COM)
return;
- if (name->on_type & S_ZER) {
- name->on_valu += outsect[sectindex].os_flen;
- name->on_type &= ~S_ZER;
- }
name->on_valu += outsect[sectindex].os_base;
debug( "%s: type 0x%x, value %ld\n",
address((name->on_type & S_EXT) ? ALLOGCHR : ALLOLCHR,
}
closefile(file);
}
-
-#ifdef NDEBUG
-
-dummy() { ; }
-
-#endif
* is done and pieces after the one that requested the growth are moved up.
*/
-#include "../../h/out.h"
+#include <out.h>
#include "const.h"
#include "assert.h"
#include "debug.h"
static copy_up();
static free_saved_moduls();
static writelong();
-static sectswap();
-static reloswap();
static namecpy();
struct memory mems[NMEMS];
*/
ind_t
alloc(piece, size)
- register int piece;
+ int piece;
register long size;
{
register ind_t incr = 0;
- register ind_t left = mems[piece].mem_left;
+ ind_t left = mems[piece].mem_left;
register ind_t full = mems[piece].mem_full;
assert(passnumber == FIRST || (!incore && piece == ALLOMODL));
/* ------------------------------------------------------------------------- */
-extern bool bytes_reversed;
-extern bool words_reversed;
-
/*
* To transform the various pieces of the output in core to the file format,
* we must order the bytes in the ushorts and longs as ACK prescribes.
*/
write_bytes()
{
- ushort nsect, nrelo;
+ ushort nsect;
long offchar;
- int fd;
register struct memory *mem;
extern ushort NLocals, NGlobals;
extern long NLChars, NGChars;
extern struct outhead outhead;
extern struct outsect outsect[];
extern char *outputname;
+ int sectionno = 0;
nsect = outhead.oh_nsect;
- nrelo = outhead.oh_nrelo;
offchar = OFF_CHAR(outhead);
- if (bytes_reversed || words_reversed) {
- swap((char *)&outhead, SF_HEAD);
- sectswap(outsect, nsect);
- reloswap(nrelo);
- }
/*
* We allocated two areas: one for local and one for global names.
* Also, we used another kind of on_foff than on file.
offchar + NLChars
);
}
- if ((fd = creat(outputname, 0666)) < 0)
+ if (! wr_open(outputname)) {
fatal("can't create %s", outputname);
+ }
/*
* These pieces must always be written.
*/
- writelong(fd, (char *)&outhead, (ind_t)SZ_HEAD);
- writelong(fd, (char *)outsect, (ind_t)nsect * SZ_SECT);
+ wr_ohead(&outhead);
+ wr_sect(outsect, nsect);
for (mem = &mems[ALLOEMIT]; mem < &mems[ALLORELO]; mem++)
- writelong(fd, mem->mem_base, mem->mem_full);
+ wrt_emit(mem->mem_base, sectionno++, mem->mem_full);
/*
* The rest depends on the flags.
*/
if (flagword & RFLAG)
- writelong(fd, mems[ALLORELO].mem_base, mems[ALLORELO].mem_full);
+ wr_relo((struct outrelo *) mems[ALLORELO].mem_base,
+ outhead.oh_nrelo);
if (!(flagword & SFLAG)) {
- writelong(fd, mems[ALLOLOCL].mem_base, mems[ALLOLOCL].mem_full);
- writelong(fd, mems[ALLOGLOB].mem_base, mems[ALLOGLOB].mem_full);
- writelong(fd, mems[ALLOLCHR].mem_base + 1, (ind_t)NLChars);
- writelong(fd, mems[ALLOGCHR].mem_base + 1, (ind_t)NGChars);
+ wr_name((struct outname *) mems[ALLOLOCL].mem_base,
+ NLocals);
+ wr_name((struct outname *) mems[ALLOGLOB].mem_base,
+ NGlobals+nsect);
+ wr_string(mems[ALLOLCHR].mem_base + 1, (long)NLChars);
+ wr_string(mems[ALLOGCHR].mem_base + 1, (long)NGChars);
#ifdef SYMDBUG
- writelong(fd, mems[ALLODBUG].mem_base, mems[ALLODBUG].mem_full);
+ wr_dbug(mems[ALLODBUG].mem_base, mems[ALLODBUG].mem_full);
#endif SYMDBUG
}
- close(fd);
-}
-
-static
-writelong(fd, base, size)
- register int fd;
- register char *base;
- register ind_t size;
-{
- register int chunk;
-
- while (size) {
- chunk = size > (ind_t)MAXCHUNK ? MAXCHUNK : size;
- write(fd, base, chunk);
- size -= chunk;
- base += chunk;
- }
-}
-
-static
-sectswap(sect, nsect)
- register struct outsect *sect;
- register ushort nsect;
-{
- while (nsect--)
- swap((char *)sect++, SF_SECT);
-}
-
-static
-reloswap(nrelo)
- register ushort nrelo;
-{
- register struct outrelo *relo;
-
- relo = (struct outrelo *)mems[ALLORELO].mem_base;
- while (nrelo--)
- swap((char *)relo++, SF_RELO);
+ wr_close();
}
static
while (nname--) {
if (name->on_foff)
name->on_foff += offchar - 1;
- if (bytes_reversed || words_reversed)
- swap((char *)name, SF_NAME);
name++;
}
}
/* $Header$ */
struct orig {
- long org_flen; /* Accumulated length of preceding sections. */
- long org_zero; /* " " " zeroparts. */
+ long org_size; /* Accumulated length of preceding sections. */
};
static char rcsid[] = "$Header$";
#endif
-#include "../../h/out.h"
+#include <out.h>
#include "const.h"
#include "memory.h"
static char rcsid[] = "$Header$";
#endif
-/*
- * Routines to read in the various parts of the object file.
- */
-
-#include "../../h/arch.h"
-#include "../../h/out.h"
-#include "../../h/ranlib.h"
-#include "const.h"
-#include "assert.h"
-
int infile; /* The current input file. */
-extern bool bytes_reversed;
-extern bool words_reversed;
-
-ushort
-getushort()
-{
- ushort ubuf;
-
- if (read(infile, (char *)&ubuf, 2) != 2)
- fatal("premature EOF");
- if (bytes_reversed)
- swap((char *)&ubuf, "2");
- return ubuf;
-}
-
-long
-getlong()
-{
- long lbuf;
-
- if (read(infile, (char *)&lbuf, 4) != 4)
- fatal("premature EOF");
- if (bytes_reversed || words_reversed)
- swap((char *)&lbuf, "4");
- return lbuf;
-}
-
-read_head(head)
- register struct outhead *head;
-{
- if (read(infile, (char *)head, SZ_HEAD) != SZ_HEAD)
- fatal("premature EOF");
- if (bytes_reversed || words_reversed)
- swap((char *)head, SF_HEAD);
- if (BADMAGIC(*head))
- fatal("bad magic number");
-}
-
-read1(fd, val)
-char *val ; {
- if ( read(fd, val, 1)!=1 ) return 0 ;
- return 1 ;
-}
-read2(fd, val)
-int *val ; {
- char rch[2] ;
- if ( read(fd, rch, 2)!=2 ) return 0 ;
- *val= (rch[0]&0377) + ((rch[1]&0377)<<8) ;
- return 1 ;
-}
-read4(fd, val)
-long *val ; {
- int v1,v2 ;
- if ( !read2(fd, &v1) ) return 0 ;
- if ( !read2(fd, &v2) ) return 0 ;
- *val = ((long)v1<<16) + (unsigned)v2 ;
- return 1 ;
-}
-
-
-read_arhdr(arhdr)
- register struct ar_hdr *arhdr;
+rd_fatal()
{
- if ( read(infile,arhdr->ar_name,sizeof arhdr->ar_name)!=
- sizeof arhdr->ar_name) {
- goto peof ;
- }
- if ( !read4(infile,&arhdr->ar_date) ) goto peof ;
- if ( !read1(infile,&arhdr->ar_uid) ) goto peof ;
- if ( !read1(infile,&arhdr->ar_gid) ) goto peof ;
- if ( !read2(infile,&arhdr->ar_mode) ) goto peof ;
- if ( !read4(infile,&arhdr->ar_size) ) goto peof ;
- return ;
-peof:
- fatal("Prematute EOF") ;
-}
-
-read_table(ran, cnt)
- register struct ranlib *ran;
- register long cnt;
-{
- read_char((char *)ran, cnt * SZ_RAN);
- if (bytes_reversed || words_reversed)
- while (cnt--)
- swap((char *)ran++, SF_RAN);
-}
-
-read_sect(sect, cnt)
- register struct outsect *sect;
- register ushort cnt;
-{
- if (read(infile, (char *)sect, cnt * SZ_SECT) != cnt * SZ_SECT)
- fatal("premature EOF");
- if (bytes_reversed || words_reversed)
- while (cnt--)
- swap((char *)sect++, SF_SECT);
-}
-
-read_emit(emit, cnt)
- register char *emit;
- register long cnt;
-{
- read_char(emit, cnt);
-}
-
-read_relo(relo, cnt)
- register struct outrelo *relo;
- register ushort cnt;
-{
- read_char((char *)relo, (long)cnt * SZ_RELO);
- if (bytes_reversed || words_reversed)
- while (cnt--)
- swap((char *)relo++, SF_RELO);
-}
-
-read_name(name, cnt)
- register struct outname *name;
- register ushort cnt;
-{
- read_char((char *)name, (long)cnt * SZ_NAME);
- if (bytes_reversed || words_reversed)
- while (cnt--)
- swap((char *)name++, SF_NAME);
-}
-
-/*
- * We don't have to worry about byte order here.
- */
-read_char(string, cnt)
- register char *string;
- register long cnt;
-{
- register int n;
-
- while (cnt) {
- n = cnt >= MAXCHUNK ? MAXCHUNK : cnt;
- if (read(infile, string, n) != n)
- fatal("premature EOF");
- string += n;
- cnt -= n;
- }
+ fatal("read error");
}
static char rcsid[] = "$Header$";
#endif
-#include "../../h/out.h"
+#include <out.h>
#include "const.h"
#include "debug.h"
#include "defs.h"
}
}
-/*
- * Returns whether `valu' refers to the zero part of its section.
- * The address of its zero part (relative to the beginning of the section)
- * is in `zero_addr'. If `valu' is used in a pc-relative address computation,
- * we have to do that computation ourselves. A pc-relative address is the
- * difference between the address of the byte after the value and the "real"
- * address:
- * referencing address + its size + pc-relative address == "real" address.
- */
-static bool
-refers_zero(valu, relo, zero_addr)
- register long valu;
- struct outrelo *relo;
- long zero_addr;
-{
- if (relo->or_type & RELPC) {
- valu += relo->or_addr;
- /*
- * Below is a dirty switch-statement. But an even dirtier
- * statement would be: valu += (relo->or_type & RELSZ),
- * because in that case you would have to know the values
- * of the RELO[124] symbols.
- */
- switch (relo->or_type & RELSZ) {
- case RELO4: valu += 1;
- valu += 1;
- case RELO2: valu += 1;
- case RELO1: valu += 1;
- }
- }
- return valu >= zero_addr;
-}
-
extern ushort NLocals, NGlobals;
extern struct outsect outsect[];
extern struct orig relorig[];
* in position of the section of local.
*/
static ushort
-addrelo(relo, names, sects, valu_out)
+addrelo(relo, names, valu_out)
struct outrelo *relo;
struct outname *names;
- struct outsect *sects;
long *valu_out; /* Out variable. */
{
register struct outname *local = &names[relo->or_nami];
if ((local->on_type & S_SCT)) {
register int sectindex = (local->on_type & S_TYP) - S_MIN;
- if (refers_zero(valu, relo, sects[sectindex].os_flen)) {
- valu -= sects[sectindex].os_flen;
- valu += outsect[sectindex].os_flen;
- valu += relorig[sectindex].org_zero;
- } else {
- valu += relorig[sectindex].org_flen;
- }
+ valu += relorig[sectindex].org_size;
valu += outsect[sectindex].os_base;
index += NGlobals + sectindex;
} else {
* which the header is pointed to by `head'. Relocation is relative to the
* names in `names'; `relo' tells how to relocate.
*/
-relocate(head, emit, names, relo, sects)
+relocate(head, emit, names, relo)
struct outhead *head;
char *emit;
struct outname names[];
struct outrelo *relo;
- struct outsect *sects;
{
long valu;
int sectindex = relo->or_sect - S_MIN;
*/
if (relo->or_nami < head->oh_nname) {
/* First two cases. */
- relo->or_nami = addrelo(relo, names, sects, &valu);
+ relo->or_nami = addrelo(relo, names, &valu);
} else {
/*
* Third case: it is absolute. The relocation of absolute
* the change in distance between the referencING and referencED
* section. We already added the origin of the referencED section;
* now we subtract the origin of the referencING section.
- * Note that the the value to be relocated cannot lie within the
- * zero part.
*/
if (relo->or_type & RELPC)
- valu -= relorig[sectindex].org_flen+outsect[sectindex].os_base;
+ valu -= relorig[sectindex].org_size+outsect[sectindex].os_base;
/*
* Now put the value back.
* relocated to its offset in the new section. `Or_addr' must again be
* in the normal part, of course.
*/
- relo->or_addr += relorig[sectindex].org_flen;
+ relo->or_addr += relorig[sectindex].org_size;
}
* If everything is kept in core, we must save some things for the second pass.
*/
-#include "../../h/arch.h"
-#include "../../h/out.h"
+#include <arch.h>
+#include <out.h>
#include "const.h"
#include "assert.h"
#include "memory.h"
#include <sys/types.h>
#include <sys/stat.h>
#endif SYMDBUG
-#include "../../h/arch.h"
-#include "../../h/out.h"
-#include "../../h/ranlib.h"
+#include <arch.h>
+#include <out.h>
+#include <ranlib.h>
#include "const.h"
#include "assert.h"
#include "memory.h"
#include "scan.h"
+#include "debug.h"
#define READ 0
char *archname; /* Name of archive, if reading from archive. */
char *modulname; /* Name of object module. */
-long position; /* Byte offset within cuurent input file. */
#ifdef SYMDBUG
long objectsize;
#endif SYMDBUG
struct stat statbuf;
extern int fstat();
#endif SYMDBUG
- extern ushort getushort();
archname = (char *)0;
modulname = (char *)0;
if (passnumber == FIRST || !incore) {
if ((infile = open(filename, READ)) < 0)
fatal("can't read %s", filename);
- magic_number = getushort();
+ magic_number = rd_unsigned2(infile);
} else {
modulbase = modulptr((ind_t)0);
magic_number = *(ushort *)modulbase;
objectsize = statbuf.st_size;
}
#endif SYMDBUG
- position = (long)0;
seek((long)0);
modulname = filename;
return PLAIN;
case AALMAG:
archname = filename;
if (passnumber == FIRST) {
- read_arhdr(&archive_header);
+ rd_arhdr(infile, &archive_header);
if (strcmp(archive_header.ar_name, SYMDEF))
fatal("no table of contents");
} else if (incore) {
register struct ar_hdr *archive_header;
{
if (passnumber == FIRST || !incore) {
- read_arhdr(archive_header);
+ rd_arhdr(infile, archive_header);
} else {
/* Copy structs. */
*archive_header = *(struct ar_hdr *)modulbase;
get_modul()
{
if (passnumber == FIRST) {
+ rd_fdopen(infile);
scan_modul();
} else if (!incore) {
+ rd_fdopen(infile);
read_modul();
}
}
if (space) {
sect = (struct outsect *)modulptr(IND_SECT(*head));
get_indirect(head, sect);
- } else {
- lseek(infile, OFF_NAME(*head) - OFF_EMIT(*head), 1);
}
- read_name((struct outname *)modulptr(IND_NAME(*head)), head->oh_nname);
- read_char((char *)modulptr(IND_CHAR(*head)), head->oh_nchar);
+ rd_name((struct outname *)modulptr(IND_NAME(*head)), head->oh_nname);
+ rd_string((char *)modulptr(IND_CHAR(*head)), head->oh_nchar);
#ifdef SYMDBUG
if (space) {
get_dbug(*(ind_t *)modulptr(IND_DBUG(*head)),
if (hard_alloc(ALLOMODL, (long)sizeof(struct outhead)) == BADOFF)
fatal("no space for module header");
- read_head((struct outhead *)modulptr(IND_HEAD));
+ rd_ohead((struct outhead *)modulptr(IND_HEAD));
/*
* Copy the header because we need it so often.
*/
size = modulsize(head) - sizeof(struct outhead) - rest;
if (hard_alloc(ALLOMODL, size) == BADOFF)
fatal("no space for module");
- read_sect((struct outsect *)modulptr(sectindex), nsect);
+ rd_sect((struct outsect *)modulptr(sectindex), nsect);
return incore && alloc(ALLOMODL, rest) != BADOFF;
}
long flen;
ind_t emitindex;
extern ind_t alloc();
+ static long zeros[MAXSECT];
+ register long zero = zeros[allopiece - ALLOEMIT];
+
+ /*
+ * Notice that "sectindex" is not a section number!
+ * It contains the offset of the section from the beginning
+ * of the module. Thus, it cannot be used to index "zeros".
+ * AIAIAIAIA
+ */
flen = ((struct outsect *)modulptr(sectindex))->os_flen;
+ if (flen && zero) {
+ if ((emitindex = alloc(allopiece, zero)) != BADOFF){
+ register char *p = address(allopiece, emitindex);
+
+ debug("Zeros %ld\n", zero, 0,0,0);
+ while (zero--) *p++ = 0;
+ }
+ else return FALSE;
+ }
+ zeros[allopiece - ALLOEMIT] =
+ ((struct outsect *) modulptr(sectindex))->os_size - flen;
if ((emitindex = alloc(allopiece, flen)) != BADOFF) {
*(ind_t *)modulptr(emitoff) = emitindex;
return TRUE;
ind_t *reloindex;
emitindex = (ind_t *)modulptr(IND_EMIT(*head));
- nsect = head->oh_nsect; piece = ALLOEMIT;
- while (nsect--) {
- read_emit(address(piece, *emitindex), sect->os_flen);
+ piece = ALLOEMIT;
+ for (nsect = 0; nsect < head->oh_nsect; nsect++) {
+ rd_outsect(nsect);
+ rd_emit(address(piece, *emitindex), sect->os_flen);
piece++; emitindex++; sect++;
}
reloindex = (ind_t *)modulptr(IND_RELO(*head));
- read_relo((struct outrelo *)address(ALLORELO, *reloindex),
+ rd_relo((struct outrelo *)address(ALLORELO, *reloindex),
head->oh_nrelo
);
}
ushort nsect, nname;
long size;
long nchar;
- long skip;
extern ind_t hard_alloc();
assert(passnumber == SECOND);
if (hard_alloc(ALLOMODL, (long)sizeof(struct outhead)) == BADOFF)
fatal("no space for module header");
head = (struct outhead *)modulptr(IND_HEAD);
- read_head(head);
+ rd_ohead(head);
nsect = head->oh_nsect; sectindex = IND_SECT(*head);
nname = head->oh_nname; nameindex = IND_NAME(*head);
nchar = head->oh_nchar; charindex = IND_CHAR(*head);
- skip = OFF_NAME(*head) - OFF_EMIT(*head);
#ifdef SYMDBUG
size = modulsize(head) - (nsect * sizeof(ind_t) + 2 * sizeof(ind_t));
#else SYMDBUG
names = (struct outname *)modulptr(nameindex);
chars = modulptr(charindex);
- read_sect(sects, nsect);
- lseek(infile, skip, 1);
- read_name(names, nname);
- read_char(chars, nchar);
+ rd_sect(sects, nsect);
+ rd_name(names, nname);
+ rd_string(chars, nchar);
}
/*
align(size)
register long size;
{
- size += sizeof(double) - 1;
- return size - (size & (sizeof(double) - 1));
+ return (size + (sizeof(double) - 1)) & ~(sizeof(double) - 1);
}
/*
if (incore) {
reloindex = *(ind_t *)(modulbase + IND_RELO(*head));
walkrelo = (struct outrelo *)address(ALLORELO, reloindex);
- } else
- lseek(infile, position + OFF_RELO(*head), 0);
+ }
}
struct outrelo *
if (incore)
return walkrelo++;
- read_relo(&relobuf, (ushort)1);
+ rd_relo(&relobuf, 1);
return &relobuf;
}
ret = core_alloc(ALLOMODL, sects[sectindex].os_flen);
if (ret == (char *)0)
fatal("no space for section contents");
- lseek(infile, position + sects[sectindex].os_foff, 0);
- read_emit(ret, sects[sectindex].os_flen);
+ rd_outsect(sectindex);
+ rd_emit(ret, sects[sectindex].os_flen);
return ret;
}
/*
* Symbol table management.
*/
-#include "../../h/out.h"
+#include <out.h>
#include "const.h"
#include "memory.h"
+#include "debug.h"
/*
* Symbol table types. Each hash table entry contains the offset of a symbol
register struct symbol *sym;
symindex = hashtable[hashval];
+ debug("looking for %s %d %ld:", string, hashval, hashtable[hashval], 0);
while (symindex != BADOFF) {
sym = (struct symbol *)address(ALLOSYMB, symindex);
name = (struct outname *)address(ALLOGLOB, sym->sy_name);
namestring = address(ALLOGCHR, (ind_t)name->on_foff);
rcp = string;
+ debug("comp %s;", namestring, 0, 0, 0);
while (*rcp == *namestring++)
- if (*rcp++ == '\0')
+ if (*rcp++ == '\0') {
+ debug("found %x, %x, %lx\n",
+ name->on_type, name->on_desc, name->on_valu, 0);
return name;
+ }
symindex = sym->sy_next;
}
/* Not found. */
+ debug("not found\n", 0, 0, 0, 0);
return (struct outname *)0;
}
ind_t savindex;
ind_t symindex;
ind_t namindex;
- struct symbol *sym;
+ register struct symbol *sym;
struct outname *newname;
extern ind_t savechar();
extern ind_t hard_alloc();
+ debug("entername %s %d %x %x", modulptr((ind_t)name->on_foff), hashval, name->on_type, name->on_desc);
savindex = savechar(ALLOGCHR, (ind_t)name->on_foff);
symindex = hard_alloc(ALLOSYMB, (long)sizeof(struct symbol));
+ debug("; %ld\n", symindex, 0, 0, 0);
namindex = hard_alloc(ALLOGLOB, (long)sizeof(struct outname));
if (savindex == BADOFF || symindex == BADOFF || namindex == BADOFF)
fatal("symbol table overflow");
static char rcsid[] = "$Header$";
#endif
-/*
- * You can choose between two strategies:
- * - Open the output file several times, once for each logical part, and
- * write to it in multiple places.
- * - Open the output file once and seek back and forth to each logical
- * part. In this case #define OUTSEEK.
- */
-
+#include <out.h>
#include <stdio.h>
-#include "../../h/out.h"
#include "const.h"
#include "assert.h"
#include "memory.h"
-#include "orig.h"
-
-static openoutput();
-static wrt_head();
-static wrt_sect();
-extern long lseek();
-
-#define WRITE 1 /* Argument to open(). */
-
-/*
- * Parts of the output file.
- */
-#define PARTEMIT 0
-#define PARTRELO 1
-#define PARTNAME 2
-#define PARTCHAR 3
-#ifdef SYMDBUG
-#define PARTDBUG 4
-#else SYMDBUG
-#define PARTDBUG PARTCHAR
-#endif SYMDBUG
-#define NPARTS (PARTDBUG + 1)
-
-/*
- * Call OUTPART() with the part you want to write on as argument, before
- * you call OUTWRITE().
- */
-static int outpart = NPARTS;
-
-#ifdef OUTSEEK
-
-static int outfile;
-static long outseek[NPARTS];
-
-#define OUTPART(p) \
- { if (outpart != (p)) {\
- outpart = (p);\
- lseek(outfile, outseek[(p)], 0);\
- }\
- }
-#define OUTSECT(i) \
- { outpart = NPARTS;\
- outseek[PARTEMIT] =\
- outsect[(i)].os_foff + relorig[(i)].org_flen;\
- }
-#define OUTWRITE(b, n) \
- { if (write(outfile, (b), (n)) != (n))\
- fatal("write error");\
- outseek[outpart] += (n);\
- }
-#define BEGINSEEK(p, o) \
- { outseek[(p)] = (o);\
- }
-
-#else OUTSEEK
-
-static int outfile[NPARTS];
-
-#define OUTPART(p) \
- { outpart = (p);\
- }
-#define OUTSECT(i) \
- { lseek( outfile[PARTEMIT],\
- outsect[(i)].os_foff + relorig[(i)].org_flen,\
- 0\
- );\
- }
-#define OUTWRITE(b, n) \
- { if (write(outfile[outpart], (b), (n)) != (n))\
- fatal("write error");\
- }
-#define BEGINSEEK(p, o) \
- { lseek(outfile[(p)], (o), 0);\
- }
-
-#endif OUTSEEK
extern struct outhead outhead;
extern struct outsect outsect[];
extern int flagword;
-extern struct orig relorig[];
-extern bool bytes_reversed, words_reversed;
extern bool incore;
+wr_fatal()
+{
+ fatal("write error");
+}
-static long offchar;
+static long off_char;
/*
* Open the output file according to the chosen strategy.
*/
begin_write()
{
- register long off;
-
- openoutput();
- BEGINSEEK(PARTEMIT, (long)0);
- wrt_head(&outhead);
- wrt_sect(outsect, outhead.oh_nsect);
+ extern char *outputname;
+ register struct outhead *hd = &outhead;
- off = SZ_HEAD + (long)outhead.oh_nsect * SZ_SECT + outhead.oh_nemit;
-
- if (flagword & RFLAG) {
- /* A relocation table will be produced. */
- BEGINSEEK(PARTRELO, off);
- off += (long)outhead.oh_nrelo * SZ_RELO;
+ assert(! incore);
+ if (! wr_open(outputname)) {
+ fatal("cannot write %s", outputname);
}
-
- if (flagword & SFLAG)
- return;
-
- /* A name table will be produced. */
- BEGINSEEK(PARTNAME, off);
- off += (long)outhead.oh_nname * SZ_NAME;
- BEGINSEEK(PARTCHAR, off);
- offchar = off; /* See wrt_name(). */
-#ifdef SYMDBUG
- off += outhead.oh_nchar;
- BEGINSEEK(PARTDBUG, off);
-#endif SYMDBUG
-}
-
-static
-openoutput()
-{
-#ifndef OUTSEEK
- register int *fdp;
-#endif OUTSEEK
- extern char *outputname;
-
- close(creat(outputname, 0666));
-#ifdef OUTSEEK
- if ((outfile = open(outputname, WRITE)) < 0)
- fatal("can't write %s", outputname);
-#else OUTSEEK
- for (fdp = &outfile[PARTEMIT]; fdp < &outfile[NPARTS]; fdp++)
- if ((*fdp = open(outputname, WRITE)) < 0)
- fatal("can't write %s", outputname);
-#endif OUTSEEK
+ wr_ohead(hd);
+ wr_sect(outsect, hd->oh_nsect);
+ off_char = OFF_CHAR(*hd);
}
static struct outname *
wrt_name(sectname(sectindex));
}
-static
-wrt_head(head)
- register struct outhead *head;
+wrt_emit(emit, sectindex, cnt)
+ char *emit;
+ int sectindex;
+ long cnt;
{
- assert(!incore);
- OUTPART(PARTEMIT);
- if (bytes_reversed || words_reversed)
- swap((char *)head, SF_HEAD);
- OUTWRITE((char *)head, SZ_HEAD);
- /*
- * Swap back because we will need it again.
- */
- if (bytes_reversed || words_reversed)
- swap((char *)head, SF_HEAD);
-}
-static
-wrt_sect(sect, cnt)
- register struct outsect *sect;
- register ushort cnt;
-{
- assert(!incore);
- OUTPART(PARTEMIT);
- while (cnt--) {
- if (bytes_reversed || words_reversed)
- swap((char *)sect, SF_SECT);
- OUTWRITE((char *)sect, SZ_SECT);
- /*
- * Swap back because we will need it again.
- */
- if (bytes_reversed || words_reversed)
- swap((char *)sect, SF_SECT);
- sect++;
- }
+ wr_outsect(sectindex);
+ wr_emit(emit, cnt);
}
-/*
- * We don't have to worry about byte order here.
- */
-wrt_emit(emit, sectindex, cnt)
- register char *emit;
- int sectindex;
- register long cnt;
+wrt_nulls(sectindex, cnt)
+ register long cnt;
{
- register int n;
+ static char nullbuf[BUFSIZ];
- assert(!incore);
- OUTPART(PARTEMIT);
- OUTSECT(sectindex);
+ wr_outsect(sectindex);
while (cnt) {
- n = cnt >= BUFSIZ ? BUFSIZ : cnt;
- OUTWRITE(emit, n);
- emit += n;
+ register int n = cnt >= BUFSIZ ? BUFSIZ : cnt;
+ wr_emit(nullbuf, (long)n);
cnt -= n;
}
}
-wrt_relo(relo)
- register struct outrelo *relo;
-{
- assert(!incore);
- assert(flagword & RFLAG);
- OUTPART(PARTRELO);
- if (bytes_reversed || words_reversed)
- swap((char *)relo, SF_RELO);
- OUTWRITE((char *)relo, SZ_RELO);
-}
-
wrt_name(name)
register struct outname *name;
{
assert(!incore);
assert(!(flagword & SFLAG));
if (name->on_mptr != (char *)0) {
- register int len = strlen(name->on_mptr) + 1;
+ register long len = strlen(name->on_mptr) + 1;
- OUTPART(PARTCHAR);
- OUTWRITE(name->on_mptr, len);
- name->on_foff = offchar;
- offchar += len;
+ wr_string(name->on_mptr, len);
+ name->on_foff = off_char;
+ off_char += len;
} else {
name->on_foff = (long)0;
}
- OUTPART(PARTNAME);
- if (bytes_reversed || words_reversed)
- swap((char *)name, SF_NAME);
- OUTWRITE((char *)name, SZ_NAME);
-}
-#ifdef SYMDBUG
-
-wrt_dbug(buf, size)
- char *buf;
- int size;
-{
- assert(!incore);
- assert(!(flagword & SFLAG));
- OUTPART(PARTDBUG);
- OUTWRITE((char *)buf, size);
+ wr_name(name, 1);
}
-#endif SYMDBUG
public / ack.git / commitdiff