From 2041c6fc2c9a06b7b2e65232805f3b980ae79ee2 Mon Sep 17 00:00:00 2001 From: Walter Bright Date: Sat, 27 Oct 2018 00:32:36 -0700 Subject: [PATCH] convert mscoffobj.c to D --- src/dmd/backend/cgobj.d | 6 +- src/dmd/backend/code.d | 9 +- src/dmd/backend/{mscoffobj.c => mscoffobj.d} | 1338 +++++++++--------- src/posix.mak | 2 +- src/vcbuild/dmd_backend.vcxproj | 1 - src/win32.mak | 6 +- 6 files changed, 694 insertions(+), 668 deletions(-) rename src/dmd/backend/{mscoffobj.c => mscoffobj.d} (63%) diff --git a/src/dmd/backend/cgobj.d b/src/dmd/backend/cgobj.d index 8eed52603ed1..2b15761e4731 100644 --- a/src/dmd/backend/cgobj.d +++ b/src/dmd/backend/cgobj.d @@ -680,7 +680,7 @@ segidx_t OmfObj_seg_debugT() Obj OmfObj_init(Outbuffer *objbuf, const(char)* filename, const(char)* csegname) { //printf("OmfObj_init()\n"); - Obj mobj = cast(Obj)mem_calloc((void*[2]).sizeof); + Obj mobj = cast(Obj)mem_calloc(__traits(classInstanceSize, Obj)); Outbuffer *reset_symbuf = obj.reset_symbuf; if (reset_symbuf) @@ -1532,7 +1532,7 @@ private void objheader(char *csegname) __gshared char[78] lnames = "\0\06DGROUP\05_TEXT\04CODE\05_DATA\04DATA\05CONST\04_BSS\03BSS" ~ "\07$$TYPES\06DEBTYP\011$$SYMBOLS\06DEBSYM"; - assert(lnames[lnames.length - 1] == 'M'); + assert(lnames[lnames.length - 2] == 'M'); // Include debug segment names if inserting type information int lnamesize = config.fulltypes ? lnames.sizeof - 1 : lnames.sizeof - 1 - 32; @@ -2331,7 +2331,7 @@ private int obj_newfarseg(targ_size_t size,int classidx) { seg_data *f = getsegment(); f.isfarseg = true; - f.seek = obj.buf.size(); + f.seek = cast(int)obj.buf.size(); f.attr = obj.fdsegattr; f.origsize = size; f.SDoffset = size; diff --git a/src/dmd/backend/code.d b/src/dmd/backend/code.d index 144d308eadee..d5f517ad65b6 100644 --- a/src/dmd/backend/code.d +++ b/src/dmd/backend/code.d @@ -244,7 +244,7 @@ struct seg_data int classidx; // lname idx of class name uint attr; // segment attribute targ_size_t origsize; // original size - long seek; // seek position in output file + int seek; // seek position in output file void* ledata; // (Ledatarec) current one we're filling in } @@ -269,10 +269,13 @@ struct seg_data uint SDlinnum_max; linnum_data *SDlinnum_data; // array of line number / offset data - int isCode(); + version (Windows) + int isCode() { return seg_data_isCode(this); } + else + int isCode(); } - +extern int seg_data_isCode(const ref seg_data sd); struct linnum_data { diff --git a/src/dmd/backend/mscoffobj.c b/src/dmd/backend/mscoffobj.d similarity index 63% rename from src/dmd/backend/mscoffobj.c rename to src/dmd/backend/mscoffobj.d index 3847c701c49f..2300f3d687f5 100644 --- a/src/dmd/backend/mscoffobj.c +++ b/src/dmd/backend/mscoffobj.d @@ -5,123 +5,102 @@ * Copyright: Copyright (C) 2009-2018 by The D Language Foundation, All Rights Reserved * Authors: $(LINK2 http://www.digitalmars.com, Walter Bright) * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) - * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/backend/mscoffobj.c, backend/mscoffobj.c) + * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/backend/mscoffobj.d, backend/mscoffobj.d) */ +module dmd.backend.mscoffobj; -#if MARS -#include -#include -#include -#include -#include -#include -#include -#include +version (MARS) +{ + +import core.stdc.ctype; +import core.stdc.stdio; +import core.stdc.stdint; +import core.stdc.stdlib; +import core.stdc.string; +import core.stdc.time; -#include "cc.h" -#include "global.h" -#include "code.h" -#include "type.h" -#include "mach.h" -#include "outbuf.h" -#include "filespec.h" -#include "cv4.h" -#include "cgcv.h" -#include "dt.h" +import dmd.backend.cc; +import dmd.backend.cdef; +import dmd.backend.code; +import dmd.backend.code_x86; +import dmd.backend.cv8; +import dmd.backend.dlist; +import dmd.backend.dvec; +import dmd.backend.el; +import dmd.backend.md5; +import dmd.backend.memh; +import dmd.backend.global; +import dmd.backend.obj; +import dmd.backend.outbuf; +import dmd.backend.ty; +import dmd.backend.type; -#if TARGET_WINDOS +import dmd.backend.mscoff; -typedef unsigned char ubyte; -typedef unsigned short ushort; -typedef unsigned uint; -#define null NULL -#define private static -#define cast +extern (C++): -#include "mscoff.h" +static if (TARGET_WINDOS) +{ -static Outbuffer *fobjbuf; +extern (C) char* strupr(char*); -static char __file__[] = __FILE__; // for tassert.h -#include "tassert.h" +private __gshared Outbuffer *fobjbuf; -#define DEST_LEN (IDMAX + IDOHD + 1) +enum DEST_LEN = (IDMAX + IDOHD + 1); char *obj_mangle2(Symbol *s,char *dest); -#if MARS -// C++ name mangling is handled by front end -#define cpp_mangle(s) ((s)->Sident) -#endif + +int elf_align(int size, int foffset); /****************************************** */ -static int elf_align(int size, int offset); -static void objflush_pointerRefs(); - -// Forward references -void MsCoffObj_pubdef(segidx_t seg, Symbol *s, targ_size_t offset); -uint MsCoffObj_bytes(segidx_t seg, targ_size_t offset, uint nbytes, void *p); -IDXSEC MsCoffObj_addScnhdr(const char *scnhdr_name, uint flags); -segidx_t MsCoffObj_getsegment2(IDXSEC shtidx); -segidx_t MsCoffObj_seg_drectve(); -segidx_t MsCoffObj_getsegment(const char *sectname, uint flags); -int MsCoffObj_reftoident(segidx_t seg, targ_size_t offset, Symbol *s, targ_size_t val, - int flags); -int MsCoffObj_comdat(Symbol *s); -segidx_t MsCoffObj_data_start(Symbol *sdata, targ_size_t datasize, segidx_t seg); -void MsCoffObj_lidata(segidx_t seg,targ_size_t offset,targ_size_t count); -void MsCoffObj_byte(segidx_t seg,targ_size_t offset,uint byte); -int MsCoffObj_external_def(const char *name); -void MsCoffObj_setModuleCtorDtor(Symbol *sfunc, bool isCtor); - - - - - // The object file is built ib several separate pieces +__gshared private +{ // String Table - String table for all other names -static Outbuffer *string_table; + Outbuffer *string_table; // Section Headers -Outbuffer *ScnhdrBuf; // Buffer to build section table in + public Outbuffer *ScnhdrBuf; // Buffer to build section table in + // The -1 is because it is 1 based indexing -#define ScnhdrTab (((IMAGE_SECTION_HEADER *)ScnhdrBuf->buf)-1) +IMAGE_SECTION_HEADER* ScnhdrTab() { return cast(IMAGE_SECTION_HEADER *)ScnhdrBuf.buf - 1; } -static int scnhdr_cnt; // Number of sections in table -#define SCNHDR_TAB_INITSIZE 16 // Initial number of sections in buffer -#define SCNHDR_TAB_INC 4 // Number of sections to increment buffer by + int scnhdr_cnt; // Number of sections in table + enum SCNHDR_TAB_INITSIZE = 16; // Initial number of sections in buffer + enum SCNHDR_TAB_INC = 4; // Number of sections to increment buffer by -#define SYM_TAB_INIT 100 // Initial number of symbol entries in buffer -#define SYM_TAB_INC 50 // Number of symbols to increment buffer by + enum SYM_TAB_INIT = 100; // Initial number of symbol entries in buffer + enum SYM_TAB_INC = 50; // Number of symbols to increment buffer by // The symbol table -static Outbuffer *symbuf; + Outbuffer *symbuf; -static Outbuffer *syment_buf; // array of struct syment + Outbuffer *syment_buf; // array of struct syment -static segidx_t segidx_drectve = UNKNOWN; // contents of ".drectve" section -static segidx_t segidx_debugS = UNKNOWN; -static segidx_t segidx_xdata = UNKNOWN; -static segidx_t segidx_pdata = UNKNOWN; + segidx_t segidx_drectve = UNKNOWN; // contents of ".drectve" section + segidx_t segidx_debugS = UNKNOWN; + segidx_t segidx_xdata = UNKNOWN; + segidx_t segidx_pdata = UNKNOWN; -static int jumpTableSeg; // segment index for __jump_table + int jumpTableSeg; // segment index for __jump_table -static Outbuffer *indirectsymbuf2; // indirect symbol table of Symbol*'s -static int pointersSeg; // segment index for __pointers + Outbuffer *indirectsymbuf2; // indirect symbol table of Symbol*'s + int pointersSeg; // segment index for __pointers -static Outbuffer *ptrref_buf; // buffer for pointer references + Outbuffer *ptrref_buf; // buffer for pointer references -static int floatused; + int floatused; /* If an MsCoffObj_external_def() happens, set this to the string index, * to be added last to the symbol table. * Obviously, there can be only one. */ -static IDXSTR extdef; + IDXSTR extdef; // Each compiler segment is a section // Predefined compiler segments CODE,DATA,CDATA,UDATA map to indexes @@ -132,11 +111,12 @@ static IDXSTR extdef; * Returns !=0 if this segment is a code segment. */ -int seg_data::isCode() +int seg_data_isCode(const ref seg_data sd) { - return (ScnhdrTab[SDshtidx].Characteristics & IMAGE_SCN_CNT_CODE) != 0; + return (ScnhdrTab[sd.SDshtidx].Characteristics & IMAGE_SCN_CNT_CODE) != 0; } +public: // already in cgobj.c (should be part of objmod?): // seg_data **SegData; @@ -145,6 +125,8 @@ extern int seg_max; segidx_t seg_tlsseg = UNKNOWN; segidx_t seg_tlsseg_bss = UNKNOWN; +} + /******************************************************* * Because the mscoff relocations cannot be computed until after * all the segments are written out, and we need more information @@ -158,7 +140,7 @@ enum RELrel = 1, // relative to location to be fixed up RELseg = 2, // 2 byte section RELaddr32 = 3, // 4 byte offset -}; +} struct Relocation { // Relocations are attached to the struct seg_data they refer to @@ -170,7 +152,7 @@ struct Relocation // to address of start of this segment ubyte rtype; // RELxxxx short val; // 0, -1, -2, -3, -4, -5 -}; +} /******************************* @@ -182,12 +164,12 @@ struct Relocation * Returns offset into the specified string table. */ -IDXSTR MsCoffObj_addstr(Outbuffer *strtab, const char *str) +IDXSTR MsCoffObj_addstr(Outbuffer *strtab, const(char)* str) { //printf("MsCoffObj_addstr(strtab = %p str = '%s')\n",strtab,str); - IDXSTR idx = strtab->size(); // remember starting offset - strtab->writeString(str); - //printf("\tidx %d, new size %d\n",idx,strtab->size()); + IDXSTR idx = cast(IDXSTR)strtab.size(); // remember starting offset + strtab.writeString(str); + //printf("\tidx %d, new size %d\n",idx,strtab.size()); return idx; } @@ -200,13 +182,13 @@ IDXSTR MsCoffObj_addstr(Outbuffer *strtab, const char *str) * Returns index into the specified string table or 0. */ -private IDXSTR elf_findstr(Outbuffer *strtab, const char *str, const char *suffix) +private IDXSTR elf_findstr(Outbuffer *strtab, const(char)* str, const(char)* suffix) { - const char *ent = cast(char *)strtab->buf+4; - const char *pend = ent+strtab->size() - 1; - const char *s = str; - const char *sx = suffix; - int len = strlen(str); + const(char)* ent = cast(char *)strtab.buf+4; + const(char)* pend = ent+strtab.size() - 1; + const(char)* s = str; + const(char)* sx = suffix; + int len = cast(uint)strlen(str); if (suffix) len += strlen(suffix); @@ -217,7 +199,7 @@ private IDXSTR elf_findstr(Outbuffer *strtab, const char *str, const char *suffi { if(*s == 0 && !sx) // end of string - found a match { - return ent - (const char *)strtab->buf - len; + return cast(IDXSTR)(ent - cast(const(char)*)strtab.buf - len); } else // table entry too short { @@ -262,26 +244,26 @@ private IDXSTR elf_findstr(Outbuffer *strtab, const char *str, const char *suffi private IDXSTR elf_addmangled(Symbol *s) { - //printf("elf_addmangled(%s)\n", s->Sident); - char dest[DEST_LEN]; + //printf("elf_addmangled(%s)\n", s.Sident.ptr); + char[DEST_LEN] dest = void; - IDXSTR namidx = string_table->size(); - char *destr = obj_mangle2(s, dest); - const char *name = destr; + IDXSTR namidx = cast(IDXSTR)string_table.size(); + char *destr = obj_mangle2(s, dest.ptr); + const(char)* name = destr; if (CPP && name[0] == '_' && name[1] == '_') { if (strncmp(name,"__ct__",6) == 0) name += 4; } - else if (tyfunc(s->ty()) && s->Sfunc && s->Sfunc->Fredirect) - name = s->Sfunc->Fredirect; + else if (tyfunc(s.ty()) && s.Sfunc && s.Sfunc.Fredirect) + name = s.Sfunc.Fredirect; size_t len = strlen(name); - string_table->reserve(len+1); - strcpy((char *)string_table->p,name); - string_table->setsize(namidx+len+1); - if (destr != dest) // if we resized result + string_table.reserve(cast(uint)(len+1)); + strcpy(cast(char *)string_table.p,name); + string_table.setsize(cast(uint)(namidx+len+1)); + if (destr != dest.ptr) // if we resized result mem_free(destr); - //dbg_printf("\telf_addmagled string_table %s namidx %d len %d size %d\n",name, namidx,len,string_table->size()); + //dbg_printf("\telf_addmagled string_table %s namidx %d len %d size %d\n",name, namidx,len,string_table.size()); return namidx; } @@ -295,11 +277,11 @@ Symbol * MsCoffObj_sym_cdata(tym_t ty,char *p,int len) //printf("MsCoffObj_sym_cdata(ty = %x, p = %x, len = %d, Offset(CDATA) = %x)\n", ty, p, len, Offset(CDATA)); alignOffset(CDATA, tysize(ty)); Symbol *s = symboldata(Offset(CDATA), ty); - s->Sseg = CDATA; + s.Sseg = CDATA; MsCoffObj_pubdef(CDATA, s, Offset(CDATA)); MsCoffObj_bytes(CDATA, Offset(CDATA), len, p); - s->Sfl = FLdata; //FLextern; + s.Sfl = FLdata; //FLextern; return s; } @@ -311,19 +293,22 @@ Symbol * MsCoffObj_sym_cdata(tym_t ty,char *p,int len) int MsCoffObj_data_readonly(char *p, int len, segidx_t *pseg) { int oldoff; -#if SCPP +version (SCPP) +{ oldoff = Offset(DATA); - SegData[DATA]->SDbuf->reserve(len); - SegData[DATA]->SDbuf->writen(p,len); + SegData[DATA].SDbuf.reserve(len); + SegData[DATA].SDbuf.writen(p,len); Offset(DATA) += len; *pseg = DATA; -#else - oldoff = Offset(CDATA); - SegData[CDATA]->SDbuf->reserve(len); - SegData[CDATA]->SDbuf->writen(p,len); +} +else +{ + oldoff = cast(int)Offset(CDATA); + SegData[CDATA].SDbuf.reserve(len); + SegData[CDATA].SDbuf.writen(p,len); Offset(CDATA) += len; *pseg = CDATA; -#endif +} return oldoff; } @@ -345,7 +330,6 @@ int MsCoffObj_data_readonly(char *p, int len) int MsCoffObj_string_literal_segment(uint sz) { assert(0); - return 0; } /****************************** @@ -354,14 +338,14 @@ int MsCoffObj_string_literal_segment(uint sz) * One source file can generate multiple .obj files. */ -Obj *MsCoffObj_init(Outbuffer *objbuf, const char *filename, const char *csegname) +Obj MsCoffObj_init(Outbuffer *objbuf, const(char)* filename, const(char)* csegname) { //printf("MsCoffObj_init()\n"); - Obj *obj = new Obj(); + Obj obj = cast(Obj)mem_calloc(__traits(classInstanceSize, Obj)); cseg = CODE; fobjbuf = objbuf; - assert(objbuf->size() == 0); + assert(objbuf.size() == 0); floatused = 0; @@ -376,26 +360,37 @@ Obj *MsCoffObj_init(Outbuffer *objbuf, const char *filename, const char *csegnam // Initialize buffers if (!string_table) - { string_table = new Outbuffer(1024); - string_table->reserve(2048); + { + string_table = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); + assert(string_table); + string_table.enlarge(1024); + string_table.reserve(2048); } - string_table->setsize(0); - string_table->write32(4); // first 4 bytes are length of string table + string_table.setsize(0); + string_table.write32(4); // first 4 bytes are length of string table if (symbuf) { - Symbol **p = cast(Symbol **)symbuf->buf; - const size_t n = symbuf->size() / sizeof(Symbol *); + Symbol **p = cast(Symbol **)symbuf.buf; + const size_t n = symbuf.size() / (Symbol *).sizeof; for (size_t i = 0; i < n; ++i) symbol_reset(p[i]); - symbuf->setsize(0); + symbuf.setsize(0); } else - symbuf = new Outbuffer(sizeof(Symbol *) * SYM_TAB_INIT); + { + symbuf = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); + assert(symbuf); + symbuf.enlarge((Symbol *).sizeof * SYM_TAB_INIT); + } if (!syment_buf) - syment_buf = new Outbuffer(sizeof(SymbolTable32) * SYM_TAB_INIT); - syment_buf->setsize(0); + { + syment_buf = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); + assert(syment_buf); + syment_buf.enlarge(SymbolTable32.sizeof * SYM_TAB_INIT); + } + syment_buf.setsize(0); extdef = 0; pointersSeg = 0; @@ -403,10 +398,13 @@ Obj *MsCoffObj_init(Outbuffer *objbuf, const char *filename, const char *csegnam // Initialize segments for CODE, DATA, UDATA and CDATA if (!ScnhdrBuf) { - ScnhdrBuf = new Outbuffer(SYM_TAB_INC * sizeof(IMAGE_SECTION_HEADER)); - ScnhdrBuf->reserve(SCNHDR_TAB_INITSIZE * sizeof(IMAGE_SECTION_HEADER)); + ScnhdrBuf = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); + assert(ScnhdrBuf); + ScnhdrBuf.enlarge(SYM_TAB_INC * IMAGE_SECTION_HEADER.sizeof); + + ScnhdrBuf.reserve(SCNHDR_TAB_INITSIZE * (IMAGE_SECTION_HEADER).sizeof); } - ScnhdrBuf->setsize(0); + ScnhdrBuf.setsize(0); scnhdr_cnt = 0; /* Define sections. Although the order should not matter, we duplicate @@ -439,23 +437,23 @@ Obj *MsCoffObj_init(Outbuffer *objbuf, const char *filename, const char *csegnam SHI_TEXT = 2, SHI_UDATA = 3, SHI_CDATA = 4, - }; + } MsCoffObj_getsegment2(SHI_TEXT); - assert(SegData[CODE]->SDseg == CODE); + assert(SegData[CODE].SDseg == CODE); MsCoffObj_getsegment2(SHI_DATA); - assert(SegData[DATA]->SDseg == DATA); + assert(SegData[DATA].SDseg == DATA); MsCoffObj_getsegment2(SHI_CDATA); - assert(SegData[CDATA]->SDseg == CDATA); + assert(SegData[CDATA].SDseg == CDATA); MsCoffObj_getsegment2(SHI_UDATA); - assert(SegData[UDATA]->SDseg == UDATA); + assert(SegData[UDATA].SDseg == UDATA); if (config.fulltypes) cv8_initfile(filename); - assert(objbuf->size() == 0); + assert(objbuf.size() == 0); return obj; } @@ -468,10 +466,11 @@ Obj *MsCoffObj_init(Outbuffer *objbuf, const char *filename, const char *csegnam * csegname: User specified default code segment name */ -void MsCoffObj_initfile(const char *filename, const char *csegname, const char *modname) +void MsCoffObj_initfile(const(char)* filename, const(char)* csegname, const(char)* modname) { //dbg_printf("MsCoffObj_initfile(filename = %s, modname = %s)\n",filename,modname); -#if SCPP +version (SCPP) +{ if (csegname && *csegname && strcmp(csegname,".text")) { // Define new section and make it the default for cseg segment // NOTE: cseg is initialized to CODE @@ -479,14 +478,14 @@ void MsCoffObj_initfile(const char *filename, const char *csegname, const char * Elf32_Shdr *newtextsec; IDXSYM newsymidx; assert(!I64); // fix later - SegData[cseg]->SDshtidx = newsecidx = + SegData[cseg].SDshtidx = newsecidx = elf_newsection(csegname,0,SHT_PROGDEF,SHF_ALLOC|SHF_EXECINSTR); newtextsec = &ScnhdrTab[newsecidx]; - newtextsec->sh_addralign = 4; - SegData[cseg]->SDsymidx = + newtextsec.sh_addralign = 4; + SegData[cseg].SDsymidx = elf_addsym(0, 0, 0, STT_SECTION, STB_LOCAL, newsecidx); } -#endif +} if (config.fulltypes) cv8_initmodule(filename, modname); } @@ -498,12 +497,12 @@ void MsCoffObj_initfile(const char *filename, const char *csegname, const char * int32_t *patchAddr(int seg, targ_size_t offset) { - return cast(int32_t *)(fobjbuf->buf + ScnhdrTab[SegData[seg]->SDshtidx].PointerToRawData + offset); + return cast(int32_t *)(fobjbuf.buf + ScnhdrTab[SegData[seg].SDshtidx].PointerToRawData + offset); } int32_t *patchAddr64(int seg, targ_size_t offset) { - return cast(int32_t *)(fobjbuf->buf + ScnhdrTab[SegData[seg]->SDshtidx].PointerToRawData + offset); + return cast(int32_t *)(fobjbuf.buf + ScnhdrTab[SegData[seg].SDshtidx].PointerToRawData + offset); } void patch(seg_data *pseg, targ_size_t offset, int seg, targ_size_t value) @@ -511,31 +510,33 @@ void patch(seg_data *pseg, targ_size_t offset, int seg, targ_size_t value) //printf("patch(offset = x%04x, seg = %d, value = x%llx)\n", cast(uint)offset, seg, value); if (I64) { - int32_t *p = (int32_t *)(fobjbuf->buf + ScnhdrTab[pseg->SDshtidx].PointerToRawData + offset); -#if 0 + int32_t *p = cast(int32_t *)(fobjbuf.buf + ScnhdrTab[pseg.SDshtidx].PointerToRawData + offset); + +static if (0) printf("\taddr1 = x%llx\n\taddr2 = x%llx\n\t*p = x%llx\n\tdelta = x%llx\n", - ScnhdrTab[pseg->SDshtidx].VirtualAddress, - ScnhdrTab[SegData[seg]->SDshtidx].VirtualAddress, + ScnhdrTab[pseg.SDshtidx].VirtualAddress, + ScnhdrTab[SegData[seg].SDshtidx].VirtualAddress, *p, - ScnhdrTab[SegData[seg]->SDshtidx].VirtualAddress - - (ScnhdrTab[pseg->SDshtidx].VirtualAddress + offset)); -#endif - *p += ScnhdrTab[SegData[seg]->SDshtidx].VirtualAddress - - (ScnhdrTab[pseg->SDshtidx].VirtualAddress - value); + ScnhdrTab[SegData[seg].SDshtidx].VirtualAddress - + (ScnhdrTab[pseg.SDshtidx].VirtualAddress + offset)); + + *p += ScnhdrTab[SegData[seg].SDshtidx].VirtualAddress - + (ScnhdrTab[pseg.SDshtidx].VirtualAddress - value); } else { - int32_t *p = (int32_t *)(fobjbuf->buf + ScnhdrTab[pseg->SDshtidx].PointerToRawData + offset); -#if 0 + int32_t *p = cast(int32_t *)(fobjbuf.buf + ScnhdrTab[pseg.SDshtidx].PointerToRawData + offset); + +static if (0) printf("\taddr1 = x%x\n\taddr2 = x%x\n\t*p = x%x\n\tdelta = x%x\n", - ScnhdrTab[pseg->SDshtidx].VirtualAddress, - ScnhdrTab[SegData[seg]->SDshtidx].VirtualAddress, + ScnhdrTab[pseg.SDshtidx].VirtualAddress, + ScnhdrTab[SegData[seg].SDshtidx].VirtualAddress, *p, - ScnhdrTab[SegData[seg]->SDshtidx].VirtualAddress - - (ScnhdrTab[pseg->SDshtidx].VirtualAddress + offset)); -#endif - *p += ScnhdrTab[SegData[seg]->SDshtidx].VirtualAddress - - (ScnhdrTab[pseg->SDshtidx].VirtualAddress - value); + ScnhdrTab[SegData[seg].SDshtidx].VirtualAddress - + (ScnhdrTab[pseg.SDshtidx].VirtualAddress + offset)); + + *p += ScnhdrTab[SegData[seg].SDshtidx].VirtualAddress - + (ScnhdrTab[pseg.SDshtidx].VirtualAddress - value); } } @@ -545,36 +546,36 @@ void patch(seg_data *pseg, targ_size_t offset, int seg, targ_size_t value) * Store them in syment_buf. */ -private void syment_set_name(SymbolTable32 *sym, const char *name) +private void syment_set_name(SymbolTable32 *sym, const(char)* name) { size_t len = strlen(name); if (len > 8) { // Use offset into string table IDXSTR idx = MsCoffObj_addstr(string_table, name); - sym->Zeros = 0; - sym->Offset = idx; + sym.Zeros = 0; + sym.Offset = idx; } else - { memcpy(sym->Name, name, len); + { memcpy(sym.Name.ptr, name, len); if (len < 8) - memset(sym->Name + len, 0, 8 - len); + memset(sym.Name.ptr + len, 0, 8 - len); } } void write_sym(SymbolTable32* sym, bool bigobj) { - assert(sizeof(*sym) == 20); + assert((*sym).sizeof == 20); if (bigobj) { - syment_buf->write(sym, sizeof(*sym)); + syment_buf.write(sym, (*sym).sizeof); } else { // the only difference between SymbolTable32 and SymbolTable // is that field SectionNumber is long instead of short - uint scoff = (char*)&sym->SectionNumber - (char*)sym; - syment_buf->write(sym, scoff + 2); - syment_buf->write(cast(char*)sym + scoff + 4, sizeof(*sym) - scoff - 4); + uint scoff = cast(uint)(cast(char*)&sym.SectionNumber - cast(char*)sym); + syment_buf.write(sym, scoff + 2); + syment_buf.write(cast(char*)sym + scoff + 4, cast(uint)((*sym).sizeof - scoff - 4)); } } @@ -584,98 +585,97 @@ void build_syment_table(bool bigobj) * Anything we put in there would have no relevance, so we'll not put out this symbol. */ - uint symsize = bigobj ? sizeof(SymbolTable32) : sizeof(SymbolTable); + uint symsize = bigobj ? SymbolTable32.sizeof : SymbolTable.sizeof; /* Now goes one symbol per section. */ for (segidx_t seg = 1; seg <= seg_count; seg++) { seg_data *pseg = SegData[seg]; - IMAGE_SECTION_HEADER *psechdr = &ScnhdrTab[pseg->SDshtidx]; // corresponding section + IMAGE_SECTION_HEADER *psechdr = &ScnhdrTab[pseg.SDshtidx]; // corresponding section SymbolTable32 sym; - memcpy(sym.Name, psechdr->Name, 8); + memcpy(sym.Name.ptr, psechdr.Name.ptr, 8); sym.Value = 0; - sym.SectionNumber = pseg->SDshtidx; + sym.SectionNumber = pseg.SDshtidx; sym.Type = 0; sym.StorageClass = IMAGE_SYM_CLASS_STATIC; sym.NumberOfAuxSymbols = 1; write_sym(&sym, bigobj); - union auxent aux; - memset(&aux, 0, sizeof(aux)); + auxent aux = void; + memset(&aux, 0, (aux).sizeof); // s_size is not set yet - //aux.x_section.length = psechdr->s_size; - if (pseg->SDbuf && pseg->SDbuf->size()) - aux.x_section.length = pseg->SDbuf->size(); + //aux.x_section.length = psechdr.s_size; + if (pseg.SDbuf && pseg.SDbuf.size()) + aux.x_section.length = cast(uint)pseg.SDbuf.size(); else - aux.x_section.length = pseg->SDoffset; + aux.x_section.length = cast(uint)pseg.SDoffset; - if (pseg->SDrel) - aux.x_section.NumberOfRelocations = cast(ushort)(pseg->SDrel->size() / sizeof(struct Relocation)); + if (pseg.SDrel) + aux.x_section.NumberOfRelocations = cast(ushort)(pseg.SDrel.size() / (Relocation).sizeof); - if (psechdr->Characteristics & IMAGE_SCN_LNK_COMDAT) + if (psechdr.Characteristics & IMAGE_SCN_LNK_COMDAT) { aux.x_section.Selection = cast(ubyte)IMAGE_COMDAT_SELECT_ANY; - if (pseg->SDassocseg) + if (pseg.SDassocseg) { aux.x_section.Selection = cast(ubyte)IMAGE_COMDAT_SELECT_ASSOCIATIVE; - aux.x_section.NumberHighPart = cast(ushort)(pseg->SDassocseg >> 16); - aux.x_section.NumberLowPart = cast(ushort)(pseg->SDassocseg & 0x0000FFFF); + aux.x_section.NumberHighPart = cast(ushort)(pseg.SDassocseg >> 16); + aux.x_section.NumberLowPart = cast(ushort)(pseg.SDassocseg & 0x0000FFFF); } } memset(&aux.x_section.Zeros, 0, 2); - syment_buf->write(&aux, symsize); + syment_buf.write(&aux, symsize); - assert(sizeof(aux) == 20); + assert((aux).sizeof == 20); } /* Add symbols from symbuf[] */ int n = seg_count + 1; - size_t dim = symbuf->size() / sizeof(Symbol *); + size_t dim = symbuf.size() / (Symbol *).sizeof; for (size_t i = 0; i < dim; i++) - { Symbol *s = ((Symbol **)symbuf->buf)[i]; - s->Sxtrnnum = syment_buf->size() / symsize; + { Symbol *s = (cast(Symbol **)symbuf.buf)[i]; + s.Sxtrnnum = cast(uint)(syment_buf.size() / symsize); n++; SymbolTable32 sym; - char dest[DEST_LEN+1]; - char *destr = obj_mangle2(s, dest); + char[DEST_LEN+1] dest = void; + char *destr = obj_mangle2(s, dest.ptr); syment_set_name(&sym, destr); sym.Value = 0; - switch (s->Sclass) + switch (s.Sclass) { case SCextern: sym.SectionNumber = IMAGE_SYM_UNDEFINED; break; default: - sym.SectionNumber = SegData[s->Sseg]->SDshtidx; + sym.SectionNumber = SegData[s.Sseg].SDshtidx; break; } - sym.Type = tyfunc(s->Stype->Tty) ? 0x20 : 0; - switch (s->Sclass) + sym.Type = tyfunc(s.Stype.Tty) ? 0x20 : 0; + switch (s.Sclass) { case SCstatic: - if (s->Sflags & SFLhidden) - goto Ldefault; - // fall-through + if (s.Sflags & SFLhidden) + goto default; + goto case; case SClocstat: sym.StorageClass = IMAGE_SYM_CLASS_STATIC; - sym.Value = s->Soffset; + sym.Value = cast(uint)s.Soffset; break; - Ldefault: default: sym.StorageClass = IMAGE_SYM_CLASS_EXTERNAL; if (sym.SectionNumber != IMAGE_SYM_UNDEFINED) - sym.Value = s->Soffset; + sym.Value = cast(uint)s.Soffset; break; } sym.NumberOfAuxSymbols = 0; @@ -702,27 +702,35 @@ void MsCoffObj_termfile() * Terminate package. */ -void MsCoffObj_term(const char *objfilename) +void MsCoffObj_term(const(char)* objfilename) { //printf("MsCoffObj_term()\n"); - assert(fobjbuf->size() == 0); -#if SCPP + assert(fobjbuf.size() == 0); +version (SCPP) +{ if (!errcnt) -#endif { objflush_pointerRefs(); outfixlist(); // backpatches } +} +else +{ + objflush_pointerRefs(); + outfixlist(); // backpatches +} if (configv.addlinenumbers) { cv8_termfile(objfilename); } -#if SCPP +version (SCPP) +{ if (errcnt) return; -#endif +} + // To allow tooling support for most output files // switch to new object file format (similar to C++ with /bigobj) // only when exceeding the limit for 16-bit section count according to @@ -742,8 +750,8 @@ void MsCoffObj_term(const char *objfilename) // Write out the bytes for the header - BIGOBJ_HEADER header; - IMAGE_FILE_HEADER header_old; + BIGOBJ_HEADER header = void; + IMAGE_FILE_HEADER header_old = void; time_t f_timedat = 0; time(&f_timedat); @@ -757,209 +765,211 @@ void MsCoffObj_term(const char *objfilename) header.Machine = I64 ? IMAGE_FILE_MACHINE_AMD64 : IMAGE_FILE_MACHINE_I386; header.NumberOfSections = scnhdr_cnt; header.TimeDateStamp = cast(uint)f_timedat; - static ubyte uuid[16] = { '\xc7', '\xa1', '\xba', '\xd1', '\xee', '\xba', '\xa9', '\x4b', - '\xaf', '\x20', '\xfa', '\xf6', '\x6a', '\xa4', '\xdc', '\xb8' }; - memcpy(header.UUID, uuid, 16); - memset(header.unused, 0, sizeof(header.unused)); - foffset = sizeof(header); // start after header - foffset += ScnhdrBuf->size(); // section headers + static immutable ubyte[16] uuid = + [ '\xc7', '\xa1', '\xba', '\xd1', '\xee', '\xba', '\xa9', '\x4b', + '\xaf', '\x20', '\xfa', '\xf6', '\x6a', '\xa4', '\xdc', '\xb8' ]; + memcpy(header.UUID.ptr, uuid.ptr, 16); + memset(header.unused.ptr, 0, (header.unused).sizeof); + foffset = (header).sizeof; // start after header + foffset += ScnhdrBuf.size(); // section headers header.PointerToSymbolTable = foffset; // offset to symbol table symtable_offset = foffset; - header.NumberOfSymbols = syment_buf->size() / sizeof(SymbolTable32); - foffset += header.NumberOfSymbols * sizeof(SymbolTable32); // symbol table + header.NumberOfSymbols = cast(uint)(syment_buf.size() / (SymbolTable32).sizeof); + foffset += header.NumberOfSymbols * (SymbolTable32).sizeof; // symbol table } else { header_old.Machine = I64 ? IMAGE_FILE_MACHINE_AMD64 : IMAGE_FILE_MACHINE_I386; - header_old.NumberOfSections = scnhdr_cnt; + header_old.NumberOfSections = cast(ushort)scnhdr_cnt; header_old.TimeDateStamp = cast(uint)f_timedat; header_old.SizeOfOptionalHeader = 0; header_old.Characteristics = 0; - foffset = sizeof(header_old); // start after header - foffset += ScnhdrBuf->size(); // section headers + foffset = (header_old).sizeof; // start after header + foffset += ScnhdrBuf.size(); // section headers header_old.PointerToSymbolTable = foffset; // offset to symbol table symtable_offset = foffset; - header_old.NumberOfSymbols = syment_buf->size() / sizeof(SymbolTable); - foffset += header_old.NumberOfSymbols * sizeof(SymbolTable); // symbol table + header_old.NumberOfSymbols = cast(uint)(syment_buf.size() / (SymbolTable).sizeof); + foffset += header_old.NumberOfSymbols * (SymbolTable).sizeof; // symbol table } uint string_table_offset = foffset; - foffset += string_table->size(); // string table + foffset += string_table.size(); // string table // Compute file offsets of all the section data for (segidx_t seg = 1; seg <= seg_count; seg++) { seg_data *pseg = SegData[seg]; - IMAGE_SECTION_HEADER *psechdr = &ScnhdrTab[pseg->SDshtidx]; // corresponding section + IMAGE_SECTION_HEADER *psechdr = &ScnhdrTab[pseg.SDshtidx]; // corresponding section - int align = pseg->SDalignment; - if (align > 1) - foffset = (foffset + align - 1) & ~(align - 1); + int align_ = pseg.SDalignment; + if (align_ > 1) + foffset = (foffset + align_ - 1) & ~(align_ - 1); - if (pseg->SDbuf && pseg->SDbuf->size()) + if (pseg.SDbuf && pseg.SDbuf.size()) { - psechdr->PointerToRawData = foffset; - //printf("seg = %2d SDshtidx = %2d psechdr = %p s_scnptr = x%x\n", seg, pseg->SDshtidx, psechdr, cast(uint)psechdr->s_scnptr); - psechdr->SizeOfRawData = pseg->SDbuf->size(); - foffset += psechdr->SizeOfRawData; + psechdr.PointerToRawData = foffset; + //printf("seg = %2d SDshtidx = %2d psechdr = %p s_scnptr = x%x\n", seg, pseg.SDshtidx, psechdr, cast(uint)psechdr.s_scnptr); + psechdr.SizeOfRawData = cast(uint)pseg.SDbuf.size(); + foffset += psechdr.SizeOfRawData; } else - psechdr->SizeOfRawData = pseg->SDoffset; + psechdr.SizeOfRawData = cast(uint)pseg.SDoffset; } // Compute file offsets of the relocation data for (segidx_t seg = 1; seg <= seg_count; seg++) { seg_data *pseg = SegData[seg]; - IMAGE_SECTION_HEADER *psechdr = &ScnhdrTab[pseg->SDshtidx]; // corresponding section - if (pseg->SDrel) + IMAGE_SECTION_HEADER *psechdr = &ScnhdrTab[pseg.SDshtidx]; // corresponding section + if (pseg.SDrel) { foffset = (foffset + 3) & ~3; - assert(psechdr->PointerToRelocations == 0); - uint nreloc = pseg->SDrel->size() / sizeof(struct Relocation); + assert(psechdr.PointerToRelocations == 0); + uint nreloc = cast(uint)(pseg.SDrel.size() / Relocation.sizeof); if (nreloc) { - psechdr->PointerToRelocations = foffset; - //printf("seg = %d SDshtidx = %d psechdr = %p s_relptr = x%x\n", seg, pseg->SDshtidx, psechdr, cast(uint)psechdr->s_relptr); - psechdr->NumberOfRelocations = nreloc; - foffset += nreloc * sizeof(struct reloc); + psechdr.PointerToRelocations = foffset; + //printf("seg = %d SDshtidx = %d psechdr = %p s_relptr = x%x\n", seg, pseg.SDshtidx, psechdr, cast(uint)psechdr.s_relptr); + psechdr.NumberOfRelocations = cast(ushort)nreloc; + foffset += nreloc * reloc.sizeof; } } } - assert(fobjbuf->size() == 0); + assert(fobjbuf.size() == 0); // Write the header if (bigobj) { - fobjbuf->write(&header, sizeof(header)); - foffset = sizeof(header); + fobjbuf.write(&header, (header).sizeof); + foffset = (header).sizeof; } else { - fobjbuf->write(&header_old, sizeof(header_old)); - foffset = sizeof(header_old); + fobjbuf.write(&header_old, (header_old).sizeof); + foffset = (header_old).sizeof; } // Write the section headers - fobjbuf->write(ScnhdrBuf); - foffset += ScnhdrBuf->size(); + fobjbuf.write(ScnhdrBuf); + foffset += ScnhdrBuf.size(); // Write the symbol table assert(foffset == symtable_offset); - fobjbuf->write(syment_buf); - foffset += syment_buf->size(); + fobjbuf.write(syment_buf); + foffset += syment_buf.size(); // Write the string table assert(foffset == string_table_offset); - *cast(uint *)(string_table->buf) = string_table->size(); - fobjbuf->write(string_table); - foffset += string_table->size(); + *cast(uint *)(string_table.buf) = cast(uint)string_table.size(); + fobjbuf.write(string_table); + foffset += string_table.size(); // Write the section data for (segidx_t seg = 1; seg <= seg_count; seg++) { seg_data *pseg = SegData[seg]; - IMAGE_SECTION_HEADER *psechdr = &ScnhdrTab[pseg->SDshtidx]; // corresponding section - foffset = elf_align(pseg->SDalignment, foffset); - if (pseg->SDbuf && pseg->SDbuf->size()) + IMAGE_SECTION_HEADER *psechdr = &ScnhdrTab[pseg.SDshtidx]; // corresponding section + foffset = elf_align(pseg.SDalignment, foffset); + if (pseg.SDbuf && pseg.SDbuf.size()) { - //printf("seg = %2d SDshtidx = %2d psechdr = %p s_scnptr = x%x, foffset = x%x\n", seg, pseg->SDshtidx, psechdr, cast(uint)psechdr->s_scnptr, cast(uint)foffset); - assert(pseg->SDbuf->size() == psechdr->SizeOfRawData); - assert(foffset == psechdr->PointerToRawData); - fobjbuf->write(pseg->SDbuf); - foffset += pseg->SDbuf->size(); + //printf("seg = %2d SDshtidx = %2d psechdr = %p s_scnptr = x%x, foffset = x%x\n", seg, pseg.SDshtidx, psechdr, cast(uint)psechdr.s_scnptr, cast(uint)foffset); + assert(pseg.SDbuf.size() == psechdr.SizeOfRawData); + assert(foffset == psechdr.PointerToRawData); + fobjbuf.write(pseg.SDbuf); + foffset += pseg.SDbuf.size(); } } // Compute the relocations, write them out - assert(sizeof(struct reloc) == 10); + assert((reloc).sizeof == 10); for (segidx_t seg = 1; seg <= seg_count; seg++) { seg_data *pseg = SegData[seg]; - IMAGE_SECTION_HEADER *psechdr = &ScnhdrTab[pseg->SDshtidx]; // corresponding section - if (pseg->SDrel) - { Relocation *r = (Relocation *)pseg->SDrel->buf; - size_t sz = pseg->SDrel->size(); - bool pdata = (strcmp(cast(const char *)psechdr->Name, ".pdata") == 0); - Relocation *rend = cast(Relocation *)(pseg->SDrel->buf + sz); + IMAGE_SECTION_HEADER *psechdr = &ScnhdrTab[pseg.SDshtidx]; // corresponding section + if (pseg.SDrel) + { Relocation *r = cast(Relocation *)pseg.SDrel.buf; + size_t sz = pseg.SDrel.size(); + bool pdata = (strcmp(cast(const(char)* )psechdr.Name, ".pdata") == 0); + Relocation *rend = cast(Relocation *)(pseg.SDrel.buf + sz); foffset = elf_align(4, foffset); -#ifdef DEBUG - if (sz && foffset != psechdr->PointerToRelocations) - printf("seg = %d SDshtidx = %d psechdr = %p s_relptr = x%x, foffset = x%x\n", seg, pseg->SDshtidx, psechdr, cast(uint)psechdr->PointerToRelocations, cast(uint)foffset); -#endif - assert(sz == 0 || foffset == psechdr->PointerToRelocations); + + debug + if (sz && foffset != psechdr.PointerToRelocations) + printf("seg = %d SDshtidx = %d psechdr = %p s_relptr = x%x, foffset = x%x\n", seg, pseg.SDshtidx, psechdr, cast(uint)psechdr.PointerToRelocations, cast(uint)foffset); + + assert(sz == 0 || foffset == psechdr.PointerToRelocations); for (; r != rend; r++) { reloc rel; rel.r_vaddr = 0; rel.r_symndx = 0; rel.r_type = 0; - Symbol *s = r->targsym; - const char *rs = r->rtype == RELaddr ? "addr" : "rel"; - //printf("%d:x%04lx : tseg %d tsym %s REL%s\n", seg, cast(int)r->offset, r->targseg, s ? s->Sident : "0", rs); + Symbol *s = r.targsym; + const(char)* rs = r.rtype == RELaddr ? "addr" : "rel"; + //printf("%d:x%04lx : tseg %d tsym %s REL%s\n", seg, cast(int)r.offset, r.targseg, s ? s.Sident.ptr : "0", rs); if (s) { //printf("Relocation\n"); //symbol_print(s); - if (pseg->isCode()) + if (pseg.isCode()) { if (I64) { - rel.r_type = (r->rtype == RELrel) + rel.r_type = (r.rtype == RELrel) ? IMAGE_REL_AMD64_REL32 : IMAGE_REL_AMD64_REL32; - if (s->Stype->Tty & mTYthread) + if (s.Stype.Tty & mTYthread) rel.r_type = IMAGE_REL_AMD64_SECREL; - if (r->val == -1) + if (r.val == -1) rel.r_type = IMAGE_REL_AMD64_REL32_1; - else if (r->val == -2) + else if (r.val == -2) rel.r_type = IMAGE_REL_AMD64_REL32_2; - else if (r->val == -3) + else if (r.val == -3) rel.r_type = IMAGE_REL_AMD64_REL32_3; - else if (r->val == -4) + else if (r.val == -4) rel.r_type = IMAGE_REL_AMD64_REL32_4; - else if (r->val == -5) + else if (r.val == -5) rel.r_type = IMAGE_REL_AMD64_REL32_5; - if (s->Sclass == SCextern || - s->Sclass == SCcomdef || - s->Sclass == SCcomdat || - s->Sclass == SCglobal) + /+if (s.Sclass == SCextern || + s.Sclass == SCcomdef || + s.Sclass == SCcomdat || + s.Sclass == SCglobal) { - rel.r_vaddr = r->offset; - rel.r_symndx = s->Sxtrnnum; + rel.r_vaddr = cast(uint)r.offset; + rel.r_symndx = s.Sxtrnnum; } - else + else+/ { - rel.r_vaddr = r->offset; - rel.r_symndx = s->Sxtrnnum; + rel.r_vaddr = cast(uint)r.offset; + rel.r_symndx = s.Sxtrnnum; } } else if (I32) { - rel.r_type = (r->rtype == RELrel) + rel.r_type = (r.rtype == RELrel) ? IMAGE_REL_I386_REL32 : IMAGE_REL_I386_DIR32; - if (s->Stype->Tty & mTYthread) + if (s.Stype.Tty & mTYthread) rel.r_type = IMAGE_REL_I386_SECREL; - if (s->Sclass == SCextern || - s->Sclass == SCcomdef || - s->Sclass == SCcomdat || - s->Sclass == SCglobal) + /+if (s.Sclass == SCextern || + s.Sclass == SCcomdef || + s.Sclass == SCcomdat || + s.Sclass == SCglobal) { - rel.r_vaddr = r->offset; - rel.r_symndx = s->Sxtrnnum; + rel.r_vaddr = cast(uint)r.offset; + rel.r_symndx = s.Sxtrnnum; } - else + else+/ { - rel.r_vaddr = r->offset; - rel.r_symndx = s->Sxtrnnum; + rel.r_vaddr = cast(uint)r.offset; + rel.r_symndx = s.Sxtrnnum; } } else @@ -974,9 +984,9 @@ void MsCoffObj_term(const char *objfilename) else rel.r_type = IMAGE_REL_AMD64_ADDR64; - if (r->rtype == RELseg) + if (r.rtype == RELseg) rel.r_type = IMAGE_REL_AMD64_SECTION; - else if (r->rtype == RELaddr32) + else if (r.rtype == RELaddr32) rel.r_type = IMAGE_REL_AMD64_SECREL; } else if (I32) @@ -986,37 +996,37 @@ void MsCoffObj_term(const char *objfilename) else rel.r_type = IMAGE_REL_I386_DIR32; - if (r->rtype == RELseg) + if (r.rtype == RELseg) rel.r_type = IMAGE_REL_I386_SECTION; - else if (r->rtype == RELaddr32) + else if (r.rtype == RELaddr32) rel.r_type = IMAGE_REL_I386_SECREL; } else assert(false); // not implemented for I16 - rel.r_vaddr = r->offset; - rel.r_symndx = s->Sxtrnnum; + rel.r_vaddr = cast(uint)r.offset; + rel.r_symndx = s.Sxtrnnum; } } - else if (r->rtype == RELaddr && pseg->isCode()) + else if (r.rtype == RELaddr && pseg.isCode()) { int32_t *p = null; - p = patchAddr(seg, r->offset); + p = patchAddr(seg, r.offset); - rel.r_vaddr = r->offset; - rel.r_symndx = s ? s->Sxtrnnum : 0; + rel.r_vaddr = cast(uint)r.offset; + rel.r_symndx = s ? s.Sxtrnnum : 0; if (I64) { rel.r_type = IMAGE_REL_AMD64_REL32; - //srel.r_value = ScnhdrTab[SegData[r->targseg]->SDshtidx].s_vaddr + *p; - //printf("SECTDIFF: x%llx + x%llx = x%x\n", ScnhdrTab[SegData[r->targseg]->SDshtidx].s_vaddr, *p, srel.r_value); + //srel.r_value = ScnhdrTab[SegData[r.targseg].SDshtidx].s_vaddr + *p; + //printf("SECTDIFF: x%llx + x%llx = x%x\n", ScnhdrTab[SegData[r.targseg].SDshtidx].s_vaddr, *p, srel.r_value); } else { rel.r_type = IMAGE_REL_I386_SECREL; - //srel.r_value = ScnhdrTab[SegData[r->targseg]->SDshtidx].s_vaddr + *p; - //printf("SECTDIFF: x%x + x%x = x%x\n", ScnhdrTab[SegData[r->targseg]->SDshtidx].s_vaddr, *p, srel.r_value); + //srel.r_value = ScnhdrTab[SegData[r.targseg].SDshtidx].s_vaddr + *p; + //printf("SECTDIFF: x%x + x%x = x%x\n", ScnhdrTab[SegData[r.targseg].SDshtidx].s_vaddr, *p, srel.r_value); } } else @@ -1030,13 +1040,13 @@ void MsCoffObj_term(const char *objfilename) //assert(rel.r_symndx <= 20000); assert(rel.r_type <= 0x14); - fobjbuf->write(&rel, sizeof(rel)); - foffset += sizeof(rel); + fobjbuf.write(&rel, (rel).sizeof); + foffset += (rel).sizeof; } } } - fobjbuf->flush(); + fobjbuf.flush(); } /***************************** @@ -1056,7 +1066,7 @@ void MsCoffObj_linnum(Srcpos srcpos, int seg, targ_size_t offset) if (srcpos.Slinnum == 0 || !srcpos.Sfilename) return; - cv8_linnum(srcpos, offset); + cv8_linnum(srcpos, cast(uint)offset); } @@ -1066,7 +1076,7 @@ void MsCoffObj_linnum(Srcpos srcpos, int seg, targ_size_t offset) void MsCoffObj_startaddress(Symbol *s) { - //dbg_printf("MsCoffObj_startaddress(Symbol *%s)\n",s->Sident); + //dbg_printf("MsCoffObj_startaddress(Symbol *%s)\n",s.Sident.ptr); //obj.startaddress = s; } @@ -1074,13 +1084,13 @@ void MsCoffObj_startaddress(Symbol *s) * Output library name. */ -bool MsCoffObj_includelib(const char *name) +bool MsCoffObj_includelib(const(char)* name) { int seg = MsCoffObj_seg_drectve(); //dbg_printf("MsCoffObj_includelib(name *%s)\n",name); - SegData[seg]->SDbuf->write(" /DEFAULTLIB:\"", 14); - SegData[seg]->SDbuf->write(name, strlen(name)); - SegData[seg]->SDbuf->writeByte('"'); + SegData[seg].SDbuf.write(" /DEFAULTLIB:\"".ptr, 14); + SegData[seg].SDbuf.write(name, cast(uint)strlen(name)); + SegData[seg].SDbuf.writeByte('"'); return true; } @@ -1088,12 +1098,12 @@ bool MsCoffObj_includelib(const char *name) * Output linker directive name. */ -bool MsCoffObj_linkerdirective(const char *directive) +bool MsCoffObj_linkerdirective(const(char)* directive) { int seg = MsCoffObj_seg_drectve(); //dbg_printf("MsCoffObj::linkerdirective(directive *%s)\n",directive); - SegData[seg]->SDbuf->writeByte(' '); - SegData[seg]->SDbuf->write(directive, strlen(directive)); + SegData[seg].SDbuf.writeByte(' '); + SegData[seg].SDbuf.write(directive, cast(uint)strlen(directive)); return true; } @@ -1110,7 +1120,7 @@ bool MsCoffObj_allowZeroSize() * Embed string in executable. */ -void MsCoffObj_exestr(const char *p) +void MsCoffObj_exestr(const(char)* p) { //dbg_printf("MsCoffObj_exestr(char *%s)\n",p); } @@ -1119,7 +1129,7 @@ void MsCoffObj_exestr(const char *p) * Embed string in obj. */ -void MsCoffObj_user(const char *p) +void MsCoffObj_user(const(char)* p) { //dbg_printf("MsCoffObj_user(char *%s)\n",p); } @@ -1130,7 +1140,7 @@ void MsCoffObj_user(const char *p) void MsCoffObj_wkext(Symbol *s1,Symbol *s2) { - //dbg_printf("MsCoffObj_wkext(Symbol *%s,Symbol *s2)\n",s1->Sident,s2->Sident); + //dbg_printf("MsCoffObj_wkext(Symbol *%s,Symbol *s2)\n",s1.Sident.ptr,s2.Sident.ptr); } /******************************* @@ -1140,7 +1150,7 @@ void MsCoffObj_wkext(Symbol *s1,Symbol *s2) * twice for the same file. */ -void obj_filename(const char *modname) +void obj_filename(const(char)* modname) { //dbg_printf("obj_filename(char *%s)\n",modname); // Not supported by mscoff @@ -1195,13 +1205,13 @@ void MsCoffObj_setModuleCtorDtor(Symbol *sfunc, bool isCtor) { // Also see https://blogs.msdn.microsoft.com/vcblog/2006/10/20/crt-initialization/ // and http://www.codeguru.com/cpp/misc/misc/applicationcontrol/article.php/c6945/Running-Code-Before-and-After-Main.htm - const int align = I64 ? IMAGE_SCN_ALIGN_8BYTES : IMAGE_SCN_ALIGN_4BYTES; - const int attr = IMAGE_SCN_CNT_INITIALIZED_DATA | align | IMAGE_SCN_MEM_READ; + const int align_ = I64 ? IMAGE_SCN_ALIGN_8BYTES : IMAGE_SCN_ALIGN_4BYTES; + const int attr = IMAGE_SCN_CNT_INITIALIZED_DATA | align_ | IMAGE_SCN_MEM_READ; const int seg = MsCoffObj_getsegment(isCtor ? ".CRT$XCU" : ".CRT$XPU", attr); const int relflags = I64 ? CFoff | CFoffset64 : CFoff; - const int sz = MsCoffObj_reftoident(seg, SegData[seg]->SDoffset, sfunc, 0, relflags); - SegData[seg]->SDoffset += sz; + const int sz = MsCoffObj_reftoident(seg, SegData[seg].SDoffset, sfunc, 0, relflags); + SegData[seg].SDoffset += sz; } @@ -1214,30 +1224,30 @@ void MsCoffObj_setModuleCtorDtor(Symbol *sfunc, bool isCtor) void MsCoffObj_ehtables(Symbol *sfunc,uint size,Symbol *ehsym) { - //printf("MsCoffObj_ehtables(func = %s, handler table = %s) \n",sfunc->Sident, ehsym->Sident); + //printf("MsCoffObj_ehtables(func = %s, handler table = %s) \n",sfunc.Sident.ptr, ehsym.Sident.ptr); /* BUG: this should go into a COMDAT if sfunc is in a COMDAT * otherwise the duplicates aren't removed. */ - int align = I64 ? IMAGE_SCN_ALIGN_8BYTES : IMAGE_SCN_ALIGN_4BYTES; // align to NPTRSIZE + int align_ = I64 ? IMAGE_SCN_ALIGN_8BYTES : IMAGE_SCN_ALIGN_4BYTES; // align to _tysize[TYnptr] - // The size is sizeof(struct FuncTable) in deh2.d + // The size is (FuncTable).sizeof in deh2.d const int seg = MsCoffObj_getsegment("._deh$B", IMAGE_SCN_CNT_INITIALIZED_DATA | - align | + align_ | IMAGE_SCN_MEM_READ); - Outbuffer *buf = SegData[seg]->SDbuf; + Outbuffer *buf = SegData[seg].SDbuf; if (I64) - { MsCoffObj_reftoident(seg, buf->size(), sfunc, 0, CFoff | CFoffset64); - MsCoffObj_reftoident(seg, buf->size(), ehsym, 0, CFoff | CFoffset64); - buf->write64(sfunc->Ssize); + { MsCoffObj_reftoident(seg, buf.size(), sfunc, 0, CFoff | CFoffset64); + MsCoffObj_reftoident(seg, buf.size(), ehsym, 0, CFoff | CFoffset64); + buf.write64(sfunc.Ssize); } else - { MsCoffObj_reftoident(seg, buf->size(), sfunc, 0, CFoff); - MsCoffObj_reftoident(seg, buf->size(), ehsym, 0, CFoff); - buf->write32(sfunc->Ssize); + { MsCoffObj_reftoident(seg, buf.size(), sfunc, 0, CFoff); + MsCoffObj_reftoident(seg, buf.size(), ehsym, 0, CFoff); + buf.write32(cast(uint)sfunc.Ssize); } } @@ -1246,32 +1256,32 @@ void MsCoffObj_ehtables(Symbol *sfunc,uint size,Symbol *ehsym) * This gets called if this is the module with "extern (D) main()" in it. */ -private void emitSectionBrace(const char* segname, const char* symname, int attr, bool coffZeroBytes) +private void emitSectionBrace(const(char)* segname, const(char)* symname, int attr, bool coffZeroBytes) { - char name[16]; - strcat(strcpy(name, segname), "$A"); - const int seg_bg = MsCoffObj_getsegment(name, attr); + char[16] name = void; + strcat(strcpy(name.ptr, segname), "$A"); + const int seg_bg = MsCoffObj_getsegment(name.ptr, attr); - strcat(strcpy(name, segname), "$C"); - const int seg_en = MsCoffObj_getsegment(name, attr); + strcat(strcpy(name.ptr, segname), "$C"); + const int seg_en = MsCoffObj_getsegment(name.ptr, attr); /* Create symbol sym_beg that sits just before the .seg$B section */ - strcat(strcpy(name, symname), "_beg"); - Symbol *beg = symbol_name(name, SCglobal, tspvoid); - beg->Sseg = seg_bg; - beg->Soffset = 0; - symbuf->write(&beg, sizeof(beg)); + strcat(strcpy(name.ptr, symname), "_beg"); + Symbol *beg = symbol_name(name.ptr, SCglobal, tspvoid); + beg.Sseg = seg_bg; + beg.Soffset = 0; + symbuf.write(&beg, beg.sizeof); if (coffZeroBytes) // unnecessary, but required by current runtime MsCoffObj_bytes(seg_bg, 0, I64 ? 8 : 4, null); /* Create symbol sym_end that sits just after the .seg$B section */ - strcat(strcpy(name, symname), "_end"); - Symbol *end = symbol_name(name, SCglobal, tspvoid); - end->Sseg = seg_en; - end->Soffset = 0; - symbuf->write(&end, sizeof(end)); + strcat(strcpy(name.ptr, symname), "_end"); + Symbol *end = symbol_name(name.ptr, SCglobal, tspvoid); + end.Sseg = seg_en; + end.Soffset = 0; + symbuf.write(&end, (end).sizeof); if (coffZeroBytes) // unnecessary, but required by current runtime MsCoffObj_bytes(seg_en, 0, I64 ? 8 : 4, null); } @@ -1280,8 +1290,8 @@ void MsCoffObj_ehsections() { //printf("MsCoffObj_ehsections()\n"); - int align = I64 ? IMAGE_SCN_ALIGN_8BYTES : IMAGE_SCN_ALIGN_4BYTES; - int attr = IMAGE_SCN_CNT_INITIALIZED_DATA | align | IMAGE_SCN_MEM_READ; + int align_ = I64 ? IMAGE_SCN_ALIGN_8BYTES : IMAGE_SCN_ALIGN_4BYTES; + int attr = IMAGE_SCN_CNT_INITIALIZED_DATA | align_ | IMAGE_SCN_MEM_READ; emitSectionBrace("._deh", "_deh", attr, true); emitSectionBrace(".minfo", "_minfo", attr, true); @@ -1296,40 +1306,41 @@ void MsCoffObj_ehsections() emitSectionBrace(".bss", "_bss", attr, false); /*************************************************************************/ -#if 0 +static if (0) +{ { /* TLS sections */ - int align = I64 ? IMAGE_SCN_ALIGN_16BYTES : IMAGE_SCN_ALIGN_4BYTES; + int align_ = I64 ? IMAGE_SCN_ALIGN_16BYTES : IMAGE_SCN_ALIGN_4BYTES; int segbg = MsCoffObj_getsegment(".tls$AAA", IMAGE_SCN_CNT_INITIALIZED_DATA | - align | + align_ | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE); int segen = MsCoffObj_getsegment(".tls$AAC", IMAGE_SCN_CNT_INITIALIZED_DATA | - align | + align_ | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE); /* Create symbol _minfo_beg that sits just before the .tls$AAB section */ Symbol *minfo_beg = symbol_name("_tlsstart", SCglobal, tspvoid); - minfo_beg->Sseg = segbg; - minfo_beg->Soffset = 0; - symbuf->write(&minfo_beg, sizeof(minfo_beg)); + minfo_beg.Sseg = segbg; + minfo_beg.Soffset = 0; + symbuf.write(&minfo_beg, (minfo_beg).sizeof); MsCoffObj_bytes(segbg, 0, I64 ? 8 : 4, null); /* Create symbol _minfo_end that sits just after the .tls$AAB section */ Symbol *minfo_end = symbol_name("_tlsend", SCglobal, tspvoid); - minfo_end->Sseg = segen; - minfo_end->Soffset = 0; - symbuf->write(&minfo_end, sizeof(minfo_end)); + minfo_end.Sseg = segen; + minfo_end.Soffset = 0; + symbuf.write(&minfo_end, (minfo_end).sizeof); MsCoffObj_bytes(segen, 0, I64 ? 8 : 4, null); } -#endif +} } /********************************* @@ -1348,79 +1359,79 @@ int MsCoffObj_comdatsize(Symbol *s, targ_size_t symsize) int MsCoffObj_comdat(Symbol *s) { - uint align; + uint align_; - //printf("MsCoffObj_comdat(Symbol* %s)\n",s->Sident); + //printf("MsCoffObj_comdat(Symbol* %s)\n",s.Sident.ptr); //symbol_print(s); //symbol_debug(s); - if (tyfunc(s->ty())) + if (tyfunc(s.ty())) { - align = I64 ? 16 : 4; - s->Sseg = MsCoffObj_getsegment(".text", IMAGE_SCN_CNT_CODE | + align_ = I64 ? 16 : 4; + s.Sseg = MsCoffObj_getsegment(".text", IMAGE_SCN_CNT_CODE | IMAGE_SCN_LNK_COMDAT | (I64 ? IMAGE_SCN_ALIGN_16BYTES : IMAGE_SCN_ALIGN_4BYTES) | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ); } - else if ((s->ty() & mTYLINK) == mTYthread) + else if ((s.ty() & mTYLINK) == mTYthread) { - s->Sfl = FLtlsdata; - align = 16; - s->Sseg = MsCoffObj_getsegment(".tls$AAB", IMAGE_SCN_CNT_INITIALIZED_DATA | + s.Sfl = FLtlsdata; + align_ = 16; + s.Sseg = MsCoffObj_getsegment(".tls$AAB", IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_LNK_COMDAT | IMAGE_SCN_ALIGN_16BYTES | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE); - MsCoffObj_data_start(s, align, s->Sseg); + MsCoffObj_data_start(s, align_, s.Sseg); } else { - s->Sfl = FLdata; - align = 16; - s->Sseg = MsCoffObj_getsegment(".data$B", IMAGE_SCN_CNT_INITIALIZED_DATA | + s.Sfl = FLdata; + align_ = 16; + s.Sseg = MsCoffObj_getsegment(".data$B", IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_LNK_COMDAT | IMAGE_SCN_ALIGN_16BYTES | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE); } // find or create new segment - if (s->Salignment > align) - { SegData[s->Sseg]->SDalignment = s->Salignment; - assert(s->Salignment >= -1); + if (s.Salignment > align_) + { SegData[s.Sseg].SDalignment = s.Salignment; + assert(s.Salignment >= -1); } - s->Soffset = SegData[s->Sseg]->SDoffset; - if (s->Sfl == FLdata || s->Sfl == FLtlsdata) + s.Soffset = SegData[s.Sseg].SDoffset; + if (s.Sfl == FLdata || s.Sfl == FLtlsdata) { // Code symbols are 'published' by MsCoffObj_func_start() - MsCoffObj_pubdef(s->Sseg,s,s->Soffset); + MsCoffObj_pubdef(s.Sseg,s,s.Soffset); searchfixlist(s); // backpatch any refs to this symbol } - return s->Sseg; + return s.Sseg; } int MsCoffObj_readonly_comdat(Symbol *s) { - //printf("MsCoffObj_readonly_comdat(Symbol* %s)\n",s->Sident); + //printf("MsCoffObj_readonly_comdat(Symbol* %s)\n",s.Sident.ptr); //symbol_print(s); symbol_debug(s); - s->Sfl = FLdata; - s->Sseg = MsCoffObj_getsegment(".rdata", IMAGE_SCN_CNT_INITIALIZED_DATA | + s.Sfl = FLdata; + s.Sseg = MsCoffObj_getsegment(".rdata", IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_LNK_COMDAT | IMAGE_SCN_ALIGN_16BYTES | IMAGE_SCN_MEM_READ); - SegData[s->Sseg]->SDalignment = s->Salignment; - assert(s->Salignment >= -1); - s->Soffset = SegData[s->Sseg]->SDoffset; - if (s->Sfl == FLdata || s->Sfl == FLtlsdata) + SegData[s.Sseg].SDalignment = s.Salignment; + assert(s.Salignment >= -1); + s.Soffset = SegData[s.Sseg].SDoffset; + if (s.Sfl == FLdata || s.Sfl == FLtlsdata) { // Code symbols are 'published' by MsCoffObj_func_start() - MsCoffObj_pubdef(s->Sseg,s,s->Soffset); + MsCoffObj_pubdef(s.Sseg,s,s.Soffset); searchfixlist(s); // backpatch any refs to this symbol } - return s->Sseg; + return s.Sseg; } @@ -1442,7 +1453,7 @@ int MsCoffObj_jmpTableSegment(Symbol *s) * segment index of found or newly created segment */ -segidx_t MsCoffObj_getsegment(const char *sectname, uint flags) +segidx_t MsCoffObj_getsegment(const(char)* sectname, uint flags) { //printf("getsegment(%s)\n", sectname); assert(strlen(sectname) <= 8); // so it won't go into string_table @@ -1450,8 +1461,8 @@ segidx_t MsCoffObj_getsegment(const char *sectname, uint flags) { for (segidx_t seg = 1; seg <= seg_count; seg++) { seg_data *pseg = SegData[seg]; - if (!(ScnhdrTab[pseg->SDshtidx].Characteristics & IMAGE_SCN_LNK_COMDAT) && - strncmp(cast(const char *)ScnhdrTab[pseg->SDshtidx].Name, sectname, 8) == 0) + if (!(ScnhdrTab[pseg.SDshtidx].Characteristics & IMAGE_SCN_LNK_COMDAT) && + strncmp(cast(const(char)* )ScnhdrTab[pseg.SDshtidx].Name, sectname, 8) == 0) { //printf("\t%s\n", sectname); return seg; // return existing segment @@ -1462,7 +1473,7 @@ segidx_t MsCoffObj_getsegment(const char *sectname, uint flags) segidx_t seg = MsCoffObj_getsegment2(MsCoffObj_addScnhdr(sectname, flags)); //printf("\tseg_count = %d\n", seg_count); - //printf("\tseg = %d, %d, %s\n", seg, SegData[seg]->SDshtidx, ScnhdrTab[SegData[seg]->SDshtidx].s_name); + //printf("\tseg = %d, %d, %s\n", seg, SegData[seg].SDshtidx, ScnhdrTab[SegData[seg].SDshtidx].s_name); return seg; } @@ -1476,47 +1487,53 @@ segidx_t MsCoffObj_getsegment2(IDXSEC shtidx) if (seg_count >= seg_max) { // need more room in segment table seg_max += 10; - SegData = cast(seg_data **)mem_realloc(SegData,seg_max * sizeof(seg_data *)); - memset(&SegData[seg_count], 0, (seg_max - seg_count) * sizeof(seg_data *)); + SegData = cast(seg_data **)mem_realloc(SegData,seg_max * (seg_data *).sizeof); + memset(&SegData[seg_count], 0, (seg_max - seg_count) * (seg_data *).sizeof); } assert(seg_count < seg_max); if (SegData[seg]) { seg_data *pseg = SegData[seg]; - Outbuffer *b1 = pseg->SDbuf; - Outbuffer *b2 = pseg->SDrel; - memset(pseg, 0, sizeof(seg_data)); + Outbuffer *b1 = pseg.SDbuf; + Outbuffer *b2 = pseg.SDrel; + memset(pseg, 0, (seg_data).sizeof); if (b1) - b1->setsize(0); + b1.setsize(0); else { - b1 = new Outbuffer(4096); - b1->reserve(4096); + b1 = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); + assert(b1); + b1.enlarge(4096); + b1.reserve(4096); } if (b2) - b2->setsize(0); - pseg->SDbuf = b1; - pseg->SDrel = b2; + b2.setsize(0); + pseg.SDbuf = b1; + pseg.SDrel = b2; } else { - seg_data *pseg = (seg_data *)mem_calloc(sizeof(seg_data)); + seg_data *pseg = cast(seg_data *)mem_calloc((seg_data).sizeof); SegData[seg] = pseg; if (!(ScnhdrTab[shtidx].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)) - { pseg->SDbuf = new Outbuffer(4096); - pseg->SDbuf->reserve(4096); + + { + pseg.SDbuf = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); + assert(pseg.SDbuf); + pseg.SDbuf.enlarge(4096); + pseg.SDbuf.reserve(4096); } } - //dbg_printf("\tNew segment - %d size %d\n", seg,SegData[seg]->SDbuf); + //dbg_printf("\tNew segment - %d size %d\n", seg,SegData[seg].SDbuf); seg_data *pseg = SegData[seg]; - pseg->SDseg = seg; - pseg->SDoffset = 0; + pseg.SDseg = seg; + pseg.SDoffset = 0; - pseg->SDshtidx = shtidx; - pseg->SDaranges_offset = 0; - pseg->SDlinnum_count = 0; + pseg.SDshtidx = shtidx; + pseg.SDaranges_offset = 0; + pseg.SDlinnum_count = 0; //printf("seg_count = %d\n", seg_count); return seg; @@ -1528,10 +1545,10 @@ segidx_t MsCoffObj_getsegment2(IDXSEC shtidx) * scnhdr number for added scnhdr */ -IDXSEC MsCoffObj_addScnhdr(const char *scnhdr_name, uint flags) +IDXSEC MsCoffObj_addScnhdr(const(char)* scnhdr_name, uint flags) { IMAGE_SECTION_HEADER sec; - memset(&sec, 0, sizeof(sec)); + memset(&sec, 0, (sec).sizeof); size_t len = strlen(scnhdr_name); if (len > 8) { // Use /nnnn form @@ -1539,9 +1556,9 @@ IDXSEC MsCoffObj_addScnhdr(const char *scnhdr_name, uint flags) sprintf(cast(char *)sec.Name, "/%d", idx); } else - memcpy(sec.Name, scnhdr_name, len); + memcpy(sec.Name.ptr, scnhdr_name, len); sec.Characteristics = flags; - ScnhdrBuf->write(cast(void *)&sec, sizeof(sec)); + ScnhdrBuf.write(cast(void *)&sec, (sec).sizeof); return ++scnhdr_cnt; } @@ -1606,7 +1623,6 @@ seg_data *MsCoffObj_tlsseg_data() { // specific for Mach-O assert(0); - return null; } /************************************* @@ -1641,7 +1657,7 @@ segidx_t MsCoffObj_seg_pdata_comdat(Symbol *sfunc) IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_READ | IMAGE_SCN_LNK_COMDAT); - SegData[seg]->SDassocseg = sfunc->Sseg; + SegData[seg].SDassocseg = sfunc.Sseg; return seg; } @@ -1651,7 +1667,7 @@ segidx_t MsCoffObj_seg_xdata_comdat(Symbol *sfunc) IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_READ | IMAGE_SCN_LNK_COMDAT); - SegData[seg]->SDassocseg = sfunc->Sseg; + SegData[seg].SDassocseg = sfunc.Sseg; return seg; } @@ -1670,13 +1686,13 @@ segidx_t MsCoffObj_seg_debugS() segidx_t MsCoffObj_seg_debugS_comdat(Symbol *sfunc) { - //printf("associated with seg %d\n", sfunc->Sseg); + //printf("associated with seg %d\n", sfunc.Sseg); segidx_t seg = MsCoffObj_getsegment(".debug$S", IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_1BYTES | IMAGE_SCN_MEM_READ | IMAGE_SCN_LNK_COMDAT | IMAGE_SCN_MEM_DISCARDABLE); - SegData[seg]->SDassocseg = sfunc->Sseg; + SegData[seg].SDassocseg = sfunc.Sseg; return seg; } @@ -1705,11 +1721,12 @@ segidx_t MsCoffObj_seg_drectve() * Output an alias definition record. */ -void MsCoffObj_alias(const char *n1,const char *n2) +void MsCoffObj_alias(const(char)* n1,const(char)* n2) { //printf("MsCoffObj_alias(%s,%s)\n",n1,n2); assert(0); -#if NOT_DONE +static if (0) // NOT_DONE +{ uint len; char *buffer; @@ -1717,15 +1734,15 @@ void MsCoffObj_alias(const char *n1,const char *n2) len = obj_namestring(buffer,n1); len += obj_namestring(buffer + len,n2); objrecord(ALIAS,buffer,len); -#endif +} } char *unsstr(uint value) { - static char buffer [64]; + __gshared char[64] buffer; - sprintf (buffer, "%d", value); - return buffer; + sprintf (buffer.ptr, "%d", value); + return buffer.ptr; } /******************************* @@ -1739,19 +1756,21 @@ char *obj_mangle2(Symbol *s,char *dest) size_t len; char *name; - //printf("MsCoffObj_mangle(s = %p, '%s'), mangle = x%x\n",s,s->Sident,type_mangle(s->Stype)); + //printf("MsCoffObj_mangle(s = %p, '%s'), mangle = x%x\n",s,s.Sident.ptr,type_mangle(s.Stype)); symbol_debug(s); assert(dest); -#if SCPP - name = CPP ? cpp_mangle(s) : s->Sident; -#elif MARS - name = cpp_mangle(s); -#else - name = s->Sident; -#endif + +version (SCPP) + name = CPP ? cpp_mangle(s) : s.Sident.ptr; +else version (MARS) + // C++ name mangling is handled by front end + name = s.Sident.ptr; +else + name = s.Sident.ptr; + len = strlen(name); // # of bytes in name //dbg_printf("len %d\n",len); - switch (type_mangle(s->Stype)) + switch (type_mangle(s.Stype)) { case mTYman_pas: // if upper case case mTYman_for: @@ -1762,10 +1781,10 @@ char *obj_mangle2(Symbol *s,char *dest) break; case mTYman_std: if (!(config.flags4 & CFG4oldstdmangle) && - config.exe == EX_WIN32 && tyfunc(s->ty()) && - !variadic(s->Stype)) + config.exe == EX_WIN32 && tyfunc(s.ty()) && + !variadic(s.Stype)) { - char *pstr = unsstr(type_paramsize(s->Stype)); + char *pstr = unsstr(type_paramsize(s.Stype)); size_t pstrlen = strlen(pstr); size_t prelen = I32 ? 1 : 0; size_t destlen = prelen + len + 1 + pstrlen + 1; @@ -1778,7 +1797,8 @@ char *obj_mangle2(Symbol *s,char *dest) memcpy(dest + prelen + 1 + len, pstr, pstrlen + 1); break; } - // fall through + goto case; + case mTYman_cpp: case mTYman_sys: case_mTYman_c64: @@ -1794,17 +1814,18 @@ char *obj_mangle2(Symbol *s,char *dest) goto case_mTYman_c64; // Prepend _ to identifier if (len >= DEST_LEN - 1) - dest = (char *)mem_malloc(1 + len + 1); + dest = cast(char *)mem_malloc(1 + len + 1); dest[0] = '_'; memcpy(dest + 1,name,len+1);// copy in name and trailing 0 break; default: -#ifdef DEBUG - printf("mangling %x\n",type_mangle(s->Stype)); +debug +{ + printf("mangling %x\n",type_mangle(s.Stype)); symbol_print(s); -#endif - printf("%d\n", type_mangle(s->Stype)); +} + printf("%d\n", type_mangle(s.Stype)); assert(0); } //dbg_printf("\t %s\n",dest); @@ -1817,13 +1838,13 @@ char *obj_mangle2(Symbol *s,char *dest) void MsCoffObj_export_symbol(Symbol *s,uint argsize) { - char dest[DEST_LEN+1]; - char *destr = obj_mangle2(s, dest); + char[DEST_LEN+1] dest = void; + char *destr = obj_mangle2(s, dest.ptr); int seg = MsCoffObj_seg_drectve(); - //printf("MsCoffObj_export_symbol(%s,%d)\n",s->Sident,argsize); - SegData[seg]->SDbuf->write(" /EXPORT:", 9); - SegData[seg]->SDbuf->write(dest, strlen(dest)); + //printf("MsCoffObj_export_symbol(%s,%d)\n",s.Sident.ptr,argsize); + SegData[seg].SDbuf.write(" /EXPORT:".ptr, 9); + SegData[seg].SDbuf.write(dest.ptr, cast(uint)strlen(dest.ptr)); } /******************************* @@ -1843,25 +1864,25 @@ segidx_t MsCoffObj_data_start(Symbol *sdata, targ_size_t datasize, segidx_t seg) { targ_size_t alignbytes; - //printf("MsCoffObj_data_start(%s,size %d,seg %d)\n",sdata->Sident,(int)datasize,seg); + //printf("MsCoffObj_data_start(%s,size %d,seg %d)\n",sdata.Sident.ptr,(int)datasize,seg); //symbol_print(sdata); - assert(sdata->Sseg); - if (sdata->Sseg == UNKNOWN) // if we don't know then there - sdata->Sseg = seg; // wasn't any segment override + assert(sdata.Sseg); + if (sdata.Sseg == UNKNOWN) // if we don't know then there + sdata.Sseg = seg; // wasn't any segment override else - seg = sdata->Sseg; + seg = sdata.Sseg; targ_size_t offset = Offset(seg); - if (sdata->Salignment > 0) - { if (SegData[seg]->SDalignment < sdata->Salignment) - SegData[seg]->SDalignment = sdata->Salignment; - alignbytes = ((offset + sdata->Salignment - 1) & ~(sdata->Salignment - 1)) - offset; + if (sdata.Salignment > 0) + { if (SegData[seg].SDalignment < sdata.Salignment) + SegData[seg].SDalignment = sdata.Salignment; + alignbytes = ((offset + sdata.Salignment - 1) & ~(sdata.Salignment - 1)) - offset; } else alignbytes = _align(datasize, offset) - offset; if (alignbytes) MsCoffObj_lidata(seg, offset, alignbytes); - sdata->Soffset = offset + alignbytes; + sdata.Soffset = offset + alignbytes; return seg; } @@ -1874,17 +1895,17 @@ segidx_t MsCoffObj_data_start(Symbol *sdata, targ_size_t datasize, segidx_t seg) void MsCoffObj_func_start(Symbol *sfunc) { - //printf("MsCoffObj_func_start(%s)\n",sfunc->Sident); + //printf("MsCoffObj_func_start(%s)\n",sfunc.Sident.ptr); symbol_debug(sfunc); - assert(sfunc->Sseg); - if (sfunc->Sseg == UNKNOWN) - sfunc->Sseg = CODE; - //printf("sfunc->Sseg %d CODE %d cseg %d Coffset x%x\n",sfunc->Sseg,CODE,cseg,Offset(cseg)); - cseg = sfunc->Sseg; + assert(sfunc.Sseg); + if (sfunc.Sseg == UNKNOWN) + sfunc.Sseg = CODE; + //printf("sfunc.Sseg %d CODE %d cseg %d Coffset x%x\n",sfunc.Sseg,CODE,cseg,Offset(cseg)); + cseg = sfunc.Sseg; assert(cseg == CODE || cseg > UDATA); MsCoffObj_pubdef(cseg, sfunc, Offset(cseg)); - sfunc->Soffset = Offset(cseg); + sfunc.Soffset = Offset(cseg); if (config.fulltypes) cv8_func_start(sfunc); @@ -1897,7 +1918,7 @@ void MsCoffObj_func_start(Symbol *sfunc) void MsCoffObj_func_term(Symbol *sfunc) { //dbg_printf("MsCoffObj_func_term(%s) offset %x, Coffset %x symidx %d\n", -// sfunc->Sident, sfunc->Soffset,Offset(cseg),sfunc->Sxtrnnum); +// sfunc.Sident.ptr, sfunc.Soffset,Offset(cseg),sfunc.Sxtrnnum); if (config.fulltypes) cv8_func_term(sfunc); @@ -1905,38 +1926,37 @@ void MsCoffObj_func_term(Symbol *sfunc) /******************************** * Output a public definition. - * Input: + * Params: * seg = segment index that symbol is defined in - * s -> symbol + * s = symbol * offset = offset of name within segment */ void MsCoffObj_pubdef(segidx_t seg, Symbol *s, targ_size_t offset) { -#if 0 - printf("MsCoffObj_pubdef(%d:x%x s=%p, %s)\n", seg, cast(int)offset, s, s->Sident); + //printf("MsCoffObj_pubdef(%d:x%x s=%p, %s)\n", seg, cast(int)offset, s, s.Sident.ptr); //symbol_print(s); -#endif + symbol_debug(s); - s->Soffset = offset; - s->Sseg = seg; - switch (s->Sclass) + s.Soffset = offset; + s.Sseg = seg; + switch (s.Sclass) { case SCglobal: case SCinline: - symbuf->write(&s, sizeof(s)); + symbuf.write(&s, (s).sizeof); break; case SCcomdat: case SCcomdef: - symbuf->write(&s, sizeof(s)); + symbuf.write(&s, (s).sizeof); break; default: - symbuf->write(&s, sizeof(s)); + symbuf.write(&s, (s).sizeof); break; } - //printf("%p\n", *(void**)symbuf->buf); - s->Sxtrnnum = 1; + //printf("%p\n", *(void**)symbuf.buf); + s.Sxtrnnum = 1; } void MsCoffObj_pubdefsize(int seg, Symbol *s, targ_size_t offset, targ_size_t symsize) @@ -1954,12 +1974,12 @@ void MsCoffObj_pubdefsize(int seg, Symbol *s, targ_size_t offset, targ_size_t sy * NOTE: Numbers will not be linear. */ -int MsCoffObj_external_def(const char *name) +int MsCoffObj_external_def(const(char)* name) { //printf("MsCoffObj_external_def('%s')\n",name); assert(name); Symbol *s = symbol_name(name, SCextern, tspvoid); - symbuf->write(&s, sizeof(s)); + symbuf.write(&s, (s).sizeof); return 0; } @@ -1976,48 +1996,48 @@ int MsCoffObj_external_def(const char *name) int MsCoffObj_external(Symbol *s) { - //printf("MsCoffObj_external('%s') %x\n",s->Sident,s->Svalue); + //printf("MsCoffObj_external('%s') %x\n",s.Sident.ptr,s.Svalue); symbol_debug(s); - symbuf->write(&s, sizeof(s)); - s->Sxtrnnum = 1; + symbuf.write(&s, (s).sizeof); + s.Sxtrnnum = 1; return 1; } /******************************* * Output a common block definition. - * Input: - * p -> external identifier - * size size in bytes of each elem - * count number of elems + * Params: + * s = Symbol for common block + * size = size in bytes of each elem + * count = number of elems * Returns: * Symbol table index for symbol */ int MsCoffObj_common_block(Symbol *s,targ_size_t size,targ_size_t count) { - //printf("MsCoffObj_common_block('%s', size=%d, count=%d)\n",s->Sident,size,count); + //printf("MsCoffObj_common_block('%s', size=%d, count=%d)\n",s.Sident.ptr,size,count); symbol_debug(s); // can't have code or thread local comdef's - assert(!(s->ty() & mTYthread)); + assert(!(s.ty() & mTYthread)); - s->Sfl = FLudata; - uint align = 16; - s->Sseg = MsCoffObj_getsegment(".bss$B", IMAGE_SCN_CNT_UNINITIALIZED_DATA | + s.Sfl = FLudata; + uint align_ = 16; + s.Sseg = MsCoffObj_getsegment(".bss$B", IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_LNK_COMDAT | IMAGE_SCN_ALIGN_16BYTES | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE); - if (s->Salignment > align) + if (s.Salignment > align_) { - SegData[s->Sseg]->SDalignment = s->Salignment; - assert(s->Salignment >= -1); + SegData[s.Sseg].SDalignment = s.Salignment; + assert(s.Salignment >= -1); } - s->Soffset = SegData[s->Sseg]->SDoffset; - SegData[s->Sseg]->SDsym = s; - SegData[s->Sseg]->SDoffset += count * size; + s.Soffset = SegData[s.Sseg].SDoffset; + SegData[s.Sseg].SDsym = s; + SegData[s.Sseg].SDoffset += count * size; - MsCoffObj_pubdef(s->Sseg, s, s->Soffset); + MsCoffObj_pubdef(s.Sseg, s, s.Soffset); searchfixlist(s); // backpatch any refs to this symbol return 1; // should return void @@ -2035,7 +2055,7 @@ int MsCoffObj_common_block(Symbol *s, int flag, targ_size_t size, targ_size_t co void MsCoffObj_write_zeros(seg_data *pseg, targ_size_t count) { - MsCoffObj_lidata(pseg->SDseg, pseg->SDoffset, count); + MsCoffObj_lidata(pseg.SDseg, pseg.SDoffset, count); } /*************************************** @@ -2047,14 +2067,14 @@ void MsCoffObj_write_zeros(seg_data *pseg, targ_size_t count) void MsCoffObj_lidata(segidx_t seg,targ_size_t offset,targ_size_t count) { //printf("MsCoffObj_lidata(%d,%x,%d)\n",seg,offset,count); - size_t idx = SegData[seg]->SDshtidx; + size_t idx = SegData[seg].SDshtidx; if ((ScnhdrTab[idx].Characteristics) & IMAGE_SCN_CNT_UNINITIALIZED_DATA) { // Use SDoffset to record size of bss section - SegData[seg]->SDoffset += count; + SegData[seg].SDoffset += count; } else { - MsCoffObj_bytes(seg, offset, count, null); + MsCoffObj_bytes(seg, offset, cast(uint)count, null); } } @@ -2062,27 +2082,27 @@ void MsCoffObj_lidata(segidx_t seg,targ_size_t offset,targ_size_t count) * Append byte to segment. */ -void MsCoffObj_write_byte(seg_data *pseg, uint byte) +void MsCoffObj_write_byte(seg_data *pseg, uint byte_) { - MsCoffObj_byte(pseg->SDseg, pseg->SDoffset, byte); + MsCoffObj_byte(pseg.SDseg, pseg.SDoffset, byte_); } /************************************ - * Output byte to object file. + * Output byte_ to object file. */ -void MsCoffObj_byte(segidx_t seg,targ_size_t offset,uint byte) +void MsCoffObj_byte(segidx_t seg,targ_size_t offset,uint byte_) { - Outbuffer *buf = SegData[seg]->SDbuf; - int save = buf->size(); - //dbg_printf("MsCoffObj_byte(seg=%d, offset=x%lx, byte=x%x)\n",seg,offset,byte); - buf->setsize(offset); - buf->writeByte(byte); + Outbuffer *buf = SegData[seg].SDbuf; + int save = cast(int)buf.size(); + //dbg_printf("MsCoffObj_byte(seg=%d, offset=x%lx, byte=x%x)\n",seg,offset,byte_); + buf.setsize(cast(uint)offset); + buf.writeByte(byte_); if (save > offset+1) - buf->setsize(save); + buf.setsize(save); else - SegData[seg]->SDoffset = offset+1; - //dbg_printf("\tsize now %d\n",buf->size()); + SegData[seg].SDoffset = offset+1; + //dbg_printf("\tsize now %d\n",buf.size()); } /*********************************** @@ -2091,7 +2111,7 @@ void MsCoffObj_byte(segidx_t seg,targ_size_t offset,uint byte) void MsCoffObj_write_bytes(seg_data *pseg, uint nbytes, void *p) { - MsCoffObj_bytes(pseg->SDseg, pseg->SDoffset, nbytes, p); + MsCoffObj_bytes(pseg.SDseg, pseg.SDoffset, nbytes, p); } /************************************ @@ -2102,37 +2122,38 @@ void MsCoffObj_write_bytes(seg_data *pseg, uint nbytes, void *p) uint MsCoffObj_bytes(segidx_t seg, targ_size_t offset, uint nbytes, void *p) { -#if 0 +static if (0) +{ if (!(seg >= 0 && seg <= seg_count)) { printf("MsCoffObj_bytes: seg = %d, seg_count = %d\n", seg, seg_count); - *(char*)0=0; + *cast(char*)0=0; } -#endif +} assert(seg >= 0 && seg <= seg_count); - Outbuffer *buf = SegData[seg]->SDbuf; + Outbuffer *buf = SegData[seg].SDbuf; if (buf == null) { //printf("MsCoffObj_bytes(seg=%d, offset=x%llx, nbytes=%d, p=x%x)\n", seg, offset, nbytes, p); //raise(SIGSEGV); assert(buf != null); } - int save = buf->size(); + int save = cast(int)buf.size(); //dbg_printf("MsCoffObj_bytes(seg=%d, offset=x%lx, nbytes=%d, p=x%x)\n", //seg,offset,nbytes,p); - buf->setsize(offset); - buf->reserve(nbytes); + buf.setsize(cast(uint)offset); + buf.reserve(nbytes); if (p) { - buf->writen(p,nbytes); + buf.writen(p,nbytes); } else { // Zero out the bytes - buf->clearn(nbytes); + buf.clearn(nbytes); } if (save > offset+nbytes) - buf->setsize(save); + buf.setsize(save); else - SegData[seg]->SDoffset = offset+nbytes; + SegData[seg].SDoffset = offset+nbytes; return nbytes; } @@ -2146,50 +2167,44 @@ void MsCoffObj_addrel(segidx_t seg, targ_size_t offset, Symbol *targsym, //printf("addrel()\n"); if (!targsym) { // Generate one - targsym = symbol_generate(SCstatic, tsint); - targsym->Sseg = targseg; - targsym->Soffset = val; - symbuf->write(&targsym, sizeof(targsym)); + targsym = symbol_generate(SCstatic, tstypes[TYint]); + targsym.Sseg = targseg; + targsym.Soffset = val; + symbuf.write(&targsym, (targsym).sizeof); } - Relocation rel; + Relocation rel = void; rel.offset = offset; rel.targsym = targsym; rel.targseg = targseg; - rel.rtype = rtype; + rel.rtype = cast(ubyte)rtype; rel.funcsym = funcsym_p; - rel.val = val; + rel.val = cast(short)val; seg_data *pseg = SegData[seg]; - if (!pseg->SDrel) - pseg->SDrel = new Outbuffer(); - pseg->SDrel->write(&rel, sizeof(rel)); + if (!pseg.SDrel) + { + pseg.SDrel = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); + assert(pseg.SDrel); + } + pseg.SDrel.write(&rel, (rel).sizeof); } /**************************************** * Sort the relocation entry buffer. */ -#if __DMC__ -private int __cdecl rel_fp(const void *e1, const void *e2) -{ Relocation *r1 = cast(Relocation *)e1; - Relocation *r2 = cast(Relocation *)e2; - - return r1->offset - r2->offset; -} -#else -extern "C" { -private int rel_fp(const void *e1, const void *e2) +extern (C) { +private int rel_fp(scope const(void*) e1, scope const(void*) e2) { Relocation *r1 = cast(Relocation *)e1; Relocation *r2 = cast(Relocation *)e2; - return r1->offset - r2->offset; + return cast(int)(r1.offset - r2.offset); } } -#endif void mach_relsort(Outbuffer *buf) { - qsort(buf->buf, buf->size() / sizeof(Relocation), sizeof(Relocation), &rel_fp); + qsort(buf.buf, buf.size() / (Relocation).sizeof, (Relocation).sizeof, &rel_fp); } /******************************* @@ -2202,21 +2217,22 @@ void mach_relsort(Outbuffer *buf) * Example: * int *abc = &def[3]; * to allocate storage: - * MsCoffObj_reftodatseg(DATA,offset,3 * sizeof(int *),UDATA); + * MsCoffObj_reftodatseg(DATA,offset,3 * (int *).sizeof,UDATA); */ void MsCoffObj_reftodatseg(segidx_t seg,targ_size_t offset,targ_size_t val, uint targetdatum,int flags) { - Outbuffer *buf = SegData[seg]->SDbuf; - int save = buf->size(); - buf->setsize(offset); -#if 0 + Outbuffer *buf = SegData[seg].SDbuf; + int save = cast(int)buf.size(); + buf.setsize(cast(uint)offset); +static if (0) +{ printf("MsCoffObj_reftodatseg(seg:offset=%d:x%llx, val=x%llx, targetdatum %x, flags %x )\n", seg,offset,val,targetdatum,flags); -#endif +} assert(seg != 0); - if (SegData[seg]->isCode() && SegData[targetdatum]->isCode()) + if (SegData[seg].isCode() && SegData[targetdatum].isCode()) { assert(0); } @@ -2225,15 +2241,15 @@ void MsCoffObj_reftodatseg(segidx_t seg,targ_size_t offset,targ_size_t val, { if (flags & CFoffset64) { - buf->write64(val); + buf.write64(val); if (save > offset + 8) - buf->setsize(save); + buf.setsize(save); return; } } - buf->write32(val); + buf.write32(cast(int)val); if (save > offset + 4) - buf->setsize(save); + buf.setsize(save); } /******************************* @@ -2250,27 +2266,27 @@ void MsCoffObj_reftocodeseg(segidx_t seg,targ_size_t offset,targ_size_t val) { //printf("MsCoffObj_reftocodeseg(seg=%d, offset=x%lx, val=x%lx )\n",seg,cast(uint)offset,cast(uint)val); assert(seg > 0); - Outbuffer *buf = SegData[seg]->SDbuf; - int save = buf->size(); - buf->setsize(offset); - val -= funcsym_p->Soffset; + Outbuffer *buf = SegData[seg].SDbuf; + int save = cast(int)buf.size(); + buf.setsize(cast(uint)offset); + val -= funcsym_p.Soffset; if (I32) MsCoffObj_addrel(seg, offset, funcsym_p, 0, RELaddr, 0); // MsCoffObj_addrel(seg, offset, funcsym_p, 0, RELaddr); // if (I64) -// buf->write64(val); +// buf.write64(val); // else - buf->write32(val); + buf.write32(cast(int)val); if (save > offset + 4) - buf->setsize(save); + buf.setsize(save); } /******************************* * Refer to an identifier. - * Input: + * Params: * seg = where the address is going (CODE or DATA) * offset = offset within seg - * s -> Symbol table entry for identifier + * s = Symbol table entry for identifier * val = displacement from identifier * flags = CFselfrel: self-relative * CFseg: get segment @@ -2287,15 +2303,16 @@ int MsCoffObj_reftoident(segidx_t seg, targ_size_t offset, Symbol *s, targ_size_ int refsize = (flags & CFoffset64) ? 8 : 4; if (flags & CFseg) refsize += 2; -#if 0 +static if (0) +{ printf("\nMsCoffObj_reftoident('%s' seg %d, offset x%llx, val x%llx, flags x%x)\n", - s->Sident,seg,cast(ulong)offset,cast(ulong)val,flags); + s.Sident.ptr,seg,cast(ulong)offset,cast(ulong)val,flags); //printf("refsize = %d\n", refsize); - //dbg_printf("Sseg = %d, Sxtrnnum = %d\n",s->Sseg,s->Sxtrnnum); + //dbg_printf("Sseg = %d, Sxtrnnum = %d\n",s.Sseg,s.Sxtrnnum); //symbol_print(s); -#endif +} assert(seg > 0); - if (s->Sclass != SClocstat && !s->Sxtrnnum) + if (s.Sclass != SClocstat && !s.Sxtrnnum) { // It may get defined later as public or local, so defer size_t numbyteswritten = addtofixlist(s, offset, seg, val, flags); assert(numbyteswritten == refsize); @@ -2304,8 +2321,8 @@ int MsCoffObj_reftoident(segidx_t seg, targ_size_t offset, Symbol *s, targ_size_ { if (I64 || I32) { - //if (s->Sclass != SCcomdat) - //val += s->Soffset; + //if (s.Sclass != SCcomdat) + //val += s.Soffset; int v = 0; if (flags & CFpc32) { @@ -2329,29 +2346,32 @@ int MsCoffObj_reftoident(segidx_t seg, targ_size_t offset, Symbol *s, targ_size_ } else { - if (SegData[seg]->isCode() && flags & CFselfrel) + if (SegData[seg].isCode() && flags & CFselfrel) { seg_data *pseg = SegData[jumpTableSeg]; L1: val -= offset + 4; MsCoffObj_addrel(seg, offset, null, jumpTableSeg, RELrel, 0); } - else if (SegData[seg]->isCode() && - ((s->Sclass != SCextern && SegData[s->Sseg]->isCode()) || s->Sclass == SClocstat || s->Sclass == SCstatic)) + else if (SegData[seg].isCode() && + ((s.Sclass != SCextern && SegData[s.Sseg].isCode()) || s.Sclass == SClocstat || s.Sclass == SCstatic)) { - val += s->Soffset; - MsCoffObj_addrel(seg, offset, null, s->Sseg, RELaddr, 0); + val += s.Soffset; + MsCoffObj_addrel(seg, offset, null, s.Sseg, RELaddr, 0); } - else if (SegData[seg]->isCode() && !tyfunc(s->ty())) + else if (SegData[seg].isCode() && !tyfunc(s.ty())) { seg_data *pseg = SegData[pointersSeg]; if (!indirectsymbuf2) - indirectsymbuf2 = new Outbuffer(); + { + indirectsymbuf2 = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); + assert(indirectsymbuf2); + } else { // Look through indirectsym to see if it is already there - int n = indirectsymbuf2->size() / sizeof(Symbol *); - Symbol **psym = (Symbol **)indirectsymbuf2->buf; + int n = cast(int)(indirectsymbuf2.size() / (Symbol *).sizeof); + Symbol **psym = cast(Symbol **)indirectsymbuf2.buf; for (int i = 0; i < n; i++) { // Linear search, pretty pathetic if (s == psym[i]) @@ -2361,39 +2381,39 @@ int MsCoffObj_reftoident(segidx_t seg, targ_size_t offset, Symbol *s, targ_size_ } } - val = pseg->SDbuf->size(); - pseg->SDbuf->writezeros(NPTRSIZE); + val = pseg.SDbuf.size(); + pseg.SDbuf.writezeros(_tysize[TYnptr]); // Add symbol s to indirectsymbuf2 - indirectsymbuf2->write(&s, sizeof(Symbol *)); + indirectsymbuf2.write(&s, (Symbol *).sizeof); L2: - //printf("MsCoffObj_reftoident: seg = %d, offset = x%x, s = %s, val = x%x, pointersSeg = %d\n", seg, offset, s->Sident, val, pointersSeg); + //printf("MsCoffObj_reftoident: seg = %d, offset = x%x, s = %s, val = x%x, pointersSeg = %d\n", seg, offset, s.Sident.ptr, val, pointersSeg); MsCoffObj_addrel(seg, offset, null, pointersSeg, RELaddr, 0); } else - { //val -= s->Soffset; + { //val -= s.Soffset; // MsCoffObj_addrel(seg, offset, s, 0, RELaddr, 0); } } - Outbuffer *buf = SegData[seg]->SDbuf; - int save = buf->size(); - buf->setsize(offset); + Outbuffer *buf = SegData[seg].SDbuf; + int save = cast(int)buf.size(); + buf.setsize(cast(uint)offset); //printf("offset = x%llx, val = x%llx\n", offset, val); if (refsize == 8) - buf->write64(val); + buf.write64(val); else if (refsize == 4) - buf->write32(val); + buf.write32(cast(int)val); else if (refsize == 6) { - buf->write32(val); - buf->writeWord(0); + buf.write32(cast(int)val); + buf.writeWord(0); } else assert(0); if (save > offset + refsize) - buf->setsize(save); + buf.setsize(save); } return refsize; } @@ -2406,7 +2426,7 @@ int MsCoffObj_reftoident(segidx_t seg, targ_size_t offset, Symbol *s, targ_size_ void MsCoffObj_far16thunk(Symbol *s) { - //dbg_printf("MsCoffObj_far16thunk('%s')\n", s->Sident); + //dbg_printf("MsCoffObj_far16thunk('%s')\n", s.Sident.ptr); assert(0); } @@ -2435,7 +2455,7 @@ int elf_align(int size, int foffset) int offset = (foffset + size - 1) & ~(size - 1); //printf("offset = x%lx, foffset = x%lx, size = x%lx\n", offset, foffset, (int)size); if (offset > foffset) - fobjbuf->writezeros(offset - foffset); + fobjbuf.writezeros(offset - foffset); return offset; } @@ -2445,27 +2465,28 @@ int elf_align(int size, int foffset) * scc symbol for ModuleInfo */ -#if MARS +version (MARS) +{ void MsCoffObj_moduleinfo(Symbol *scc) { - int align = I64 ? IMAGE_SCN_ALIGN_8BYTES : IMAGE_SCN_ALIGN_4BYTES; + int align_ = I64 ? IMAGE_SCN_ALIGN_8BYTES : IMAGE_SCN_ALIGN_4BYTES; /* Module info sections */ const int seg = MsCoffObj_getsegment(".minfo$B", IMAGE_SCN_CNT_INITIALIZED_DATA | - align | + align_ | IMAGE_SCN_MEM_READ); - //printf("MsCoffObj_moduleinfo(%s) seg = %d:x%x\n", scc->Sident, seg, Offset(seg)); + //printf("MsCoffObj_moduleinfo(%s) seg = %d:x%x\n", scc.Sident.ptr, seg, Offset(seg)); int flags = CFoff; if (I64) flags |= CFoffset64; - SegData[seg]->SDoffset += MsCoffObj_reftoident(seg, Offset(seg), scc, 0, flags); + SegData[seg].SDoffset += MsCoffObj_reftoident(seg, Offset(seg), scc, 0, flags); } -#endif +} /********************************** * Reset code seg to existing seg. @@ -2482,7 +2503,6 @@ Symbol *MsCoffObj_tlv_bootstrap() { // specific for Mach-O assert(0); - return null; } /***************************************** @@ -2494,11 +2514,14 @@ Symbol *MsCoffObj_tlv_bootstrap() void MsCoffObj_write_pointerRef(Symbol* s, uint soff) { if (!ptrref_buf) - ptrref_buf = new Outbuffer; + { + ptrref_buf = cast(Outbuffer*) calloc(1, Outbuffer.sizeof); + assert(ptrref_buf); + } // defer writing pointer references until the symbols are written out - ptrref_buf->write(&s, sizeof(s)); - ptrref_buf->write32(soff); + ptrref_buf.write(&s, (s).sizeof); + ptrref_buf.write32(soff); } /***************************************** @@ -2508,42 +2531,43 @@ void MsCoffObj_write_pointerRef(Symbol* s, uint soff) * s = symbol that contains the pointer * soff = offset of the pointer inside the Symbol's memory */ -private void objflush_pointerRef(Symbol* s, uint soff) +extern (D) private void objflush_pointerRef(Symbol* s, uint soff) { - bool isTls = (s->Sfl == FLtlsdata); - const char* segname = isTls ? ".tp$B" : ".dp$B"; + bool isTls = (s.Sfl == FLtlsdata); + const(char)* segname = isTls ? ".tp$B" : ".dp$B"; int attr = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_READ; int seg = MsCoffObj_getsegment(segname, attr); - targ_size_t offset = SegData[seg]->SDoffset; - MsCoffObj_addrel(seg, offset, s, offset, RELaddr32, 0); - Outbuffer* buf = SegData[seg]->SDbuf; - buf->setsize(offset); - buf->write32(soff); - SegData[seg]->SDoffset = buf->size(); + targ_size_t offset = SegData[seg].SDoffset; + MsCoffObj_addrel(seg, offset, s, cast(uint)offset, RELaddr32, 0); + Outbuffer* buf = SegData[seg].SDbuf; + buf.setsize(cast(uint)offset); + buf.write32(soff); + SegData[seg].SDoffset = buf.size(); } /***************************************** * flush all pointer references saved by write_pointerRef * to the object file */ -private void objflush_pointerRefs() +extern (D) private void objflush_pointerRefs() { if (!ptrref_buf) return; - ubyte *p = ptrref_buf->buf; - ubyte *end = ptrref_buf->p; + ubyte *p = ptrref_buf.buf; + ubyte *end = ptrref_buf.p; while (p < end) { Symbol* s = *cast(Symbol**)p; - p += sizeof(s); + p += s.sizeof; uint soff = *cast(uint*)p; - p += sizeof(soff); + p += soff.sizeof; objflush_pointerRef(s, soff); } - ptrref_buf->reset(); + ptrref_buf.reset(); } -#endif -#endif +} + +} diff --git a/src/posix.mak b/src/posix.mak index 022d19f65c30..5863b35dde36 100644 --- a/src/posix.mak +++ b/src/posix.mak @@ -404,7 +404,7 @@ BACK_SRC = \ $C/elfobj.c $C/cv4.h $C/dwarf2.h $C/exh.h $C/go.h \ $C/dwarf.c $C/dwarf.h $C/aa.h $C/aarray.d \ $C/platform_stub.c $C/code_x86.h $C/code_stub.h \ - $C/machobj.c $C/mscoffobj.c \ + $C/machobj.c $C/mscoffobj.d \ $C/obj.h $C/pdata.d $C/cv8.d $C/backconfig.d $C/sizecheck.c $C/divcoeff.d \ $C/dvarstats.d $C/dvec.d \ $C/md5.d $C/md5.h \ diff --git a/src/vcbuild/dmd_backend.vcxproj b/src/vcbuild/dmd_backend.vcxproj index b7b401a796f4..3a4db5b95cb8 100644 --- a/src/vcbuild/dmd_backend.vcxproj +++ b/src/vcbuild/dmd_backend.vcxproj @@ -92,7 +92,6 @@ - diff --git a/src/win32.mak b/src/win32.mak index 58b16a544c90..5e17f97ed31e 100644 --- a/src/win32.mak +++ b/src/win32.mak @@ -242,7 +242,7 @@ BACKSRC= $C\cdef.h $C\cc.h $C\oper.h $C\ty.h $C\optabgen.d \ $C\dwarf.c $C\dwarf.h $C\machobj.c $C\aarray.d \ $C\strtold.c $C\aa.h \ $C\md5.h $C\md5.d $C\ph2.d $C\util2.d \ - $C\mscoffobj.c $C\obj.h $C\pdata.d $C\cv8.d $C\backconfig.d $C\sizecheck.c \ + $C\mscoffobj.d $C\obj.h $C\pdata.d $C\cv8.d $C\backconfig.d $C\sizecheck.c \ $C\divcoeff.d $C\dwarfeh.d $C\dvarstats.d \ $C\dvec.d $C\filespec.d $C\backend.txt @@ -578,8 +578,8 @@ $G/gsroa.obj : $C\gsroa.d $G/md5.obj : $C\md5.d $(HOST_DC) -c -of$@ $(DFLAGS) -betterC -mv=dmd.backend=$C $C\md5 -$G/mscoffobj.obj : $C\mscoff.h $C\mscoffobj.c - $(CC) -c -o$@ $(MFLAGS) -I$D;$(ROOT) -I$G $C\mscoffobj +$G/mscoffobj.obj : $C\mscoffobj.d + $(HOST_DC) -c -of$@ $(DFLAGS) -betterC -mv=dmd.backend=$C $C\mscoffobj $G/newman.obj : $(CH) $C\newman.d $(HOST_DC) -c -of$@ $(DFLAGS) -betterC -mv=dmd.backend=$C $C\newman