code review 2587041: 5l, 6l, 8l: link pclntab and symtab as ordinary rodata ...

src/libmach/executable.c

 // Inferno libmach/executable.c
 // http://code.google.com/p/inferno-os/source/browse/utils/libmach/executable.c
 //
 //      Copyright © 1994-1999 Lucent Technologies Inc.
 //      Power PC support Copyright © 1995-2004 C H Forsyth (forsyth@terzarima.net).
 //      Portions Copyright © 1997-1999 Vita Nuova Limited.
 //      Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com).
 //      Revisions Copyright © 2000-2004 Lucent Technologies Inc. and others.
 //      Portions Copyright © 2009 The Go Authors.  All rights reserved.
 //
@@ skipping 48 matching lines @@
 static  int     nextboot(int, Fhdr*, ExecHdr*);
 static  int     sparcboot(int, Fhdr*, ExecHdr*);
 static  int     mipsboot(int, Fhdr*, ExecHdr*);
 static  int     mips4kboot(int, Fhdr*, ExecHdr*);
 static  int     common(int, Fhdr*, ExecHdr*);
 static  int     commonllp64(int, Fhdr*, ExecHdr*);
 static  int     adotout(int, Fhdr*, ExecHdr*);
 static  int     elfdotout(int, Fhdr*, ExecHdr*);
 static  int     machdotout(int, Fhdr*, ExecHdr*);
 static  int     armdotout(int, Fhdr*, ExecHdr*);
-static  void    setsym(Fhdr*, int32, int32, int32, vlong);
+static  void    setsym(Fhdr*, vlong, int32, vlong, int32, vlong, int32);
 static  void    setdata(Fhdr*, uvlong, int32, vlong, int32);
 static  void    settext(Fhdr*, uvlong, uvlong, int32, vlong);
 static  void    hswal(void*, int, uint32(*)(uint32));
 static  uvlong  _round(uvlong, uint32);
 
 /*
  *      definition of per-executable file type structures
  */
 
 typedef struct Exectable{
@@ skipping 340 matching lines @@
 adotout(int fd, Fhdr *fp, ExecHdr *hp)
 {
         int32 pgsize;
 
         USED(fd);
         pgsize = mach->pgsize;
         settext(fp, hp->e.exechdr.entry, pgsize+sizeof(Exec),
                         hp->e.exechdr.text, sizeof(Exec));
         setdata(fp, _round(pgsize+fp->txtsz+sizeof(Exec), pgsize),
                 hp->e.exechdr.data, fp->txtsz+sizeof(Exec), hp->e.exechdr.bss);
-        setsym(fp, hp->e.exechdr.syms, hp->e.exechdr.spsz, hp->e.exechdr.pcsz, fp->datoff+fp->datsz);
+        setsym(fp, fp->datoff+fp->datsz, hp->e.exechdr.syms, 0, hp->e.exechdr.spsz, 0, hp->e.exechdr.pcsz);
         return 1;
 }
 
 static void
 commonboot(Fhdr *fp)
 {
         if (!(fp->entry & mach->ktmask))
                 return;
 
         switch(fp->type) {                              /* boot image */
@@ skipping 77 matching lines @@
                 char *p;
                 uvlong *v;
         } u;
         u.p = (char*)&hp->e.exechdr;
         entry = beswav(*u.v);
 
         pgsize = mach->pgsize;
         settext(fp, entry, pgsize+fp->hdrsz, hp->e.exechdr.text, fp->hdrsz);
         setdata(fp, _round(pgsize+fp->txtsz+fp->hdrsz, pgsize),
                 hp->e.exechdr.data, fp->txtsz+fp->hdrsz, hp->e.exechdr.bss);
-        setsym(fp, hp->e.exechdr.syms, hp->e.exechdr.spsz, hp->e.exechdr.pcsz, fp->datoff+fp->datsz);
+        setsym(fp, fp->datoff+fp->datsz, hp->e.exechdr.syms, 0, hp->e.exechdr.spsz, 0, hp->e.exechdr.pcsz);
 
         if(hp->e.exechdr.magic & DYN_MAGIC) {
                 fp->txtaddr = 0;
                 fp->dataddr = fp->txtsz;
                 return 1;
         }
         commonboot(fp);
         return 1;
 }
 
@@ skipping 212 matching lines @@
                  */
                 if(ep->machine == SPARC64 && ep->phnum == 2) {
                         uint32 txtaddr, txtsz, dataddr, bsssz;
 
                         txtaddr = ph[0].vaddr | 0x80000000;
                         txtsz = ph[0].filesz - ph[0].paddr;
                         dataddr = txtaddr + txtsz;
                         bsssz = ph[0].memsz - ph[0].filesz;
                         settext(fp, ep->elfentry | 0x80000000, txtaddr, txtsz, ph[0].offset);
                         setdata(fp, dataddr, ph[0].paddr, ph[0].offset + txtsz, bsssz);
-                        setsym(fp, ph[1].filesz, 0, ph[1].memsz, ph[1].offset);
+                        setsym(fp, ph[1].offset, ph[1].filesz, 0, 0, 0, ph[1].memsz);
                         free(ph);
                         return 1;
                 }
 
                 werrstr("No TEXT or DATA sections");
-error:
                 free(ph);
                 free(sh);
                 return 0;
         }
 
         settext(fp, ep->elfentry, ph[it].vaddr, ph[it].memsz, ph[it].offset);
         setdata(fp, ph[id].vaddr, ph[id].filesz, ph[id].offset, ph[id].memsz - ph[id].filesz);
         if(is != -1)
-                setsym(fp, ph[is].filesz, 0, ph[is].memsz, ph[is].offset);
+                setsym(fp, ph[is].offset, ph[is].filesz, 0, 0, 0, ph[is].memsz);
         else if(sh != 0){
                 char *buf;
                 uvlong symsize = 0;
                 uvlong symoff = 0;
                 uvlong pclnsz = 0;
+                uvlong pclnoff = 0;
 
                 /* load shstrtab names */
                 buf = malloc(sh[ep->shstrndx].size);
                 if (buf == 0)
                         goto done;
                 memset(buf, 0, sizeof buf);
                 seek(fd, sh[ep->shstrndx].offset, 0);
                 i = read(fd, buf, sh[ep->shstrndx].size);
                 USED(i);        // shut up ubuntu gcc
 
                 for(i = 0; i < ep->shnum; i++) {
                         if (strcmp(&buf[sh[i].name], ".gosymtab") == 0) {
                                 symsize = sh[i].size;
                                 symoff = sh[i].offset;
                         }
                         if (strcmp(&buf[sh[i].name], ".gopclntab") == 0) {
-                                if (sh[i].offset != symoff+symsize) {
-                                        werrstr("pc line table not contiguous with symbol table");
-                                        free(buf);
-                                        goto error;
-                                }
                                 pclnsz = sh[i].size;
+                                pclnoff = sh[i].offset;
                         }
                 }
-                setsym(fp, symsize, 0, pclnsz, symoff);
+                setsym(fp, symoff, symsize, 0, 0, pclnoff, pclnsz);
                 free(buf);
         }
 done:
         free(ph);
         free(sh);
         return 1;
 }
 
 static int
 elfdotout(int fd, Fhdr *fp, ExecHdr *hp)
@@ skipping 116 matching lines @@
                  */
                 if(ep->machine == SPARC64 && ep->phnum == 2) {
                         uint32 txtaddr, txtsz, dataddr, bsssz;
 
                         txtaddr = ph[0].vaddr | 0x80000000;
                         txtsz = ph[0].filesz - ph[0].paddr;
                         dataddr = txtaddr + txtsz;
                         bsssz = ph[0].memsz - ph[0].filesz;
                         settext(fp, ep->elfentry | 0x80000000, txtaddr, txtsz, ph[0].offset);
                         setdata(fp, dataddr, ph[0].paddr, ph[0].offset + txtsz, bsssz);
-                        setsym(fp, ph[1].filesz, 0, ph[1].memsz, ph[1].offset);
+                        setsym(fp, ph[1].offset, ph[1].filesz, 0, 0, 0, ph[1].memsz);
                         free(ph);
                         return 1;
                 }
 
                 werrstr("No TEXT or DATA sections");
-error:
                 free(sh);
                 free(ph);
                 return 0;
         }
 
         settext(fp, ep->elfentry, ph[it].vaddr, ph[it].memsz, ph[it].offset);
         setdata(fp, ph[id].vaddr, ph[id].filesz, ph[id].offset, ph[id].memsz - ph[id].filesz);
         if(is != -1)
-                setsym(fp, ph[is].filesz, 0, ph[is].memsz, ph[is].offset);
+                setsym(fp, ph[is].offset, ph[is].filesz, 0, 0, 0, ph[is].memsz);
         else if(sh != 0){
                 char *buf;
                 uvlong symsize = 0;
                 uvlong symoff = 0;
-                uvlong pclnsz = 0;
+                uvlong pclnsize = 0;
+                uvlong pclnoff = 0;
 
                 /* load shstrtab names */
                 buf = malloc(sh[ep->shstrndx].size);
                 if (buf == 0)
                         goto done;
                 memset(buf, 0, sizeof buf);
                 seek(fd, sh[ep->shstrndx].offset, 0);
                 i = read(fd, buf, sh[ep->shstrndx].size);
                 USED(i);        // shut up ubuntu gcc
 
                 for(i = 0; i < ep->shnum; i++) {
                         if (strcmp(&buf[sh[i].name], ".gosymtab") == 0) {
                                 symsize = sh[i].size;
                                 symoff = sh[i].offset;
                         }
                         if (strcmp(&buf[sh[i].name], ".gopclntab") == 0) {
-                                if (sh[i].offset != symoff+symsize) {
-                                        werrstr("pc line table not contiguous with symbol table");
-                                        free(buf);
-                                        goto error;
-                                }
-                                pclnsz = sh[i].size;
+                                pclnsize = sh[i].size;
+                                pclnoff = sh[i].offset;
                         }
                 }
-                setsym(fp, symsize, 0, pclnsz, symoff);
+                setsym(fp, symoff, symsize, 0, 0, pclnoff, pclnsize);
                 free(buf);
         }
 done:
         free(sh);
         free(ph);
         return 1;
 }
 
 static int
 machdotout(int fd, Fhdr *fp, ExecHdr *hp)
@@ skipping 203 matching lines @@
         }
         if (textva == 0 || datava == 0) {
                 free(cmd);
                 free(cmdbuf);
                 return 0;
         }
         /* compute entry by taking address after header - weird - BUG? */
         settext(fp, textva+sizeof(Machhdr) + mp->sizeofcmds, textva, textsize, textoff);
         setdata(fp, datava, datasize, dataoff, bsssize);
         if(symtab != 0)
-                setsym(fp, symtab->filesize, 0, pclntab? pclntab->filesize : 0, symtab->fileoff);
+                setsym(fp, symtab->fileoff, symtab->filesize, 0, 0, 0, pclntab? pclntab->filesize : 0);
         free(cmd);
         free(cmdbuf);
         return 1;
 bad:
         free(cmd);
         free(cmdbuf);
         return 0;
 }
 
 /*
  * (Free|Net)BSD ARM header.
  */
 static int
 armdotout(int fd, Fhdr *fp, ExecHdr *hp)
 {
         uvlong kbase;
 
         USED(fd);
         settext(fp, hp->e.exechdr.entry, sizeof(Exec), hp->e.exechdr.text, sizeof(Exec));
         setdata(fp, fp->txtsz, hp->e.exechdr.data, fp->txtsz, hp->e.exechdr.bss);
-        setsym(fp, hp->e.exechdr.syms, hp->e.exechdr.spsz, hp->e.exechdr.pcsz, fp->datoff+fp->datsz);
+        setsym(fp, fp->datoff+fp->datsz, hp->e.exechdr.syms, 0, hp->e.exechdr.spsz, 0, hp->e.exechdr.pcsz);
 
         kbase = 0xF0000000;
         if ((fp->entry & kbase) == kbase) {             /* Boot image */
                 fp->txtaddr = kbase+sizeof(Exec);
                 fp->name = "ARM *BSD boot image";
                 fp->hdrsz = 0;          /* header stripped */
                 fp->dataddr = kbase+fp->txtsz;
         }
         return 1;
 }
@@ skipping 10 matching lines @@
 static void
 setdata(Fhdr *fp, uvlong a, int32 s, vlong off, int32 bss)
 {
         fp->dataddr = a;
         fp->datsz = s;
         fp->datoff = off;
         fp->bsssz = bss;
 }
 
 static void
-setsym(Fhdr *fp, int32 symsz, int32 sppcsz, int32 lnpcsz, vlong symoff)
+setsym(Fhdr *fp, vlong symoff, int32 symsz, vlong sppcoff, int32 sppcsz, vlong lnpcoff, int32 lnpcsz)
 {
+        fp->symoff = symoff;
         fp->symsz = symsz;
-        fp->symoff = symoff;
+ ·······
+        if(sppcoff == 0)
+                sppcoff = symoff+symsz;
+        fp->sppcoff = symoff;
         fp->sppcsz = sppcsz;
-        fp->sppcoff = fp->symoff+fp->symsz;
+
+        if(lnpcoff == 0)
+                lnpcoff = sppcoff + sppcsz;
+        fp->lnpcoff = lnpcoff;
         fp->lnpcsz = lnpcsz;
-        fp->lnpcoff = fp->sppcoff+fp->sppcsz;
 }
 
 
 static uvlong
 _round(uvlong a, uint32 b)
 {
         uvlong w;
 
         w = (a/b)*b;
         if (a!=w)
                 w += b;
         return(w);
 }