code review 3733046: new cgo windows port.

src/cmd/ld/ldpe.c

-/*
-        Copyright © 2010 Wei guangjing.
-        Portions Copyright © 2010 The Go Authors.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
 
 #include        "l.h"
 #include        "lib.h"
 #include        "../ld/pe.h"
 
 #define IMAGE_SCN_MEM_DISCARDABLE 0x2000000
 
 #define IMAGE_SYM_UNDEFINED     0
 #define IMAGE_SYM_ABSOLUTE (-1)
 #define IMAGE_SYM_DEBUG (-2)
@@ skipping 69 matching lines @@
         uint16 sectnum;
         uint16 type;
         uint8 sclass;
         uint8 aux;
         Sym* sym;
 };
 
 struct PeSect {
         char* name;
         uchar* base;
-        uint64  size;
+        uint64 size;
         Sym* sym;
         IMAGE_SECTION_HEADER sh;
 };
 
 struct PeObj {
         Biobuf  *f;
         char    *name;
         uint32 base;
 ········
         PeSect  *sect;
-        uint            nsect;
+        uint    nsect;
         PeSym   *pesym;
         uint npesym;
 ········
         IMAGE_FILE_HEADER fh;
-        uchar* snames;
+        char* snames;
 };
 
 static int map(PeObj *obj, PeSect *sect);
-static int readsym(PeObj *obj, int i, PeSym **sym, char *pn);
+static int readsym(PeObj *obj, int i, PeSym **sym);
 
 void
 ldpe(Biobuf *f, char *pkg, int64 len, char *pn)
 {
         char *name;
         int32 base;
-        int i, j, numaux;
-        uint32 l;
+        int i, j, l, numaux;
         PeObj *obj;
         PeSect *sect, *rsect;
         IMAGE_SECTION_HEADER sh;
         uchar symbuf[18];
         Sym *s;
         Reloc *r, *rp;
         PeSym *sym;
 ········
         if(debug['v'])
                 Bprint(&bso, "%5.2f ldpe %s\n", cputime(), pn);
 ········
         version++;
         base = Boffset(f);
 ········
         obj = mal(sizeof *obj);
         obj->f = f;
         obj->base = base;
         obj->name = pn;
         // read header
         if(Bread(f, &obj->fh, sizeof obj->fh) != sizeof obj->fh)
                 goto bad;
         // load section list
         obj->sect = mal(obj->fh.NumberOfSections*sizeof obj->sect[0]);
         obj->nsect = obj->fh.NumberOfSections;
         for(i=0; i < obj->fh.NumberOfSections; i++) {
                 if(Bread(f, &obj->sect[i].sh, sizeof sh) != sizeof sh)
                         goto bad;
                 obj->sect[i].size = obj->sect[i].sh.SizeOfRawData;
-                obj->sect[i].name = obj->sect[i].sh.Name;
-                // TODO riase error if found .cormeta .rsrc
+                obj->sect[i].name = (char*)obj->sect[i].sh.Name;
+                // TODO return error if found .cormeta .rsrc
         }
         // load string table
         Bseek(f, base+obj->fh.PointerToSymbolTable+18*obj->fh.NumberOfSymbols, 0);
         if(Bread(f, &l, sizeof l) != sizeof l)·
                 goto bad;
         obj->snames = mal(l);
         Bseek(f, base+obj->fh.PointerToSymbolTable+18*obj->fh.NumberOfSymbols, 0);
         if(Bread(f, obj->snames, l) != l)
                 goto bad;
         // read symbols
         obj->pesym = mal(obj->fh.NumberOfSymbols*sizeof obj->pesym[0]);
         obj->npesym = obj->fh.NumberOfSymbols;
         Bseek(f, base+obj->fh.PointerToSymbolTable, 0);
-        numaux = 0;
         for(i=0; i<obj->fh.NumberOfSymbols; i+=numaux+1) {
                 Bseek(f, base+obj->fh.PointerToSymbolTable+sizeof(symbuf)*i, 0);
                 if(Bread(f, symbuf, sizeof symbuf) != sizeof symbuf)
                         goto bad;
+················
                 if((symbuf[0] == 0) && (symbuf[1] == 0) &&
                          (symbuf[2] == 0) && (symbuf[3] == 0)) {
                         l = le32(&symbuf[4]);
-                        obj->pesym[i].name = &obj->snames[l];
+                        obj->pesym[i].name = (char*)&obj->snames[l];
                 } else {
-                        obj->pesym[i].name = strdup(symbuf);
+                        obj->pesym[i].name = strdup((char*)symbuf);
                 }
                 obj->pesym[i].value = le32(&symbuf[8]);
                 obj->pesym[i].sectnum = le16(&symbuf[12]);
                 obj->pesym[i].sclass = symbuf[16];
                 obj->pesym[i].aux = symbuf[17];
                 obj->pesym[i].type = le16(&symbuf[14]);
-                numaux = obj->pesym[i].aux; if (numaux < 0) numaux = 0;
+                numaux = obj->pesym[i].aux; 
+                if (numaux < 0) 
+                        numaux = 0;
         }
         // create symbols for mapped sections
         for(i=0; i<obj->nsect; i++) {
                 sect = &obj->sect[i];
-                if(sect->sh.Characteristics & IMAGE_SCN_MEM_DISCARDABLE)
+                if(sect->sh.Characteristics&IMAGE_SCN_MEM_DISCARDABLE)
                         continue;
                 if(map(obj, sect) < 0)
                         goto bad;
 ················
                 name = smprint("%s(%s)", pn, sect->name);
                 s = lookup(name, version);
                 free(name);
-                switch(sect->sh.Characteristics&(IMAGE_SCN_CNT_UNINITIALIZED_DATA|IMAGE_SCN_CNT_INITIALIZED_DATA|IMAGE_SCN_MEM_READ|IMAGE_SCN_MEM_WRITE|IMAGE_SCN_CNT_CODE|IMAGE_SCN_MEM_EXECUTE)) {
+                switch(sect->sh.Characteristics&(IMAGE_SCN_CNT_UNINITIALIZED_DATA|IMAGE_SCN_CNT_INITIALIZED_DATA|
+                        IMAGE_SCN_MEM_READ|IMAGE_SCN_MEM_WRITE|IMAGE_SCN_CNT_CODE|IMAGE_SCN_MEM_EXECUTE)) {
                         case IMAGE_SCN_CNT_INITIALIZED_DATA|IMAGE_SCN_MEM_READ: //.rdata
                                 s->type = SRODATA;
                                 break;
                         case IMAGE_SCN_CNT_UNINITIALIZED_DATA|IMAGE_SCN_MEM_READ|IMAGE_SCN_MEM_WRITE: //.bss
                         case IMAGE_SCN_CNT_INITIALIZED_DATA|IMAGE_SCN_MEM_READ|IMAGE_SCN_MEM_WRITE: //.data
                                 s->type = SDATA;
                                 break;
-                        case IMAGE_SCN_CNT_CODE |IMAGE_SCN_MEM_EXECUTE|IMAGE_SCN_MEM_READ: //.text
+                        case IMAGE_SCN_CNT_CODE|IMAGE_SCN_MEM_EXECUTE|IMAGE_SCN_MEM_READ: //.text
                                 s->type = STEXT;
                                 break;
                         default:
                                 werrstr("unexpected flags for PE section %s", sect->name);
                                 goto bad;
                 }
                 s->p = sect->base;
                 s->np = sect->size;
                 s->size = sect->size;
                 if(s->type == STEXT) {
                         if(etextp)
                                 etextp->next = s;
                         else
                                 textp = s;
                         etextp = s;
                 }
                 sect->sym = s;
         }
 ········
         // load relocations
         for(i=0; i<obj->nsect; i++) {
                 rsect = &obj->sect[i];
                 if(rsect->sym == 0 || rsect->sh.NumberOfRelocations == 0)
-                                continue;
+                        continue;
                 if(rsect->sh.Characteristics&IMAGE_SCN_MEM_DISCARDABLE)
                         continue;
                 r = mal(rsect->sh.NumberOfRelocations*sizeof r[0]);
                 Bseek(f, obj->base+rsect->sh.PointerToRelocations, 0);
                 for(j=0; j<rsect->sh.NumberOfRelocations; j++) {
                         rp = &r[j];
                         if(Bread(f, symbuf, 10) != 10)
                                 goto bad;
 ························
                         uint32 rva, symindex;
                         uint16 type;
                         rva = le32(&symbuf[0]);
                         symindex = le32(&symbuf[4]);
                         type = le16(&symbuf[8]);
-                        if(readsym(obj, symindex, &sym, pn) < 0)
+                        if(readsym(obj, symindex, &sym) < 0)
                                 goto bad;
                         if(sym->sym == nil) {
-                                werrstr("reloc of invalid sym %s idx=%d type=%d", sym->name, sym->sclass, sym->type);
+                                werrstr("reloc of invalid sym %s idx=%d type=%d", sym->name, symindex, sym->type);
                                 goto bad;
                         }
                         rp->sym = sym->sym;
                         rp->siz = 4;
                         rp->off = rva;
                         switch(type) {
                                 default:
                                         diag("%s: unknown relocation type %d;", pn, type);
                                 case IMAGE_REL_I386_REL32:
                                         rp->type = D_PCREL;
                                         rp->add = 0;
                                         break;
                                 case IMAGE_REL_I386_DIR32:
                                         rp->type = D_ADDR;
                                         // load addend from image
                                         rp->add = le32(rsect->base+rp->off);
                                         break;
                         }
                 }
                 qsort(r, rsect->sh.NumberOfRelocations, sizeof r[0], rbyoff);
 ················
                 s = rsect->sym;
                 s->r = r;
                 s->nr = rsect->sh.NumberOfRelocations;
         }
 ········
         // enter sub-symbols into symbol table.
+        // frist 2 entry is file name.
         for(i=2; i<obj->npesym; i++) {
                 if(obj->pesym[i].name == 0)
                         continue;
                 if(obj->pesym[i].name[0] == '.') //skip section
                         continue;
                 if(obj->pesym[i].sectnum > 0) {
                         sect = &obj->sect[obj->pesym[i].sectnum-1];
                         if(sect->sym == 0)
                                 continue;
                 }
-                if(readsym(obj, i, &sym, pn) < 0)
+                if(readsym(obj, i, &sym) < 0)
                         goto bad;
 ········
                 s = sym->sym;
                 if(sym->sectnum == 0) {// extern
                         if(s->type == SDYNIMPORT)
                                 s->plt = -2; // flag for dynimport in PE object files.
                         continue;
                 } else if (sym->sectnum > 0) {
                         sect = &obj->sect[sym->sectnum-1];
                         if(sect->sym == 0)
@@ skipping 36 matching lines @@
 }
 
 static int
 map(PeObj *obj, PeSect *sect)
 {
         if(sect->base != nil)
                 return 0;
 
         sect->base = mal(sect->sh.SizeOfRawData);
         werrstr("short read");
-        if(Bseek(obj->f, obj->base+sect->sh.PointerToRawData, 0) < 0 || Bread(obj->f, sect->base, sect->sh.SizeOfRawData) != sect->sh.SizeOfRawData)
+        if(Bseek(obj->f, obj->base+sect->sh.PointerToRawData, 0) < 0 || 
+                        Bread(obj->f, sect->base, sect->sh.SizeOfRawData) != sect->sh.SizeOfRawData)
                 return -1;
 ········
         return 0;
 }
 
 static int
-readsym(PeObj *obj, int i, PeSym **y, char* pn)
+readsym(PeObj *obj, int i, PeSym **y)
 {
         Sym *s;
         PeSym *sym;
-        char* name;
+        char *name, *p;
 
         if(i >= obj->npesym || i < 0) {
                 werrstr("invalid pe symbol index");
                 return -1;
         }
 
         sym = &obj->pesym[i];
         *y = sym;
         s = nil;
 ········
-        if(sym->sclass == IMAGE_SYM_CLASS_STATIC && sym->value == 0) { // section
-                        PeSect *sect;
-                        sect = &obj->sect[sym->sectnum-1];
-                        name = sect->sym->name;
-        }
-
+        name = sym->name;
+        if(sym->sclass == IMAGE_SYM_CLASS_STATIC && sym->value == 0) // section
+                name = obj->sect[sym->sectnum-1].sym->name;
         if(strncmp(sym->name, "__imp__", 6) == 0)
-                        name = &sym->name[7]; // __imp__Name => Name
+                name = &sym->name[7]; // __imp__Name => Name
         else if(sym->name[0] == '_')·
-                        name = &sym->name[1]; // _Name => Name
+                name = &sym->name[1]; // _Name => Name
+        // remove last @XXX
+        p = strchr(name, '@');
+        if(p)
+                *p = 0;
 ········
         switch(sym->type) {
         default:
-                        werrstr("%s: invalid symbol type %d", sym->name, sym->sclass);
-                        return -1;
+                werrstr("%s: invalid symbol type %d", sym->name, sym->type);
+                return -1;
         case IMAGE_SYM_DTYPE_FUNCTION:
         case IMAGE_SYM_DTYPE_NULL:
                 switch(sym->sclass) {
                 case IMAGE_SYM_CLASS_EXTERNAL: //global
-                                        s = lookup(name, 0);
-                                break;
+                        s = lookup(name, 0);
+                        break;
                 case IMAGE_SYM_CLASS_NULL:
                 case IMAGE_SYM_CLASS_STATIC:
-                                s = lookup(name, version);
+                        s = lookup(name, version);
                         break;
                 default:
                         werrstr("%s: invalid symbol binding %d", sym->name, sym->sclass);
                         return -1;
                 }
                 break;
-         ·······
-        }
+        }
+
         if(s != nil && s->type == 0 && !(sym->sclass == IMAGE_SYM_CLASS_STATIC && sym->value == 0))
                 s->type = SXREF;
         sym->sym = s;
 
         return 0;
 }