578 lines
23 KiB
C++
578 lines
23 KiB
C++
/**************************** mac2asm.cpp *********************************
|
|
* Author: Agner Fog
|
|
* Date created: 2007-05-24
|
|
* Last modified: 2008-05-12
|
|
* Project: objconv
|
|
* Module: mac2asm.cpp
|
|
* Description:
|
|
* Module for disassembling Mach-O files
|
|
*
|
|
* Copyright 2007-2008 GNU General Public License http://www.gnu.org/licenses
|
|
*****************************************************************************/
|
|
#include "stdafx.h"
|
|
|
|
// Constructor
|
|
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
|
|
CMAC2ASM<MACSTRUCTURES>::CMAC2ASM() {
|
|
}
|
|
|
|
// Convert
|
|
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
|
|
void CMAC2ASM<MACSTRUCTURES>::Convert() {
|
|
// Do the conversion
|
|
|
|
// Check cpu type
|
|
switch (this->FileHeader.cputype) {
|
|
case MAC_CPU_TYPE_I386:
|
|
this->WordSize = 32; break;
|
|
|
|
case MAC_CPU_TYPE_X86_64:
|
|
this->WordSize = 64; break;
|
|
|
|
default:
|
|
// Wrong type
|
|
err.submit(2011, ""); return;
|
|
}
|
|
|
|
// check object/executable file type
|
|
uint32 ExeType; // File type: 0 = object, 1 = position independent shared object, 2 = executable
|
|
|
|
switch (this->FileHeader.filetype) {
|
|
case MAC_OBJECT: // Relocatable object file
|
|
ExeType = 0; break;
|
|
|
|
case MAC_FVMLIB: // fixed VM shared library file
|
|
case MAC_DYLIB: // dynamicly bound shared library file
|
|
case MAC_BUNDLE: // part of universal binary
|
|
ExeType = 1; break;
|
|
|
|
case MAC_EXECUTE: // demand paged executable file
|
|
case MAC_CORE: // core file
|
|
case MAC_PRELOAD: // preloaded executable file
|
|
ExeType = 2; break;
|
|
|
|
default: // Other types
|
|
err.submit(2011, ""); return;
|
|
}
|
|
|
|
// Tell disassembler
|
|
// Disasm.Init(ExeType, this->ImageBase);
|
|
Disasm.Init(ExeType, 0);
|
|
|
|
// Make Sections list and relocations list
|
|
MakeSectionList();
|
|
|
|
// Make Symbols list in Disasm
|
|
MakeSymbolList();
|
|
|
|
// Make relocations list in Disasm
|
|
MakeRelocations();
|
|
|
|
// Make symbol entries for imported symbols
|
|
MakeImports();
|
|
|
|
Disasm.Go(); // Disassemble
|
|
|
|
*this << Disasm.OutFile; // Take over output file from Disasm
|
|
}
|
|
|
|
// MakeSectionList
|
|
|
|
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
|
|
void CMAC2ASM<MACSTRUCTURES>::MakeSectionList() {
|
|
// Make Sections list and Relocations list in Disasm
|
|
|
|
uint32 icmd; // Command index
|
|
int32 isec1; // Section index within segment
|
|
int32 isec2 = 0; // Section index global
|
|
int32 nsect; // Number of sections in segment
|
|
uint32 cmd; // Load command
|
|
uint32 cmdsize; // Command size
|
|
|
|
StringBuffer.Push(0, 1); // Initialize string buffer
|
|
|
|
// Pointer to current position
|
|
uint8 * currentp = (uint8*)(this->Buf() + sizeof(TMAC_header));
|
|
|
|
// Loop through file commands
|
|
for (icmd = 1; icmd <= this->FileHeader.ncmds; icmd++) {
|
|
cmd = ((MAC_load_command*)currentp) -> cmd;
|
|
cmdsize = ((MAC_load_command*)currentp) -> cmdsize;
|
|
|
|
if (cmd == MAC_LC_SEGMENT || cmd == MAC_LC_SEGMENT_64) {
|
|
// This is a segment command
|
|
if ((this->WordSize == 64) ^ (cmd == MAC_LC_SEGMENT_64)) {
|
|
// Inconsistent word size
|
|
err.submit(2320); break;
|
|
}
|
|
|
|
// Number of sections in segment
|
|
nsect = ((TMAC_segment_command*)currentp) -> nsects;
|
|
|
|
// Find first section header
|
|
TMAC_section * sectp = (TMAC_section*)(currentp + sizeof(TMAC_segment_command));
|
|
|
|
// Loop through section headers
|
|
for (isec1 = 1; isec1 <= nsect; isec1++, sectp++) {
|
|
|
|
if (sectp->offset >= this->GetDataSize()) {
|
|
// points outside file
|
|
err.submit(2035); break;
|
|
}
|
|
|
|
// Get section properties
|
|
isec2++; // Section number
|
|
uint32 MacSectionType = sectp->flags & MAC_SECTION_TYPE;
|
|
uint8 * Buffer = (uint8*)(this->Buf()) + sectp->offset;
|
|
uint32 TotalSize = (uint32)sectp->size;
|
|
uint32 InitSize = TotalSize;
|
|
if (MacSectionType == MAC_S_ZEROFILL) InitSize = 0;
|
|
uint32 SectionAddress = (uint32)sectp->addr;
|
|
uint32 Align = sectp->align;
|
|
|
|
// Get section type
|
|
// 0 = unknown, 1 = code, 2 = data, 3 = uninitialized data, 4 = constant data
|
|
uint32 Type = 0;
|
|
if (sectp->flags & (MAC_S_ATTR_PURE_INSTRUCTIONS | MAC_S_ATTR_SOME_INSTRUCTIONS)) {
|
|
Type = 1; // code
|
|
}
|
|
else if (MacSectionType == MAC_S_ZEROFILL) {
|
|
Type = 3; // uninitialized data
|
|
}
|
|
else {
|
|
Type = 2; // data or anything else
|
|
}
|
|
|
|
// Make section name by combining segment name and section name
|
|
uint32 NameOffset = StringBuffer.Push(sectp->segname, (uint32)strlen(sectp->segname)); // Segment name
|
|
StringBuffer.Push(".", 1); // Separate by dot
|
|
StringBuffer.PushString(sectp->sectname); // Section name
|
|
char * Name = StringBuffer.Buf() + NameOffset;
|
|
|
|
// Save section record
|
|
Disasm.AddSection(Buffer, InitSize, TotalSize, SectionAddress, Type, Align, this->WordSize, Name);
|
|
|
|
// Save information about relocation list for this section
|
|
if (sectp->nreloc) {
|
|
MAC_SECT_WITH_RELOC RelList = {isec2, sectp->offset, sectp->nreloc, sectp->reloff};
|
|
RelocationQueue.Push(RelList);
|
|
}
|
|
|
|
// Find import tables
|
|
if (MacSectionType >= MAC_S_NON_LAZY_SYMBOL_POINTERS && MacSectionType <= MAC_S_LAZY_SYMBOL_POINTERS /*?*/) {
|
|
// This is an import table
|
|
ImportSections.Push(sectp);
|
|
}
|
|
// Find literals sections
|
|
if (MacSectionType == MAC_S_4BYTE_LITERALS || MacSectionType == MAC_S_8BYTE_LITERALS) {
|
|
// This is a literals section
|
|
ImportSections.Push(sectp);
|
|
}
|
|
}
|
|
}
|
|
currentp += cmdsize;
|
|
}
|
|
}
|
|
|
|
// MakeRelocations
|
|
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
|
|
void CMAC2ASM<MACSTRUCTURES>::MakeRelocations() {
|
|
// Make relocations for object and executable files
|
|
uint32 iqq; // Index into RelocationQueue = table of relocation tables
|
|
uint32 irel; // Index into relocation table
|
|
int32 Section; // Section index
|
|
uint32 SectOffset; // File offset of section binary data
|
|
uint32 NumReloc; // Number of relocations records for this section
|
|
uint32 ReltabOffset; // File offset of relocation table for this section
|
|
uint32 SourceOffset; // Section-relative offset of relocation source
|
|
uint32 SourceSize; // Size of relocation source
|
|
int32 Inline = 0; // Inline addend at relocation source
|
|
uint32 TargetAddress; // Base-relative address of relocation target
|
|
uint32 TargetSymbol; // Symbol index of target
|
|
//int32 TargetSection; // Target section
|
|
int32 Addend; // Offset to add to target
|
|
uint32 ReferenceAddress; // Base-relative address of reference point
|
|
uint32 ReferenceSymbol; // Symbol index of reference point
|
|
uint32 R_Type; // Relocation type in Mach-O record
|
|
uint32 R_Type2; // Relocation type of second entry of a pair
|
|
uint32 R_PCRel; // Relocation is self-relative
|
|
uint32 RelType = 0; // Relocation type translated to disasm record
|
|
|
|
// Loop through RelocationQueue. There is one entry for each relocation table
|
|
for (iqq = 0; iqq < RelocationQueue.GetNumEntries(); iqq++) {
|
|
Section = RelocationQueue[iqq].Section; // Section index
|
|
SectOffset = RelocationQueue[iqq].SectOffset; // File offset of section binary data
|
|
NumReloc = RelocationQueue[iqq].NumReloc; // Number of relocations records for this section
|
|
ReltabOffset = RelocationQueue[iqq].ReltabOffset; // File offset of relocation table for this section
|
|
|
|
if (NumReloc == 0) continue;
|
|
|
|
if (ReltabOffset == 0 || ReltabOffset >= this->GetDataSize() || ReltabOffset + NumReloc*sizeof(MAC_relocation_info) >= this->GetDataSize()) {
|
|
// Pointer out of range
|
|
err.submit(2035); return;
|
|
}
|
|
|
|
// pointer to relocation info
|
|
union {
|
|
MAC_relocation_info * r;
|
|
MAC_scattered_relocation_info * s;
|
|
int8 * b;
|
|
} relp;
|
|
// Point to first relocation entry
|
|
relp.b = this->Buf() + ReltabOffset;
|
|
|
|
// Loop through relocation table
|
|
for (irel = 0; irel < NumReloc; irel++, relp.r++) {
|
|
|
|
// Set defaults
|
|
ReferenceAddress = ReferenceSymbol = TargetSymbol = Addend = 0;
|
|
|
|
if (relp.s->r_scattered) {
|
|
// scattered relocation entry
|
|
SourceOffset = relp.s->r_address;
|
|
SourceSize = 1 << relp.s->r_length;
|
|
R_PCRel = relp.s->r_pcrel;
|
|
R_Type = relp.s->r_type;
|
|
TargetAddress = relp.s->r_value;
|
|
TargetSymbol = 0;
|
|
}
|
|
else {
|
|
// non-scattered relocation entry
|
|
SourceOffset = relp.r->r_address;
|
|
SourceSize = 1 << relp.r->r_length;
|
|
R_PCRel = relp.r->r_pcrel;
|
|
R_Type = relp.r->r_type;
|
|
if (relp.r->r_extern) {
|
|
TargetSymbol = relp.r->r_symbolnum + 1;
|
|
}
|
|
else {
|
|
//TargetSection = relp.r->r_symbolnum;
|
|
}
|
|
TargetAddress = 0;
|
|
}
|
|
|
|
if (this->WordSize == 32 && (R_Type == MAC32_RELOC_SECTDIFF || R_Type == MAC32_RELOC_LOCAL_SECTDIFF)) {
|
|
// This is the first of a pair of relocation entries.
|
|
// Get second entry containing reference point
|
|
irel++; relp.r++;
|
|
if (irel >= NumReloc) {err.submit(2050); break;}
|
|
|
|
if (relp.s->r_scattered) {
|
|
// scattered relocation entry
|
|
R_Type2 = relp.s->r_type;
|
|
ReferenceAddress = relp.s->r_value;
|
|
ReferenceSymbol = 0;
|
|
}
|
|
else {
|
|
// non-scattered relocation entry
|
|
ReferenceSymbol = relp.r->r_symbolnum + 1;
|
|
R_Type2 = relp.r->r_type;
|
|
ReferenceAddress = 0;
|
|
}
|
|
if (R_Type2 != MAC32_RELOC_PAIR) {err.submit(2050); break;}
|
|
|
|
if (ReferenceSymbol == 0) {
|
|
// Reference point has no symbol index. Make one
|
|
ReferenceSymbol = Disasm.AddSymbol(ASM_SEGMENT_IMGREL, ReferenceAddress, 0, 0, 2, 0, 0);
|
|
}
|
|
}
|
|
|
|
if (this->WordSize == 64 && R_Type == MAC64_RELOC_SUBTRACTOR) {
|
|
// This is the first of a pair of relocation entries.
|
|
// The first entry contains reference point to subtract
|
|
irel++; relp.r++;
|
|
if (irel >= NumReloc || relp.s->r_scattered || relp.r->r_type != MAC64_RELOC_UNSIGNED) {
|
|
err.submit(2050); break;
|
|
}
|
|
ReferenceSymbol = TargetSymbol;
|
|
R_PCRel = relp.r->r_pcrel;
|
|
if (relp.r->r_extern) {
|
|
TargetSymbol = relp.r->r_symbolnum + 1;
|
|
}
|
|
else {
|
|
//TargetSection = relp.r->r_symbolnum;
|
|
}
|
|
TargetAddress = 0;
|
|
}
|
|
|
|
// Get inline addend or address
|
|
if (SectOffset + SourceOffset < this->GetDataSize()) {
|
|
switch (SourceSize) {
|
|
case 1:
|
|
Inline = CMemoryBuffer::Get<int8>(SectOffset+SourceOffset);
|
|
// (this->Get<int8> doesn't work on Gnu compiler 4.0.1)
|
|
break;
|
|
case 2:
|
|
Inline = CMemoryBuffer::Get<int16>(SectOffset+SourceOffset);
|
|
break;
|
|
case 4: case 8:
|
|
Inline = CMemoryBuffer::Get<int32>(SectOffset+SourceOffset);
|
|
break;
|
|
default:
|
|
Inline = 0;
|
|
}
|
|
}
|
|
|
|
if (this->WordSize == 32) {
|
|
// Calculate target address and addend, 32 bit system
|
|
if (R_Type == MAC32_RELOC_SECTDIFF || R_Type == MAC32_RELOC_LOCAL_SECTDIFF) {
|
|
// Relative to reference point
|
|
// Compensate for inline value = TargetAddress - ReferenceAddress;
|
|
Addend = ReferenceAddress - TargetAddress;
|
|
}
|
|
else if (R_PCRel) {
|
|
// Self-relative
|
|
TargetAddress += Inline + SourceOffset + SourceSize;
|
|
Addend = -4 - Inline;
|
|
}
|
|
else {
|
|
// Direct
|
|
TargetAddress += Inline;
|
|
Addend = -Inline;
|
|
}
|
|
}
|
|
|
|
if (TargetSymbol == 0) {
|
|
// Target has no symbol index. Make one
|
|
TargetSymbol = Disasm.AddSymbol(ASM_SEGMENT_IMGREL, TargetAddress, 0, 0, 2, 0, 0);
|
|
}
|
|
|
|
// Find type
|
|
if (this->WordSize == 32) {
|
|
switch (R_Type) {
|
|
case MAC32_RELOC_VANILLA:
|
|
// Direct or self-relative
|
|
RelType = R_PCRel ? 2 : 1;
|
|
break;
|
|
|
|
case MAC32_RELOC_SECTDIFF: case MAC32_RELOC_LOCAL_SECTDIFF:
|
|
// Relative to reference point
|
|
RelType = 0x10;
|
|
break;
|
|
|
|
case MAC32_RELOC_PB_LA_PTR:
|
|
// Lazy pointer
|
|
RelType = 0x41; //??
|
|
break;
|
|
|
|
default:
|
|
// Unknown type
|
|
err.submit(2030, R_Type);
|
|
break;
|
|
}
|
|
}
|
|
else { // 64-bit relocation types
|
|
switch (R_Type) {
|
|
case MAC64_RELOC_UNSIGNED:
|
|
// Absolute address
|
|
RelType = 1;
|
|
break;
|
|
case MAC64_RELOC_BRANCH:
|
|
// Signed 32-bit displacement with implicit -4 addend
|
|
case MAC64_RELOC_SIGNED:
|
|
// Signed 32-bit displacement with implicit -4 addend
|
|
case MAC64_RELOC_SIGNED_1:
|
|
// Signed 32-bit displacement with implicit -4 addend and explicit -1 addend
|
|
case MAC64_RELOC_SIGNED_2:
|
|
// Signed 32-bit displacement with implicit -4 addend and explicit -2 addend
|
|
case MAC64_RELOC_SIGNED_4:
|
|
// Signed 32-bit displacement with implicit -4 addend and explicit -4 addend
|
|
RelType = 2; Addend -= 4;
|
|
break;
|
|
case MAC64_RELOC_GOT:
|
|
// Absolute or relative reference to GOT?
|
|
// RelType = 0x1001; break;
|
|
case MAC64_RELOC_GOT_LOAD:
|
|
// Signed 32-bit displacement to GOT
|
|
RelType = 0x1002; Addend -= 4;
|
|
break;
|
|
case MAC64_RELOC_SUBTRACTOR:
|
|
// 32 or 64 bit relative to arbitrary reference point
|
|
RelType = 0x10;
|
|
break;
|
|
default:
|
|
// Unknown type
|
|
err.submit(2030, R_Type);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Make relocation record
|
|
Disasm.AddRelocation(Section, SourceOffset, Addend,
|
|
RelType, SourceSize, TargetSymbol, ReferenceSymbol);
|
|
}
|
|
}
|
|
}
|
|
|
|
// MakeSymbolList
|
|
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
|
|
void CMAC2ASM<MACSTRUCTURES>::MakeSymbolList() {
|
|
// Make Symbols list in Disasm
|
|
uint32 symi; // Symbol index, 0-based
|
|
uint32 symn = 0; // Symbol number, 1-based
|
|
char * Name; // Symbol name
|
|
int32 Section; // Section number (1-based). 0 = external, ASM_SEGMENT_ABSOLUTE = absolute, ASM_SEGMENT_IMGREL = image-relative
|
|
uint32 Offset; // Offset into section. (Value for absolute symbol)
|
|
uint32 Type; // Symbol type. Use values listed above for SOpcodeDef operands. 0 = unknown type
|
|
uint32 Scope; // 1 = function local, 2 = file local, 4 = public, 8 = weak public, 0x10 = communal, 0x20 = external
|
|
|
|
// pointer to string table
|
|
char * strtab = (char*)(this->Buf() + this->StringTabOffset);
|
|
|
|
// loop through symbol table
|
|
TMAC_nlist * symp = (TMAC_nlist*)(this->Buf() + this->SymTabOffset);
|
|
for (symi = 0; symi < this->SymTabNumber; symi++, symp++) {
|
|
|
|
if (symp->n_type & MAC_N_STAB) {
|
|
// Debug symbol. Ignore
|
|
continue;
|
|
}
|
|
|
|
if (symp->n_strx < this->StringTabSize) {
|
|
// Normal symbol
|
|
Section = symp->n_sect;
|
|
Offset = (uint32)symp->n_value;
|
|
Name = strtab + symp->n_strx;
|
|
symn = symi + 1; // Convert 0-based to 1-based index
|
|
|
|
// Get scope
|
|
if (symi < this->iextdefsym) {
|
|
// Local
|
|
Scope = 2;
|
|
}
|
|
else if (Section && (symp->n_type & MAC_N_TYPE) != MAC_N_UNDF) {
|
|
// Public
|
|
Scope = 4;
|
|
}
|
|
else {
|
|
// External
|
|
Scope = 0x20;
|
|
}
|
|
// Check if absolute
|
|
if ((symp->n_type & MAC_N_TYPE) == MAC_N_ABS) {
|
|
// Absolute
|
|
Section = ASM_SEGMENT_ABSOLUTE; Scope = 4;
|
|
}
|
|
// Check if weak/communal
|
|
if (symp->n_type & MAC_N_PEXT) {
|
|
// Communal?
|
|
Scope = 0x10;
|
|
}
|
|
else if (symp->n_desc & MAC_N_WEAK_DEF) {
|
|
// Weak public
|
|
Scope = 8;
|
|
}
|
|
else if (symp->n_desc & MAC_N_WEAK_REF) {
|
|
// Weak external (not supported by disassembler)
|
|
Scope = 0x20;
|
|
}
|
|
// Get type
|
|
Type = 0;
|
|
|
|
// Offset is always based, not section-relative
|
|
if (Section > 0) Section = ASM_SEGMENT_IMGREL;
|
|
|
|
// Add symbol to diassembler
|
|
Disasm.AddSymbol(Section, Offset, 0, Type, Scope, symn, Name);
|
|
}
|
|
}
|
|
}
|
|
|
|
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
|
|
void CMAC2ASM<MACSTRUCTURES>::MakeImports() {
|
|
// Make symbol entries for all import tables
|
|
uint32 isec; // Index into ImportSections list
|
|
uint32 SectionType; // Section type
|
|
TMAC_section * sectp; // Pointer to section
|
|
TMAC_nlist * symp0 = (TMAC_nlist*)(this->Buf() + this->SymTabOffset); // Pointer to symbol table
|
|
uint32 * IndSymp = (uint32*)(this->Buf() + this->IndirectSymTabOffset); // Pointer to indirect symbol table
|
|
uint32 iimp; // Index into import table
|
|
char * strtab = (char*)(this->Buf() + this->StringTabOffset); // pointer to string table
|
|
|
|
// Loop through import sections
|
|
for (isec = 0; isec < ImportSections.GetNumEntries(); isec++) {
|
|
// Pointer to section header
|
|
sectp = ImportSections[isec];
|
|
// Section type
|
|
SectionType = sectp->flags & MAC_SECTION_TYPE;
|
|
if (SectionType >= MAC_S_NON_LAZY_SYMBOL_POINTERS && SectionType <= MAC_S_MOD_INIT_FUNC_POINTERS) {
|
|
|
|
// This section contains import tables
|
|
// Entry size in import table
|
|
uint32 EntrySize = sectp->reserved2;
|
|
// Entry size is 4 if not specified
|
|
if (EntrySize == 0) EntrySize = 4;
|
|
// Number of entries
|
|
uint32 NumEntries = (uint32)sectp->size / EntrySize;
|
|
// Index into indirect symbol table entry of first entry in import table
|
|
uint32 Firsti = sectp->reserved1;
|
|
// Check if within range
|
|
if (Firsti + NumEntries > this->IndirectSymTabNumber) {
|
|
// This occurs when disassembling 64-bit Mach-O executable
|
|
// I don't know how to interpret the import table
|
|
err.submit(1054); continue;
|
|
}
|
|
// Loop through import table entries
|
|
for (iimp = 0; iimp < NumEntries; iimp++) {
|
|
// Address of import table entry
|
|
uint32 ImportAddress = (uint32)sectp->addr + iimp * EntrySize;
|
|
// Get symbol table index from indirect symbol table
|
|
uint32 symi = IndSymp[iimp + Firsti];
|
|
// Check index
|
|
if (symi == 0x80000000) {
|
|
// This value occurs. Maybe it means ignore?
|
|
continue;
|
|
}
|
|
// Check if index within symbol table
|
|
if (symi >= this->SymTabNumber) {
|
|
err.submit(1052); continue;
|
|
}
|
|
// Find name
|
|
uint32 StringIndex = symp0[symi].n_strx;
|
|
if (StringIndex >= this->StringTabSize) {
|
|
err.submit(1052); continue;
|
|
}
|
|
const char * Name = strtab + StringIndex;
|
|
// Name of .so to import from
|
|
const char * DLLName = "?";
|
|
|
|
// Symbol type
|
|
uint32 Type = 0;
|
|
switch (SectionType) {
|
|
case MAC_S_NON_LAZY_SYMBOL_POINTERS:
|
|
case MAC_S_LAZY_SYMBOL_POINTERS:
|
|
// pointer to symbol
|
|
Type = 3; break;
|
|
case MAC_S_SYMBOL_STUBS:
|
|
// jump to function
|
|
Type = 0x83;
|
|
// Make appear as direct call
|
|
DLLName = 0;
|
|
break;
|
|
case MAC_S_MOD_INIT_FUNC_POINTERS:
|
|
// function pointer?
|
|
Type = 0x0C; break;
|
|
}
|
|
|
|
// Make symbol record for disassembler
|
|
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, ImportAddress, 4, Type, 2, 0, Name, DLLName);
|
|
}
|
|
}
|
|
else if (SectionType == MAC_S_4BYTE_LITERALS) {
|
|
// Section contains 4-byte float constants.
|
|
// Make symbol
|
|
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, (uint32)sectp->addr, 4, 0x43, 2, 0, "Float_constants");
|
|
}
|
|
else if (SectionType == MAC_S_8BYTE_LITERALS) {
|
|
// Section contains 8-byte double constants.
|
|
// Make symbol
|
|
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, (uint32)sectp->addr, 8, 0x44, 2, 0, "Double_constants");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Make template instances for 32 and 64 bits
|
|
template class CMAC2ASM<MAC32STRUCTURES>;
|
|
template class CMAC2ASM<MAC64STRUCTURES>;
|