mirrors/dmd
1
0
Fork 0
mirror of https://github.com/dlang/dmd.git synced 2025-04-26 21:21:48 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 10

Get rid of obsolete dmd.{lib,scan}omf modules

Browse source
This commit is contained in:
Martin Kinkelin 2024-05-25 15:49:39 +02:00
parent dd673700c0
commit d715bdc972
6 changed files with 2 additions and 997 deletions
Download patch file Download diff file Expand all files Collapse all files

4
compiler/src/build.d
View file

@ -1562,8 +1562,8 @@ auto sourceFiles()
dmsc.d e2ir.d iasmdmd.d glue.d objc_glue.d
s2ir.d tocsym.d toctype.d tocvdebug.d todt.d toir.d toobj.d
"),
driver: fileArray(env["D"], "dinifile.d dmdparams.d gluelayer.d lib.d libelf.d libmach.d libmscoff.d libomf.d
link.d mars.d main.d scanelf.d scanmach.d scanmscoff.d scanomf.d vsoptions.d
driver: fileArray(env["D"], "dinifile.d dmdparams.d gluelayer.d lib.d libelf.d libmach.d libmscoff.d
link.d mars.d main.d scanelf.d scanmach.d scanmscoff.d vsoptions.d
"),
frontend: fileArray(env["D"], "
access.d aggregate.d aliasthis.d argtypes_x86.d argtypes_sysv_x64.d argtypes_aarch64.d arrayop.d

2
compiler/src/dmd/README.md
View file

@ -201,11 +201,9 @@ Note that these groups have no strict meaning, the category assignments are a bi
| [libelf.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/libelf.d) | Library in ELF format (Unix) |
| [libmach.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/libmach.d) | Library in Mach-O format (macOS) |
| [libmscoff.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/libmscoff.d) | Library in COFF format (32/64-bit Windows) |
| [libomf.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/libomf.d) | Library in OMF format (legacy 32-bit Windows) |
| [scanelf.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/scanelf.d) | Extract symbol names from a library in ELF format |
| [scanmach.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/scanmach.d) | Extract symbol names from a library in Mach-O format |
| [scanmscoff.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/scanmscoff.d) | Extract symbol names from a library in COFF format |
| [scanomf.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/scanomf.d) | Extract symbol names from a library in OMF format |
### Code generation / back-end interfacing

1
compiler/src/dmd/lib.d
View file

@ -22,7 +22,6 @@ import dmd.target : Target;
import dmd.libelf;
import dmd.libmach;
import dmd.libmscoff;
import dmd.libomf;
private enum LOG = false;

596
compiler/src/dmd/libomf.d
View file

@ -1,596 +0,0 @@
/**
* A library in the OMF format, a legacy format for 32-bit Windows.
*
* Copyright: Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved
* Authors: $(LINK2 https://www.digitalmars.com, Walter Bright)
* License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/libomf.d, _libomf.d)
* Documentation: https://dlang.org/phobos/dmd_libomf.html
* Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/libomf.d
*/
module dmd.libomf;
import core.stdc.stdio;
import core.stdc.string;
import core.stdc.stdlib;
import core.bitop;
import dmd.errors : fatal;
import dmd.utils;
import dmd.lib;
import dmd.location;
import dmd.root.array;
import dmd.root.file;
import dmd.root.filename;
import dmd.root.rmem;
import dmd.common.outbuffer;
import dmd.root.string;
import dmd.root.stringtable;
import dmd.scanomf;
// Entry point (only public symbol in this module).
Library LibOMF_factory()
{
return new LibOMF();
}
private: // for the remainder of this module
nothrow:
enum LOG = false;
struct OmfObjSymbol
{
char* name;
OmfObjModule* om;
/// Predicate for `Array.sort`for name comparison
static int name_pred (scope const OmfObjSymbol** ppe1, scope const OmfObjSymbol** ppe2) nothrow @nogc pure
{
return strcmp((**ppe1).name, (**ppe2).name);
}
}
alias OmfObjModules = Array!(OmfObjModule*);
alias OmfObjSymbols = Array!(OmfObjSymbol*);
final class LibOMF : Library
{
OmfObjModules objmodules; // OmfObjModule[]
OmfObjSymbols objsymbols; // OmfObjSymbol[]
StringTable!(OmfObjSymbol*) tab;
extern (D) this()
{
tab._init(14_000);
}
/***************************************
* Add object module or library to the library.
* Examine the buffer to see which it is.
* If the buffer is NULL, use module_name as the file name
* and load the file.
*/
override void addObject(const(char)[] module_name, const(ubyte)[] buffer)
{
static if (LOG)
{
printf("LibOMF::addObject(%.*s)\n", cast(int)module_name.length,
module_name.ptr);
}
void corrupt(int reason)
{
eSink.error(loc, "corrupt OMF object module %.*s %d",
cast(int)module_name.length, module_name.ptr, reason);
}
if (!buffer.length)
{
assert(module_name.length, "No module nor buffer provided to `addObject`");
// read file and take buffer ownership
OutBuffer b;
if (readFile(Loc.initial, module_name, b))
fatal();
buffer = cast(ubyte[])b.extractSlice();
}
uint g_page_size;
ubyte* pstart = cast(ubyte*)buffer.ptr;
bool islibrary = false;
/* See if it's an OMF library.
* Don't go by file extension.
*/
struct LibHeader
{
align(1):
ubyte recTyp; // 0xF0
ushort pagesize;
uint lSymSeek;
ushort ndicpages;
}
/* Determine if it is an OMF library, an OMF object module,
* or something else.
*/
if (buffer.length < (LibHeader).sizeof)
return corrupt(__LINE__);
const lh = cast(const(LibHeader)*)buffer.ptr;
if (lh.recTyp == 0xF0)
{
/* OMF library
* The modules are all at buffer.ptr[g_page_size .. lh.lSymSeek]
*/
islibrary = 1;
g_page_size = lh.pagesize + 3;
if (lh.lSymSeek > buffer.length || g_page_size > buffer.length)
return corrupt(__LINE__);
buffer = (cast(ubyte*)pstart)[g_page_size .. lh.lSymSeek];
}
else if (lh.recTyp == '!' && memcmp(lh, "!<arch>\n".ptr, 8) == 0)
{
eSink.error(loc, "COFF libraries not supported");
return;
}
else
{
// Not a library, assume OMF object module
g_page_size = 16;
}
bool firstmodule = true;
void addOmfObjModule(char* name, void* base, size_t length)
{
auto om = new OmfObjModule();
om.base = cast(ubyte*)base;
om.page = cast(ushort)((om.base - pstart) / g_page_size);
om.length = cast(uint)length;
/* Determine the name of the module
*/
const(char)[] n;
if (firstmodule && module_name && !islibrary)
{
// Remove path and extension
n = FileName.sansExt(FileName.name(module_name));
}
else
{
/* Use THEADR name as module name,
* removing path and extension.
*/
n = FileName.sansExt(FileName.name(name.toDString()));
}
om.name = toCString(n)[0 .. n.length];
firstmodule = false;
this.objmodules.push(om);
}
if (scanOmfLib(&addOmfObjModule, cast(void*)buffer.ptr, buffer.length, g_page_size))
return corrupt(__LINE__);
}
/*****************************************************************************/
void addSymbol(OmfObjModule* om, const(char)[] name, int pickAny = 0) nothrow
{
assert(name.length == strlen(name.ptr));
static if (LOG)
{
printf("LibOMF::addSymbol(%.*s, %.*s, %d)\n",
cast(int)om.name.length, om.name.ptr,
cast(int)name.length, name.ptr, pickAny);
}
if (auto s = tab.insert(name, null))
{
auto os = new OmfObjSymbol();
os.name = cast(char*)Mem.check(strdup(name.ptr));
os.om = om;
s.value = os;
objsymbols.push(os);
}
else
{
// already in table
if (!pickAny)
{
const s2 = tab.lookup(name);
assert(s2);
const os = s2.value;
eSink.error(loc, "multiple definition of %.*s: %.*s and %.*s: %s",
cast(int)om.name.length, om.name.ptr,
cast(int)name.length, name.ptr,
cast(int)os.om.name.length, os.om.name.ptr, os.name);
}
}
}
private:
/************************************
* Scan single object module for dictionary symbols.
* Send those symbols to LibOMF::addSymbol().
*/
void scanObjModule(OmfObjModule* om)
{
static if (LOG)
{
printf("LibMSCoff::scanObjModule(%s)\n", om.name.ptr);
}
extern (D) void addSymbol(const(char)[] name, int pickAny) nothrow
{
this.addSymbol(om, name, pickAny);
}
scanOmfObjModule(&addSymbol, om.base[0 .. om.length], om.name.ptr, loc, eSink);
}
/***********************************
* Calculates number of pages needed for dictionary
* Returns:
* number of pages
*/
ushort numDictPages(uint padding)
{
ushort ndicpages;
ushort bucksForHash;
ushort bucksForSize;
uint symSize = 0;
foreach (s; objsymbols)
{
symSize += (strlen(s.name) + 4) & ~1;
}
foreach (om; objmodules)
{
size_t len = om.name.length;
if (len > 0xFF)
len += 2; // Digital Mars long name extension
symSize += (len + 4 + 1) & ~1;
}
bucksForHash = cast(ushort)((objsymbols.length + objmodules.length + HASHMOD - 3) / (HASHMOD - 2));
bucksForSize = cast(ushort)((symSize + BUCKETSIZE - padding - padding - 1) / (BUCKETSIZE - padding));
ndicpages = (bucksForHash > bucksForSize) ? bucksForHash : bucksForSize;
//printf("ndicpages = %u\n",ndicpages);
// Find prime number greater than ndicpages
__gshared uint* primes =
[
1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,
47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103,
107, 109, 113, 127, 131, 137, 139, 149, 151, 157,
163, 167, 173, 179, 181, 191, 193, 197, 199, 211,
223, 227, 229, 233, 239, 241, 251, 257, 263, 269,
271, 277, 281, 283, 293, 307, 311, 313, 317, 331,
337, 347, 349, 353, 359, 367, 373, 379, 383, 389,
397, 401, 409, 419, 421, 431, 433, 439, 443, 449,
457, 461, 463, 467, 479, 487, 491, 499, 503, 509,
//521,523,541,547,
0
];
for (size_t i = 0; 1; i++)
{
if (primes[i] == 0)
{
// Quick and easy way is out.
// Now try and find first prime number > ndicpages
uint prime;
for (prime = (ndicpages + 1) | 1; 1; prime += 2)
{
// Determine if prime is prime
for (uint u = 3; u < prime / 2; u += 2)
{
if ((prime / u) * u == prime)
goto L1;
}
break;
L1:
}
ndicpages = cast(ushort)prime;
break;
}
if (primes[i] > ndicpages)
{
ndicpages = cast(ushort)primes[i];
break;
}
}
return ndicpages;
}
/*******************************************
* Write the module and symbol names to the dictionary.
* Returns:
* false failure
*/
bool FillDict(ubyte* bucketsP, ushort ndicpages)
{
// max size that will fit in dictionary
enum LIBIDMAX = (512 - 0x25 - 3 - 4);
ubyte[4 + LIBIDMAX + 2 + 1] entry;
//printf("FillDict()\n");
// Add each of the module names
foreach (om; objmodules)
{
ushort n = cast(ushort)om.name.length;
if (n > 255)
{
entry[0] = 0xFF;
entry[1] = 0;
*cast(ushort*)(entry.ptr + 2) = cast(ushort)(n + 1);
memcpy(entry.ptr + 4, om.name.ptr, n);
n += 3;
}
else
{
entry[0] = cast(ubyte)(1 + n);
memcpy(entry.ptr + 1, om.name.ptr, n);
}
entry[n + 1] = '!';
*(cast(ushort*)(n + 2 + entry.ptr)) = om.page;
if (n & 1)
entry[n + 2 + 2] = 0;
if (!EnterDict(bucketsP, ndicpages, entry.ptr, n + 1))
return false;
}
// Sort the symbols
objsymbols.sort!(OmfObjSymbol.name_pred);
// Add each of the symbols
foreach (os; objsymbols)
{
ushort n = cast(ushort)strlen(os.name);
if (n > 255)
{
entry[0] = 0xFF;
entry[1] = 0;
*cast(ushort*)(entry.ptr + 2) = n;
memcpy(entry.ptr + 4, os.name, n);
n += 3;
}
else
{
entry[0] = cast(ubyte)n;
memcpy(entry.ptr + 1, os.name, n);
}
*(cast(ushort*)(n + 1 + entry.ptr)) = os.om.page;
if ((n & 1) == 0)
entry[n + 3] = 0;
if (!EnterDict(bucketsP, ndicpages, entry.ptr, n))
{
return false;
}
}
return true;
}
/**********************************************
* Create and write library to libbuf.
* The library consists of:
* library header
* object modules...
* dictionary header
* dictionary pages...
*/
protected override void writeLibToBuffer(ref OutBuffer libbuf)
{
/* Scan each of the object modules for symbols
* to go into the dictionary
*/
foreach (om; objmodules)
{
scanObjModule(om);
}
uint g_page_size = 16;
/* Calculate page size so that the number of pages
* fits in 16 bits. This is because object modules
* are indexed by page number, stored as an unsigned short.
*/
while (1)
{
Lagain:
static if (LOG)
{
printf("g_page_size = %d\n", g_page_size);
}
uint offset = g_page_size;
foreach (om; objmodules)
{
uint page = offset / g_page_size;
if (page > 0xFFFF)
{
// Page size is too small, double it and try again
g_page_size *= 2;
goto Lagain;
}
offset += OMFObjSize(om.base, om.length, om.name.ptr);
// Round the size of the file up to the next page size
// by filling with 0s
uint n = (g_page_size - 1) & offset;
if (n)
offset += g_page_size - n;
}
break;
}
/* Leave one page of 0s at start as a dummy library header.
* Fill it in later with the real data.
*/
libbuf.fill0(g_page_size);
/* Write each object module into the library
*/
foreach (om; objmodules)
{
uint page = cast(uint)(libbuf.length / g_page_size);
assert(page <= 0xFFFF);
om.page = cast(ushort)page;
// Write out the object module om
writeOMFObj(libbuf, om.base, om.length, om.name.ptr);
// Round the size of the file up to the next page size
// by filling with 0s
uint n = (g_page_size - 1) & libbuf.length;
if (n)
libbuf.fill0(g_page_size - n);
}
// File offset of start of dictionary
uint offset = cast(uint)libbuf.length;
// Write dictionary header, then round it to a BUCKETPAGE boundary
ushort size = (BUCKETPAGE - (cast(short)offset + 3)) & (BUCKETPAGE - 1);
libbuf.writeByte(0xF1);
libbuf.writeword(size);
libbuf.fill0(size);
// Create dictionary
ubyte* bucketsP = null;
ushort ndicpages;
ushort padding = 32;
for (;;)
{
ndicpages = numDictPages(padding);
static if (LOG)
{
printf("ndicpages = %d\n", ndicpages);
}
// Allocate dictionary
if (bucketsP)
bucketsP = cast(ubyte*)Mem.check(realloc(bucketsP, ndicpages * BUCKETPAGE));
else
bucketsP = cast(ubyte*)Mem.check(malloc(ndicpages * BUCKETPAGE));
memset(bucketsP, 0, ndicpages * BUCKETPAGE);
for (uint u = 0; u < ndicpages; u++)
{
// 'next available' slot
bucketsP[u * BUCKETPAGE + HASHMOD] = (HASHMOD + 1) >> 1;
}
if (FillDict(bucketsP, ndicpages))
break;
padding += 16; // try again with more margins
}
// Write dictionary
libbuf.write(bucketsP[0 .. ndicpages * BUCKETPAGE]);
if (bucketsP)
free(bucketsP);
// Create library header
struct Libheader
{
align(1):
ubyte recTyp;
ushort recLen;
uint trailerPosn;
ushort ndicpages;
ubyte flags;
uint filler;
}
Libheader libHeader;
memset(&libHeader, 0, (Libheader).sizeof);
libHeader.recTyp = 0xF0;
libHeader.recLen = 0x0D;
libHeader.trailerPosn = offset + (3 + size);
libHeader.recLen = cast(ushort)(g_page_size - 3);
libHeader.ndicpages = ndicpages;
libHeader.flags = 1; // always case sensitive
// Write library header at start of buffer
memcpy(cast(void*)libbuf[].ptr, &libHeader, (libHeader).sizeof);
}
}
/*****************************************************************************/
/*****************************************************************************/
struct OmfObjModule
{
ubyte* base; // where are we holding it in memory
uint length; // in bytes
ushort page; // page module starts in output file
const(char)[] name; // module name, with terminating 0
}
enum HASHMOD = 0x25;
enum BUCKETPAGE = 512;
enum BUCKETSIZE = (BUCKETPAGE - HASHMOD - 1);
/*******************************************
* Write a single entry into dictionary.
* Returns:
* false failure
*/
bool EnterDict(ubyte* bucketsP, ushort ndicpages, ubyte* entry, uint entrylen)
{
ushort uStartIndex;
ushort uStep;
ushort uStartPage;
ushort uPageStep;
ushort uIndex;
ushort uPage;
ushort n;
uint u;
uint nbytes;
ubyte* aP;
ubyte* zP;
aP = entry;
zP = aP + entrylen; // point at last char in identifier
uStartPage = 0;
uPageStep = 0;
uStartIndex = 0;
uStep = 0;
u = entrylen;
while (u--)
{
uStartPage = rol!(ushort)(uStartPage, 2) ^ (*aP | 0x20);
uStep = ror!(ushort)(uStep, 2) ^ (*aP++ | 0x20);
uStartIndex = ror!(ushort)(uStartIndex, 2) ^ (*zP | 0x20);
uPageStep = rol!(ushort)(uPageStep, 2) ^ (*zP-- | 0x20);
}
uStartPage %= ndicpages;
uPageStep %= ndicpages;
if (uPageStep == 0)
uPageStep++;
uStartIndex %= HASHMOD;
uStep %= HASHMOD;
if (uStep == 0)
uStep++;
uPage = uStartPage;
uIndex = uStartIndex;
// number of bytes in entry
nbytes = 1 + entrylen + 2;
if (entrylen > 255)
nbytes += 2;
while (1)
{
aP = &bucketsP[uPage * BUCKETPAGE];
uStartIndex = uIndex;
while (1)
{
if (0 == aP[uIndex])
{
// n = next available position in this page
n = aP[HASHMOD] << 1;
assert(n > HASHMOD);
// if off end of this page
if (n + nbytes > BUCKETPAGE)
{
aP[HASHMOD] = 0xFF;
break;
// next page
}
else
{
aP[uIndex] = cast(ubyte)(n >> 1);
memcpy((aP + n), entry, nbytes);
aP[HASHMOD] += (nbytes + 1) >> 1;
if (aP[HASHMOD] == 0)
aP[HASHMOD] = 0xFF;
return true;
}
}
uIndex += uStep;
uIndex %= 0x25;
/*if (uIndex > 0x25)
uIndex -= 0x25;*/
if (uIndex == uStartIndex)
break;
}
uPage += uPageStep;
if (uPage >= ndicpages)
uPage -= ndicpages;
if (uPage == uStartPage)
break;
}
return false;
}

394
compiler/src/dmd/scanomf.d
View file

@ -1,394 +0,0 @@
/**
* Extract symbols from an OMF object file.
*
* Copyright: Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved
* Authors: $(LINK2 https://www.digitalmars.com, Walter Bright)
* License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/scanomf.d, _scanomf.d)
* Documentation: https://dlang.org/phobos/dmd_scanomf.html
* Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/scanomf.d
*/
module dmd.scanomf;
import core.stdc.string;
import core.stdc.stdlib;
import dmd.arraytypes;
import dmd.common.outbuffer;
import dmd.errorsink;
import dmd.location;
import dmd.root.rmem;
import dmd.root.string;
nothrow:
private enum LOG = false;
/*****************************************
* Reads an object module from base[] and passes the names
* of any exported symbols to (*pAddSymbol)().
* Params:
* pAddSymbol = function to pass the names to
* base = array of contents of object module
* module_name = name of the object module (used for error messages)
* loc = location to use for error printing
* eSink = where the error messages go
*/
void scanOmfObjModule(void delegate(const(char)[] name, int pickAny) nothrow pAddSymbol,
scope const ubyte[] base, scope const char* module_name, Loc loc, ErrorSink eSink)
{
static if (LOG)
{
printf("scanOmfObjModule(%s)\n", module_name);
}
char[LIBIDMAX + 1] name = void;
Strings names;
scope(exit)
for (size_t u = 1; u < names.length; u++)
free(cast(void*)names[u]);
names.push(null); // don't use index 0
bool easyomf = false; // assume not EASY-OMF
const pend = base.ptr + base.length;
const(ubyte)* pnext;
for (auto p = base.ptr; 1; p = pnext)
{
assert(p < pend);
ubyte recTyp = *p++;
ushort recLen = *cast(ushort*)p;
p += 2;
pnext = p + recLen;
recLen--; // forget the checksum
switch (recTyp)
{
case LNAMES:
case LLNAMES:
while (p + 1 < pnext)
{
parseName(p, name.ptr);
char* copy = cast(char*)Mem.check(strdup(name.ptr));
names.push(copy);
}
break;
case PUBDEF:
if (easyomf)
recTyp = PUB386; // convert to MS format
goto case;
case PUB386:
if (!(parseIdx(p) | parseIdx(p)))
p += 2; // skip seg, grp, frame
while (p + 1 < pnext)
{
parseName(p, name.ptr);
p += (recTyp == PUBDEF) ? 2 : 4; // skip offset
parseIdx(p); // skip type index
pAddSymbol(name[0 .. strlen(name.ptr)], 0);
}
break;
case COMDAT:
if (easyomf)
recTyp = COMDAT + 1; // convert to MS format
goto case;
case COMDAT + 1:
{
int pickAny = 0;
if (*p++ & 5) // if continuation or local comdat
break;
ubyte attr = *p++;
if (attr & 0xF0) // attr: if multiple instances allowed
pickAny = 1;
p++; // align
p += 2; // enum data offset
if (recTyp == COMDAT + 1)
p += 2; // enum data offset
parseIdx(p); // type index
if ((attr & 0x0F) == 0) // if explicit allocation
{
parseIdx(p); // base group
parseIdx(p); // base segment
}
uint idx = parseIdx(p); // public name index
if (idx == 0 || idx >= names.length)
{
//debug(printf("[s] name idx=%d, uCntNames=%d\n", idx, uCntNames));
eSink.error(loc, "corrupt COMDAT");
return;
}
//printf("[s] name='%s'\n",name);
const(char)* n = names[idx];
pAddSymbol(n.toDString(), pickAny);
break;
}
case COMDEF:
{
while (p + 1 < pnext)
{
parseName(p, name.ptr);
parseIdx(p); // type index
skipDataType(p); // data type
pAddSymbol(name[0 .. strlen(name.ptr)], 1);
}
break;
}
case ALIAS:
while (p + 1 < pnext)
{
parseName(p, name.ptr);
pAddSymbol(name[0 .. strlen(name.ptr)], 0);
parseName(p, name.ptr);
}
break;
case MODEND:
case M386END:
return;
case COMENT:
// Recognize Phar Lap EASY-OMF format
{
__gshared ubyte* omfstr1 = [0x80, 0xAA, '8', '0', '3', '8', '6'];
if (recLen == (omfstr1).sizeof)
{
for (uint i = 0; i < (omfstr1).sizeof; i++)
if (*p++ != omfstr1[i])
goto L1;
easyomf = true;
break;
L1:
}
}
// Recognize .IMPDEF Import Definition Records
{
__gshared ubyte* omfstr2 = [0, 0xA0, 1];
if (recLen >= 7)
{
p++;
for (uint i = 1; i < (omfstr2).sizeof; i++)
if (*p++ != omfstr2[i])
goto L2;
p++; // skip OrdFlag field
parseName(p, name.ptr);
pAddSymbol(name[0 .. strlen(name.ptr)], 0);
break;
L2:
}
}
break;
default:
// ignore
}
}
}
/*************************************************
* Scan a block of memory buf[0..buflen], pulling out each
* OMF object module in it and sending the info in it to (*pAddObjModule).
* Returns:
* true for corrupt OMF data
*/
bool scanOmfLib(void delegate(char* name, void* base, size_t length) nothrow pAddObjModule, scope void* buf, size_t buflen, uint pagesize)
{
/* Split up the buffer buf[0..buflen] into multiple object modules,
* each aligned on a pagesize boundary.
*/
const(ubyte)* base = null;
char[LIBIDMAX + 1] name = void;
auto p = cast(const(ubyte)*)buf;
auto pend = p + buflen;
const(ubyte)* pnext;
for (; p < pend; p = pnext) // for each OMF record
{
if (p + 3 >= pend)
return true; // corrupt
ubyte recTyp = *p;
ushort recLen = *cast(const(ushort)*)(p + 1);
pnext = p + 3 + recLen;
if (pnext > pend)
return true; // corrupt
recLen--; // forget the checksum
switch (recTyp)
{
case LHEADR:
case THEADR:
if (!base)
{
base = p;
p += 3;
parseName(p, name.ptr);
if (name[0] == 'C' && name[1] == 0) // old C compilers did this
base = pnext; // skip past THEADR
}
break;
case MODEND:
case M386END:
{
if (base)
{
pAddObjModule(name.ptr, cast(ubyte*)base, pnext - base);
base = null;
}
// Round up to next page
uint t = cast(uint)(pnext - cast(const(ubyte)*)buf);
t = (t + pagesize - 1) & ~cast(uint)(pagesize - 1);
pnext = cast(const(ubyte)*)buf + t;
break;
}
default:
// ignore
}
}
return (base !is null); // missing MODEND record
}
uint OMFObjSize(scope const void* base, size_t length, scope const char* name)
{
ubyte c = *cast(const(ubyte)*)base;
if (c != THEADR && c != LHEADR)
{
size_t len = strlen(name);
assert(len <= LIBIDMAX);
length += len + 5;
}
return cast(uint)length;
}
void writeOMFObj(ref OutBuffer buf, scope const void* base, size_t length, scope const char* name)
{
ubyte c = *cast(const(ubyte)*)base;
if (c != THEADR && c != LHEADR)
{
const len = strlen(name);
assert(len <= LIBIDMAX);
ubyte[4 + LIBIDMAX + 1] header = void;
header[0] = THEADR;
header[1] = cast(ubyte)(2 + len);
header[2] = 0;
header[3] = cast(ubyte)len;
assert(len <= 0xFF - 2);
memcpy(4 + header.ptr, name, len);
// Compute and store record checksum
uint n = cast(uint)(len + 4);
ubyte checksum = 0;
ubyte* p = header.ptr;
while (n--)
{
checksum -= *p;
p++;
}
*p = checksum;
buf.write(header.ptr[0 .. len + 5]);
}
buf.write(base[0 .. length]);
}
private: // for the remainder of this module
/**************************
* Record types:
*/
enum RHEADR = 0x6E;
enum REGINT = 0x70;
enum REDATA = 0x72;
enum RIDATA = 0x74;
enum OVLDEF = 0x76;
enum ENDREC = 0x78;
enum BLKDEF = 0x7A;
enum BLKEND = 0x7C;
enum DEBSYM = 0x7E;
enum THEADR = 0x80;
enum LHEADR = 0x82;
enum PEDATA = 0x84;
enum PIDATA = 0x86;
enum COMENT = 0x88;
enum MODEND = 0x8A;
enum M386END = 0x8B; /* 32 bit module end record */
enum EXTDEF = 0x8C;
enum TYPDEF = 0x8E;
enum PUBDEF = 0x90;
enum PUB386 = 0x91;
enum LOCSYM = 0x92;
enum LINNUM = 0x94;
enum LNAMES = 0x96;
enum SEGDEF = 0x98;
enum GRPDEF = 0x9A;
enum FIXUPP = 0x9C;
/*#define (none) 0x9E */
enum LEDATA = 0xA0;
enum LIDATA = 0xA2;
enum LIBHED = 0xA4;
enum LIBNAM = 0xA6;
enum LIBLOC = 0xA8;
enum LIBDIC = 0xAA;
enum COMDEF = 0xB0;
enum LEXTDEF = 0xB4;
enum LPUBDEF = 0xB6;
enum LCOMDEF = 0xB8;
enum CEXTDEF = 0xBC;
enum COMDAT = 0xC2;
enum LINSYM = 0xC4;
enum ALIAS = 0xC6;
enum LLNAMES = 0xCA;
enum LIBIDMAX = (512 - 0x25 - 3 - 4);
// max size that will fit in dictionary
void parseName(ref scope const(ubyte)* pp, char* name)
{
auto p = pp;
uint len = *p++;
if (len == 0xFF && *p == 0) // if long name
{
len = p[1] & 0xFF;
len |= cast(uint)p[2] << 8;
p += 3;
assert(len <= LIBIDMAX);
}
memcpy(name, p, len);
name[len] = 0;
pp = p + len;
}
ushort parseIdx(ref scope const(ubyte)* pp)
{
auto p = pp;
const c = *p++;
ushort idx = (0x80 & c) ? ((0x7F & c) << 8) + *p++ : c;
pp = p;
return idx;
}
// skip numeric field of a data type of a COMDEF record
void skipNumericField(ref scope const(ubyte)* pp)
{
const(ubyte)* p = pp;
const c = *p++;
if (c == 0x81)
p += 2;
else if (c == 0x84)
p += 3;
else if (c == 0x88)
p += 4;
else
assert(c <= 0x80);
pp = p;
}
// skip data type of a COMDEF record
void skipDataType(ref scope const(ubyte)* pp)
{
auto p = pp;
const c = *p++;
if (c == 0x61)
{
// FAR data
skipNumericField(p);
skipNumericField(p);
}
else if (c == 0x62)
{
// NEAR data
skipNumericField(p);
}
else
{
assert(1 <= c && c <= 0x5f); // Borland segment indices
}
pp = p;
}

2
dub.sdl
View file

@ -134,14 +134,12 @@ subPackage {
libelf,\
libmach,\
libmscoff,\
libomf,\
link,\
objc_glue,\
s2ir,\
scanelf,\
scanmach,\
scanmscoff,\
scanomf,\
tocsym,\
toctype,\
tocvdebug,\