encounter
/
MWCC
mirror of https://git.wuffs.org/MWCC
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
MWCC/compiler_and_linker/unsorted/MachO.c

924 lines
30 KiB
C
Raw Blame History

#include "compiler/MachO.h"
#include "compiler/CError.h"
#include "compiler/CParser.h"
#include "compiler/CPrep.h"
#include "compiler/CompilerTools.h"
#include "compiler/ObjGenMachO.h"
#include "cos.h"
static MachOSegment *FirstSeg;
static MachOSegment *LastSeg;
static UInt32 SectNum;
static UInt32 SymNum;
static UInt32 NumStabs;
static UInt32 ilocalsym;
static UInt32 nlocalsym;
static UInt32 iextdefsym;
static UInt32 nextdefsym;
static UInt32 iundefsym;
static UInt32 nundefsym;
static MachOSymbol *FirstSym;
static MachOSymbol *LastSym;
static MachOSymbol *FirstStab;
static MachOSymbol *LastStab;
static UInt32 FileOffset;
static UInt32 VmAddr;
static GList ObjFile;
static SInt32 SymPad;
static UInt32 CodeSize;
static UInt32 IdataSize;
static UInt32 UdataSize;
static GList IndirectSymbolTable;
static GList StringTable;
static UInt32 IndirectSymbolTableOffset;
void MachO_Setup(void) {
FirstSeg = LastSeg = NULL;
FirstSym = LastSym = NULL;
FirstStab = LastStab = NULL;
SectNum = 0;
SymNum = 0;
NumStabs = 0;
ilocalsym = -1;
nlocalsym = 0;
iextdefsym = -1;
nextdefsym = 0;
iundefsym = -1;
nundefsym = 0;
InitGList(&IndirectSymbolTable, 256);
InitGList(&StringTable, 4096);
AppendGListByte(&StringTable, 0);
}
static UInt32 GetSectVMAddr(UInt32 id) {
MachOSegment *segment;
MachOSection *section;
for (segment = FirstSeg; segment; segment = segment->next) {
for (section = segment->firstSection; section; section = section->next) {
if (section->num == id)
return section->section.addr;
}
}
return 0;
}
static UInt32 AllocateForLoadCommands(void) {
UInt32 ncmds = 0;
MachOSegment *segment;
MachOSection *section;
for (segment = FirstSeg; segment; segment = segment->next) {
FileOffset += sizeof(struct segment_command);
segment->cmd.cmdsize += sizeof(struct segment_command);
ncmds++;
for (section = segment->firstSection; section; section = section->next) {
segment->cmd.cmdsize += sizeof(struct section);
FileOffset += sizeof(struct section);
}
}
return ncmds;
}
static UInt32 AlignModulus[] = {
1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80, 0x100, 0x200, 0x400, 0x800
};
static void AllocateAddresses(void) {
MachOSegment *segment;
MachOSection *section;
UInt32 pad;
for (segment = FirstSeg; segment; segment = segment->next) {
segment->cmd.vmaddr = VmAddr;
segment->cmd.fileoff = FileOffset;
for (section = segment->firstSection; section; section = section->next) {
if (section->glist.size)
section->section.size = section->glist.size;
pad = AlignModulus[section->section.align] - (VmAddr % AlignModulus[section->section.align]);
pad %= AlignModulus[section->section.align];
VmAddr += pad;
section->section.addr = VmAddr;
VmAddr += section->section.size;
FileOffset += pad;
if (section->glist.size) {
section->section.offset = FileOffset;
FileOffset += section->glist.size;
} else {
section->section.offset = FileOffset;
}
if (!strncmp(section->section.segname, "__TEXT", 6)) {
CodeSize += section->section.size;
} else {
if (section->glist.size)
IdataSize += section->section.size;
else
UdataSize += section->section.size;
}
}
segment->cmd.filesize = FileOffset - segment->cmd.fileoff;
segment->cmd.vmsize = VmAddr - segment->cmd.vmaddr;
}
}
static void ApplyRelocs(void) {
MachOSegment *segment;
MachOSection *section;
MachOReloc *reloc;
enum reloc_type_ppc pairType;
UInt32 pairValue;
UInt32 opMask;
UInt32 argMask;
UInt32 value;
UInt32 *ptr;
for (segment = FirstSeg; segment; segment = segment->next) {
for (section = segment->firstSection; section; section = section->next) {
for (reloc = section->firstReloc; reloc; reloc = reloc->next) {
if (reloc->is_extern) {
opMask = 0xFFFFFFFF;
argMask = 0;
value = 0;
switch (reloc->reltype) {
case PPC_RELOC_HI16:
case PPC_RELOC_LO16:
case PPC_RELOC_HA16:
pairValue = 0;
pairType = reloc->reltype;
break;
}
} else if (reloc->reltype == PPC_RELOC_PAIR) {
if (reloc->value != 0xFFFFFF) {
value = pairValue - (reloc->value + section->section.addr);
value += reloc->address;
} else {
value = pairValue + reloc->address;
}
switch (pairType) {
case PPC_RELOC_HI16:
opMask = 0xFFFF0000;
argMask = 0xFFFF;
value >>= 16;
break;
case PPC_RELOC_HA16:
opMask = 0xFFFF0000;
argMask = 0xFFFF;
if (value & 0x8000)
value += 0x10000;
value >>= 16;
break;
case PPC_RELOC_LO16:
opMask = 0xFFFF0000;
argMask = 0xFFFF;
value = value & 0xFFFF;
break;
case PPC_RELOC_HI16_SECTDIFF:
opMask = 0xFFFF0000;
argMask = 0xFFFF;
value >>= 16;
break;
case PPC_RELOC_HA16_SECTDIFF:
opMask = 0xFFFF0000;
argMask = 0xFFFF;
if (value & 0x8000)
value += 0x10000;
value >>= 16;
break;
case PPC_RELOC_LO16_SECTDIFF:
opMask = 0xFFFF0000;
argMask = 0xFFFF;
value = value & 0xFFFF;
break;
case PPC_RELOC_SECTDIFF:
opMask = 0;
argMask = 0xFFFFFFFF;
break;
default:
CError_FATAL(388);
}
} else {
value = GetSectVMAddr(reloc->value);
switch (reloc->reltype) {
case PPC_RELOC_VANILLA:
opMask = 0;
argMask = 0xFFFFFFFF;
break;
case PPC_RELOC_BR14:
opMask = 0xFFFF0003;
argMask = 0xFFFC;
break;
case PPC_RELOC_BR24:
opMask = 0xFC000003;
argMask = 0x3FFFFFC;
break;
case PPC_RELOC_LO14:
opMask = 0xFFFF0003;
argMask = 0xFFFC;
break;
case PPC_RELOC_HI16:
case PPC_RELOC_HA16:
case PPC_RELOC_LO16:
case PPC_RELOC_HI16_SECTDIFF:
case PPC_RELOC_HA16_SECTDIFF:
case PPC_RELOC_LO16_SECTDIFF:
case PPC_RELOC_SECTDIFF:
// first half of a pair
opMask = 0xFFFF0000;
argMask = 0xFFFF;
pairValue = value;
pairType = reloc->reltype;
value = 0;
break;
case PPC_RELOC_PB_LA_PTR:
CError_FATAL(428);
break;
default:
CError_FATAL(432);
}
}
if (reloc->reltype != PPC_RELOC_PAIR)
ptr = (UInt32 *) ((*section->glist.data) + reloc->address);
if (reloc->is_pcrel) {
if (!reloc->is_extern) {
*ptr = CTool_EndianConvertWord32(
(CTool_EndianConvertWord32(*ptr) & opMask) |
(argMask & (value - (reloc->address + section->section.addr) + (CTool_EndianConvertWord32(*ptr) & argMask))));
}
} else {
if (reloc->reltype == PPC_RELOC_PAIR) {
*ptr = CTool_EndianConvertWord32(
(CTool_EndianConvertWord32(*ptr) & opMask) |
(value & argMask)
);
} else {
*ptr = CTool_EndianConvertWord32(
(CTool_EndianConvertWord32(*ptr) & opMask) |
(argMask & (value + (CTool_EndianConvertWord32(*ptr) & argMask)))
);
}
}
}
}
}
}
static void AllocForRelocs(void) {
MachOSegment *segment;
MachOSection *section;
for (segment = FirstSeg; segment; segment = segment->next) {
for (section = segment->firstSection; section; section = section->next) {
if (section->section.nreloc) {
section->section.reloff = FileOffset;
FileOffset += section->section.nreloc * 8;
}
}
}
}
static void WriteSegLoadCommands(void) {
MachOSegment *segment;
MachOSection *section;
for (segment = FirstSeg; segment; segment = segment->next) {
#ifdef ENDIAN_CONVERSION
struct segment_command c = segment->cmd;
c.cmd = CTool_EndianConvertWord32(c.cmd);
c.cmdsize = CTool_EndianConvertWord32(c.cmdsize);
c.vmaddr = CTool_EndianConvertWord32(c.vmaddr);
c.vmsize = CTool_EndianConvertWord32(c.vmsize);
c.fileoff = CTool_EndianConvertWord32(c.fileoff);
c.filesize = CTool_EndianConvertWord32(c.filesize);
c.maxprot = CTool_EndianConvertWord32(c.maxprot);
c.initprot = CTool_EndianConvertWord32(c.initprot);
c.nsects = CTool_EndianConvertWord32(c.nsects);
c.flags = CTool_EndianConvertWord32(c.flags);
AppendGListData(&ObjFile, &c, sizeof(c));
#else
AppendGListData(&ObjFile, &segment->cmd, sizeof(segment->cmd));
#endif
for (section = segment->firstSection; section; section = section->next) {
#ifdef ENDIAN_CONVERSION
struct section c = section->section;
c.addr = CTool_EndianConvertWord32(c.addr);
c.size = CTool_EndianConvertWord32(c.size);
c.offset = CTool_EndianConvertWord32(c.offset);
c.align = CTool_EndianConvertWord32(c.align);
c.reloff = CTool_EndianConvertWord32(c.reloff);
c.nreloc = CTool_EndianConvertWord32(c.nreloc);
c.flags = CTool_EndianConvertWord32(c.flags);
c.reserved1 = CTool_EndianConvertWord32(c.reserved1);
c.reserved2 = CTool_EndianConvertWord32(c.reserved2);
AppendGListData(&ObjFile, &c, sizeof(c));
#else
AppendGListData(&ObjFile, &section->section, sizeof(section->section));
#endif
}
}
}
static void WriteSymtabLoadCommand(void) {
struct symtab_command cmd;
UInt32 total;
cmd.cmd = CTool_EndianConvertWord32(LC_SYMTAB);
cmd.cmdsize = CTool_EndianConvertWord32(sizeof(cmd));
cmd.symoff = CTool_EndianConvertWord32(FileOffset);
total = SymNum + NumStabs;
cmd.nsyms = CTool_EndianConvertWord32(total);
FileOffset += total * sizeof(struct nlist);
cmd.stroff = CTool_EndianConvertWord32(FileOffset);
cmd.strsize = CTool_EndianConvertWord32(StringTable.size);
AppendGListData(&ObjFile, &cmd, sizeof(cmd));
}
static void WriteDynamicSymtabLoadCommand(void) {
struct dysymtab_command cmd;
if (!nlocalsym)
ilocalsym = 0;
if (!nextdefsym)
iextdefsym = ilocalsym + nlocalsym;
if (!nundefsym)
iundefsym = iextdefsym + nextdefsym;
ilocalsym += NumStabs;
iextdefsym += NumStabs;
iundefsym += NumStabs;
CError_ASSERT(644, (ilocalsym + nlocalsym) <= (SymNum + NumStabs));
CError_ASSERT(648, (iextdefsym + nextdefsym) <= (SymNum + NumStabs));
CError_ASSERT(652, (iundefsym + nundefsym) <= (SymNum + NumStabs));
cmd.cmd = CTool_EndianConvertWord32(LC_DYSYMTAB);
cmd.cmdsize = CTool_EndianConvertWord32(sizeof(cmd));
cmd.ilocalsym = CTool_EndianConvertWord32(ilocalsym);
cmd.nlocalsym = CTool_EndianConvertWord32(nlocalsym);
cmd.iextdefsym = CTool_EndianConvertWord32(iextdefsym);
cmd.nextdefsym = CTool_EndianConvertWord32(nextdefsym);
cmd.iundefsym = CTool_EndianConvertWord32(iundefsym);
cmd.nundefsym = CTool_EndianConvertWord32(nundefsym);
cmd.tocoff = 0;
cmd.ntoc = 0;
cmd.modtaboff = 0;
cmd.nmodtab = 0;
cmd.extrefsymoff = 0;
cmd.nextrefsyms = 0;
cmd.indirectsymoff = CTool_EndianConvertWord32(IndirectSymbolTableOffset);
cmd.nindirectsyms = CTool_EndianConvertWord32(IndirectSymbolTable.size / 4);
cmd.extreloff = 0;
cmd.nextrel = 0;
cmd.locreloff = 0;
cmd.nlocrel = 0;
AppendGListData(&ObjFile, &cmd, sizeof(cmd));
}
static void WriteSectionData(void) {
MachOSegment *segment;
MachOSection *section;
UInt32 pad;
VmAddr = 0;
for (segment = FirstSeg; segment; segment = segment->next) {
for (section = segment->firstSection; section; section = section->next) {
pad = AlignModulus[section->section.align] - (VmAddr % AlignModulus[section->section.align]);
pad %= AlignModulus[section->section.align];
while (pad) {
AppendGListByte(&ObjFile, 0);
VmAddr++;
FileOffset++;
pad--;
}
if (section->glist.size) {
CError_ASSERT(711, ObjFile.size == section->section.offset);
COS_LockHandle(section->glist.data);
AppendGListData(&ObjFile, *section->glist.data, section->glist.size);
COS_UnlockHandle(section->glist.data);
VmAddr += section->glist.size;
FreeGList(&section->glist);
} else {
VmAddr += pad + section->section.size;
}
}
}
}
static void WriteRelocs(void) {
MachOSegment *segment;
MachOSection *section;
MachOReloc *reloc;
enum reloc_type_ppc pairType;
UInt32 pairValue;
SInt32 scatterFlag;
UInt32 combo;
static char length_code[] = {
0, 0, 1, 1, 2
};
pairType = 0;
pairValue = 0;
scatterFlag = 0;
for (segment = FirstSeg; segment; segment = segment->next) {
for (section = segment->firstSection; section; section = section->next) {
for (reloc = section->firstReloc; reloc; reloc = reloc->next) {
if (reloc->is_extern)
reloc->value += NumStabs;
switch (reloc->reltype) {
case PPC_RELOC_LO16:
case PPC_RELOC_HA16:
case PPC_RELOC_LO14:
pairType = reloc->reltype;
if (reloc->is_extern) {
pairValue = 0;
} else {
pairValue = reloc->next->address + GetSectVMAddr(reloc->value);
}
case PPC_RELOC_VANILLA:
case PPC_RELOC_BR14:
case PPC_RELOC_BR24:
case PPC_RELOC_HI16:
case PPC_RELOC_PB_LA_PTR:
AppendGListLong(&ObjFile, CTool_EndianConvertWord32(reloc->address));
AppendGListLong(&ObjFile,
CTool_EndianConvertWord32((reloc->value << 8) |
(reloc->is_pcrel << 7) |
(length_code[reloc->length] << 5) |
(reloc->is_extern << 4) |
reloc->reltype)
);
break;
case PPC_RELOC_PAIR:
switch (pairType) {
case PPC_RELOC_HI16:
case PPC_RELOC_HA16:
scatterFlag = 0;
reloc->address = pairValue & 0xFFFF;
break;
case PPC_RELOC_LO16:
scatterFlag = 0;
reloc->address = pairValue >> 16;
break;
case PPC_RELOC_HI16_SECTDIFF:
case PPC_RELOC_HA16_SECTDIFF:
scatterFlag = R_SCATTERED;
reloc->value += section->section.addr;
pairValue -= reloc->value;
reloc->address = pairValue & 0xFFFF;
break;
case PPC_RELOC_LO16_SECTDIFF:
scatterFlag = R_SCATTERED;
reloc->value += section->section.addr;
pairValue -= reloc->value;
reloc->address = pairValue >> 16;
break;
default:
CError_FATAL(891);
reloc->address = 0;
break;
}
pairValue = 0;
pairType = 0;
if (scatterFlag) {
AppendGListLong(&ObjFile,
CTool_EndianConvertWord32(scatterFlag |
(reloc->is_pcrel << 30) |
(length_code[reloc->length] << 28) |
(reloc->reltype << 24) |
reloc->address)
);
AppendGListLong(&ObjFile, CTool_EndianConvertWord32(reloc->value));
} else {
combo =
(reloc->value << 8) |
(reloc->is_pcrel << 7) |
(length_code[reloc->length] << 5) |
reloc->reltype;
AppendGListLong(&ObjFile, CTool_EndianConvertWord32(reloc->address));
AppendGListLong(&ObjFile, CTool_EndianConvertWord32(combo));
}
break;
case PPC_RELOC_SECTDIFF:
case PPC_RELOC_HI16_SECTDIFF:
case PPC_RELOC_LO16_SECTDIFF:
case PPC_RELOC_HA16_SECTDIFF:
// build scattered relocation
reloc->value = reloc->next->address + GetSectVMAddr(reloc->value);
pairType = reloc->reltype;
pairValue = reloc->value;
AppendGListLong(&ObjFile,
CTool_EndianConvertWord32(R_SCATTERED |
(reloc->is_pcrel << 30) |
(length_code[reloc->length] << 28) |
(reloc->reltype << 24) |
reloc->address)
);
AppendGListLong(&ObjFile, CTool_EndianConvertWord32(reloc->value));
break;
default:
CError_FATAL(930);
}
}
}
}
}
static void WriteIndirectSymbolTable(void) {
UInt32 i;
UInt32 *ptr;
while (SymPad) {
AppendGListByte(&ObjFile, 0);
SymPad--;
}
COS_LockHandle(IndirectSymbolTable.data);
ptr = (UInt32 *) *IndirectSymbolTable.data;
for (i = 0; i < MachO_NumIndirectSym(); ptr++, i++) {
*ptr += NumStabs;
*ptr = CTool_EndianConvertWord32(*ptr);
}
AppendGListData(&ObjFile, *IndirectSymbolTable.data, IndirectSymbolTable.size);
COS_UnlockHandle(IndirectSymbolTable.data);
FreeGList(&IndirectSymbolTable);
}
static void WriteSymbolTable(void) {
MachOSymbol *symbol;
struct nlist nlist;
if (FirstStab) {
LastStab->next = FirstSym;
FirstSym = FirstStab;
}
for (symbol = FirstSym; symbol; symbol = symbol->next) {
nlist.n_strx = CTool_EndianConvertWord32(symbol->data.u.strx);
nlist.n_type = symbol->data.type;
if (symbol->data.section)
nlist.n_sect = symbol->data.section->num;
else
nlist.n_sect = 0;
nlist.n_desc = CTool_EndianConvertWord16(symbol->data.desc);
if (
symbol->data.type == N_STSYM ||
symbol->data.type == N_FUN ||
symbol->data.type == N_LCSYM ||
symbol->data.type == N_SLINE ||
symbol->data.type == N_SO ||
symbol->data.type == N_SOL ||
symbol->data.type == N_ENTRY ||
symbol->data.type == N_ECOML ||
(symbol->data.type & N_TYPE) == N_SECT
)
{
if (symbol->data.section)
symbol->data.value += symbol->data.section->section.addr;
else
CError_FATAL(1010);
}
nlist.n_value = CTool_EndianConvertWord32(symbol->data.value);
AppendGListData(&ObjFile, &nlist, sizeof(nlist));
}
}
static void WriteStringTable(void) {
COS_LockHandle(StringTable.data);
AppendGListData(&ObjFile, *StringTable.data, StringTable.size);
COS_UnlockHandle(StringTable.data);
}
void MachO_Finish(void) {
struct mach_header hdr;
CodeSize = 0;
IdataSize = UdataSize = 0;
VmAddr = 0;
FileOffset = sizeof(hdr);
hdr.ncmds = AllocateForLoadCommands();
FileOffset += 24; // what am I?
hdr.ncmds++;
if (copts.codegen_dynamic) {
FileOffset += 80; // what am I?
hdr.ncmds++;
}
hdr.ncmds = CTool_EndianConvertWord32(hdr.ncmds);
hdr.sizeofcmds = CTool_EndianConvertWord32(FileOffset - sizeof(hdr));
AllocateAddresses();
ApplyRelocs();
AllocForRelocs();
SymPad = (4 - (FileOffset & 3)) & 3;
FileOffset += SymPad;
IndirectSymbolTableOffset = 0;
if (IndirectSymbolTable.size > 0) {
IndirectSymbolTableOffset = FileOffset;
FileOffset += IndirectSymbolTable.size;
}
InitGList(&ObjFile, 4096);
hdr.magic = CTool_EndianConvertWord32(MH_MAGIC);
hdr.cputype = CTool_EndianConvertWord32(CPU_TYPE_POWERPC);
hdr.cpusubtype = CTool_EndianConvertWord32(CPU_SUBTYPE_MC98000_ALL);
hdr.filetype = CTool_EndianConvertWord32(MH_OBJECT);
hdr.flags = 0;
AppendGListData(&ObjFile, &hdr, sizeof(hdr));
WriteSegLoadCommands();
WriteSymtabLoadCommand();
if (copts.codegen_dynamic)
WriteDynamicSymtabLoadCommand();
WriteSectionData();
WriteRelocs();
WriteIndirectSymbolTable();
WriteSymbolTable();
WriteStringTable();
COS_ResizeHandle(ObjFile.data, ObjFile.size);
cparamblkptr->objectDataHandle = ObjFile.data;
cparamblkptr->objectdata.codesize = CodeSize;
cparamblkptr->objectdata.udatasize = UdataSize;
cparamblkptr->objectdata.idatasize = IdataSize;
}
void MachO_Cleanup(void) {
if (StringTable.data)
FreeGList(&StringTable);
if (IndirectSymbolTable.data)
FreeGList(&IndirectSymbolTable);
}
MachOSegment *MachO_CreateSegment(char *segname, int maxprot, int initprot, UInt32 flags) {
MachOSegment *segment = galloc(sizeof(MachOSegment));
memset(&segment->cmd, 0, sizeof(segment->cmd));
segment->cmd.cmd = LC_SEGMENT;
strncpy(segment->cmd.segname, segname, sizeof(segment->cmd.segname));
segment->cmd.maxprot = maxprot;
segment->cmd.initprot = initprot;
segment->cmd.flags = flags;
segment->firstSection = segment->lastSection = NULL;
segment->next = NULL;
if (FirstSeg == NULL)
FirstSeg = segment;
else
LastSeg->next = segment;
LastSeg = segment;
return segment;
}
MachOSection *MachO_CreateSection(MachOSegment *segment, char *segname, char *sectname, UInt32 align, UInt32 flags, UInt32 sectionID) {
MachOSection *section;
UInt32 alignConv;
alignConv = 0;
while (!(align & 1)) {
align >>= 1;
alignConv++;
}
section = galloc(sizeof(MachOSection));
memset(section, 0, sizeof(MachOSection));
strncpy(section->section.segname, segname, sizeof(section->section.segname));
strncpy(section->section.sectname, sectname, sizeof(section->section.sectname));
section->section.align = alignConv;
section->section.flags = flags;
section->num = ++SectNum;
section->id = sectionID;
section->next = NULL;
if (segment->firstSection == NULL)
segment->firstSection = section;
else
segment->lastSection->next = section;
segment->lastSection = section;
segment->cmd.nsects++;
return section;
}
GList *MachO_GetGList(MachOSection *section) {
if (!section->glist.data)
InitGList(&section->glist, 256);
return &section->glist;
}
void MachO_SetSectionSize(void) {
// empty, unused, unknown args
}
void MachO_Relocate(MachOSection *section, UInt32 address, UInt32 value, char length, char is_pcrel, Boolean is_extern, int reltype) {
MachOReloc *reloc;
reloc = galloc(sizeof(MachOReloc));
reloc->address = address;
reloc->value = value;
reloc->length = length;
reloc->is_pcrel = is_pcrel;
reloc->is_extern = is_extern;
reloc->reltype = reltype;
reloc->next = NULL;
if (section->firstReloc == NULL)
section->firstReloc = reloc;
else
section->lastReloc->next = reloc;
section->lastReloc = reloc;
section->section.nreloc++;
}
static SInt32 DeclareString(char *str) {
SInt32 offset;
if (str) {
offset = StringTable.size;
AppendGListID(&StringTable, str);
} else {
offset = 0;
}
return offset;
}
UInt32 MachO_DeclareSymbol(char *name, MachOSection *section, UInt32 value, Boolean isAbsolute, short type, short desc) {
MachOSymbol *symbol;
symbol = galloc(sizeof(MachOSymbol));
memset(symbol, 0, sizeof(MachOSymbol));
if (section) {
if (type) {
if (nextdefsym == 0)
iextdefsym = SymNum;
nextdefsym++;
} else {
if (nlocalsym == 0)
ilocalsym = SymNum;
nlocalsym++;
}
symbol->data.type = type | N_SECT;
symbol->data.section = section;
} else if (isAbsolute) {
symbol->data.type = type | N_ABS;
} else {
if (nundefsym == 0)
iundefsym = SymNum;
nundefsym++;
symbol->data.type = type & ~N_PEXT;
}
symbol->data.value = value;
symbol->data.u.strx = DeclareString(name);
symbol->data.desc = desc;
symbol->index = SymNum++;
if (FirstSym == NULL)
FirstSym = symbol;
else
LastSym->next = symbol;
LastSym = symbol;
return symbol->index;
}
void MachO_ReOrderSections(void) {
MachOSection *section;
MachOSegment *segment;
MachOSection *prev;
MachOSection *firstRemoved;
MachOSection *lastRemoved;
UInt32 counter;
counter = 0;
for (segment = FirstSeg; segment; segment = segment->next) {
prev = NULL;
section = segment->firstSection;
firstRemoved = lastRemoved = NULL;
while (section) {
if (section->section.size && section->glist.data == NULL && section != segment->firstSection) {
// detach this section
if (prev)
prev->next = section->next;
else
segment->firstSection = section->next;
if (section == segment->lastSection)
segment->lastSection = prev;
section->next = NULL;
// add it to the list to be pushed to the end
if (firstRemoved == NULL)
firstRemoved = section;
else
lastRemoved->next = section;
lastRemoved = section;
// continue iterating
if (prev)
section = prev->next;
else
section = segment->firstSection;
} else {
prev = section;
section = section->next;
}
}
// attach the other sections
if (firstRemoved) {
if (segment->firstSection == NULL)
segment->firstSection = firstRemoved;
else
segment->lastSection->next = firstRemoved;
segment->lastSection = lastRemoved;
}
// renumber them all
for (section = segment->firstSection; section; section = section->next)
section->num = ++counter;
}
}
void MachO_AddIndirectSymbol(SInt32 symbol) {
CError_ASSERT(1577, symbol >= 0);
AppendGListLong(&IndirectSymbolTable, symbol);
}
UInt32 MachO_NumIndirectSym(void) {
return IndirectSymbolTable.size / 4;
}
SInt32 MachO_OutputStab(SymbolData *data, SInt32 strIndex) {
MachOSymbol *symbol;
symbol = galloc(sizeof(MachOSymbol));
memset(symbol, 0, sizeof(MachOSymbol));
if (strIndex == -1)
data->u.strx = DeclareString(data->u.name);
else
data->u.strx = strIndex;
memcpy(&symbol->data, data, sizeof(SymbolData));
if (FirstStab == NULL)
FirstStab = symbol;
else
LastStab->next = symbol;
LastStab = symbol;
NumStabs++;
return data->u.strx;
}
Reference in New Issue View Git Blame Copy Permalink