зеркало из https://github.com/mozilla/gecko-dev.git
344 строки
11 KiB
C++
344 строки
11 KiB
C++
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
|
|
* implied. See the License for the specific language governing
|
|
* rights and limitations under the License.
|
|
*
|
|
* The Original Code is Mozilla Communicator client code, released
|
|
* March 31, 1998.
|
|
*
|
|
* The Initial Developer of the Original Code is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
* Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*
|
|
* Patrick C. Beard <beard@netscape.com>
|
|
*
|
|
* Alternatively, the contents of this file may be used under the
|
|
* terms of the GNU Public License (the "GPL"), in which case the
|
|
* provisions of the GPL are applicable instead of those above.
|
|
* If you wish to allow use of your version of this file only
|
|
* under the terms of the GPL and not to allow others to use your
|
|
* version of this file under the NPL, indicate your decision by
|
|
* deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this
|
|
* file under either the NPL or the GPL.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <Memory.h>
|
|
|
|
#include "SymFiles.h"
|
|
#include "sym_file.h"
|
|
#include "gc.h"
|
|
|
|
struct sym_file {
|
|
// file data structures.
|
|
FSSpec mFileSpec;
|
|
SInt16 mFileRef;
|
|
UInt8* mPageBuffer;
|
|
UInt32 mPageOffset;
|
|
UInt32 mBufferOffset;
|
|
|
|
DiskSymbolHeaderBlock mHeader;
|
|
ResourceTableEntry mCodeEntry;
|
|
UInt8** mNameTable;
|
|
|
|
sym_file(const FSSpec* spec);
|
|
~sym_file();
|
|
|
|
bool init();
|
|
bool open();
|
|
bool close();
|
|
bool seek(UInt32 position);
|
|
UInt32 read(void* buffer, UInt32 count);
|
|
|
|
const UInt8* getName(UInt32 nameIndex);
|
|
};
|
|
|
|
sym_file::sym_file(const FSSpec* spec)
|
|
: mFileSpec(*spec), mFileRef(-1), mPageBuffer(NULL), mPageOffset(0), mBufferOffset(0),
|
|
mNameTable(NULL)
|
|
{
|
|
}
|
|
|
|
sym_file::~sym_file()
|
|
{
|
|
// this seems to die when we are being debugged.
|
|
if (mFileRef != -1) {
|
|
::FSClose(mFileRef);
|
|
mFileRef = -1;
|
|
}
|
|
|
|
if (mPageBuffer != NULL) {
|
|
delete[] mPageBuffer;
|
|
mPageBuffer = NULL;
|
|
}
|
|
|
|
if (mNameTable != NULL) {
|
|
UInt8** nameTable = mNameTable;
|
|
UInt16 pageCount = mHeader.dshb_nte.dti_page_count;
|
|
while (pageCount-- > 0) {
|
|
GC_free(*nameTable++);
|
|
}
|
|
delete[] mNameTable;
|
|
mNameTable = NULL;
|
|
}
|
|
}
|
|
|
|
bool sym_file::init()
|
|
{
|
|
// open the file.
|
|
if (!open())
|
|
return false;
|
|
|
|
// read the header. should make sure it is a valid .xSYM file, etc.
|
|
DiskSymbolHeaderBlock& header = mHeader;
|
|
long count = sizeof(header);
|
|
if (::FSRead(mFileRef, (long*) &count, &header) != noErr || count != sizeof(header))
|
|
return false;
|
|
|
|
// read the name table.
|
|
mNameTable = new UInt8*[header.dshb_nte.dti_page_count];
|
|
if (mNameTable == NULL)
|
|
return false;
|
|
|
|
// seek to first page of the name table.
|
|
::SetFPos(mFileRef, fsFromStart, header.dshb_nte.dti_first_page * header.dshb_page_size);
|
|
// read all of the pages into memory, for speed.
|
|
for (int i = 0; i < header.dshb_nte.dti_page_count; i++) {
|
|
// allocate each page atomically, so GC won't have to scan them.
|
|
UInt8* page = mNameTable[i] = (UInt8*) GC_malloc_atomic(header.dshb_page_size);
|
|
if (page == NULL)
|
|
return false;
|
|
count = header.dshb_page_size;
|
|
if (::FSRead(mFileRef, &count, page) != noErr || count != header.dshb_page_size)
|
|
return false;
|
|
}
|
|
|
|
// allocate the page buffer and initialize offsets.
|
|
mPageBuffer = new UInt8[header.dshb_page_size];
|
|
|
|
// read the RTE tables.
|
|
seek(header.dshb_rte.dti_first_page * header.dshb_page_size + sizeof(ResourceTableEntry));
|
|
for (int i = 1; i <= header.dshb_rte.dti_object_count; i++) {
|
|
ResourceTableEntry resEntry;
|
|
if (read(&resEntry, sizeof(resEntry)) == sizeof(resEntry)) {
|
|
switch (resEntry.rte_ResType) {
|
|
case 'CODE':
|
|
mCodeEntry = resEntry;
|
|
break;
|
|
case 'DATA':
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool sym_file::open()
|
|
{
|
|
if (mFileRef == -1) {
|
|
// open the specified symbol file.
|
|
if (::FSpOpenDF(&mFileSpec, fsRdPerm, &mFileRef) != noErr)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool sym_file::close()
|
|
{
|
|
if (mFileRef != -1) {
|
|
::FSClose(mFileRef);
|
|
mFileRef = -1;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool sym_file::seek(UInt32 position)
|
|
{
|
|
if (position != (mPageOffset + mBufferOffset)) {
|
|
// if position is off current page, the resync the buffer.
|
|
UInt32 pageSize = mHeader.dshb_page_size;
|
|
if (position < mPageOffset || position >= (mPageOffset + pageSize)) {
|
|
// make sure the file is open.
|
|
if (!open())
|
|
return false;
|
|
// read the nearest page to this offset.
|
|
mPageOffset = (position - (position % pageSize));
|
|
if (::SetFPos(mFileRef, fsFromStart, mPageOffset) != noErr)
|
|
return false;
|
|
long count = pageSize;
|
|
if (::FSRead(mFileRef, &count, mPageBuffer) != noErr)
|
|
return false;
|
|
}
|
|
mBufferOffset = (position - mPageOffset);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
UInt32 sym_file::read(void* buffer, UInt32 count)
|
|
{
|
|
// we don't handle reads that aren't on the current page.
|
|
if ((mBufferOffset + count) < mHeader.dshb_page_size) {
|
|
::BlockMoveData(mPageBuffer + mBufferOffset, buffer, count);
|
|
mBufferOffset += count;
|
|
return count;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
const UInt8* sym_file::getName(UInt32 nameIndex)
|
|
{
|
|
UInt32 nameOffset = 2 * nameIndex;
|
|
const UInt8* page = mNameTable[nameOffset / mHeader.dshb_page_size];
|
|
const UInt8* name = page + (nameOffset % mHeader.dshb_page_size);
|
|
return name;
|
|
}
|
|
|
|
static bool getFileReferenceTableEntry(sym_file* symbols,
|
|
const FileReference& fileRef,
|
|
FileReferenceTableEntry* frte)
|
|
{
|
|
const DiskSymbolHeaderBlock& header = symbols->mHeader;
|
|
UInt32 fileRefsPerPage = (header.dshb_page_size / sizeof(FileReferenceTableEntry));
|
|
UInt32 fileRefPage = (fileRef.fref_frte_index / fileRefsPerPage);
|
|
UInt32 fileRefIndex = (fileRef.fref_frte_index % fileRefsPerPage);
|
|
|
|
// seek to the specified frte.
|
|
symbols->seek((header.dshb_frte.dti_first_page + fileRefPage) * header.dshb_page_size + fileRefIndex * sizeof(FileReferenceTableEntry));
|
|
return (symbols->read(frte, sizeof(FileReferenceTableEntry)) == sizeof(FileReferenceTableEntry));
|
|
}
|
|
|
|
static bool getContainedStatementTableEntry(sym_file* symbols,
|
|
UInt32 statementIndex,
|
|
ContainedStatementsTableEntry* statementEntry)
|
|
{
|
|
const DiskSymbolHeaderBlock& header = symbols->mHeader;
|
|
UInt32 entriesPerPage = (header.dshb_page_size / sizeof(ContainedStatementsTableEntry));
|
|
UInt32 entryPage = (statementIndex / entriesPerPage);
|
|
UInt32 entryIndex = (statementIndex % entriesPerPage);
|
|
|
|
// seek to the specified statement entry.
|
|
symbols->seek((header.dshb_csnte.dti_first_page + entryPage) * header.dshb_page_size + entryIndex * sizeof(ContainedStatementsTableEntry));
|
|
return (symbols->read(statementEntry, sizeof(ContainedStatementsTableEntry)) == sizeof(ContainedStatementsTableEntry));
|
|
}
|
|
|
|
inline bool isMeatyModule(const ModulesTableEntry& moduleEntry)
|
|
{
|
|
return (moduleEntry.mte_kind == kModuleKindProcedure) || (moduleEntry.mte_kind == kModuleKindFunction);
|
|
}
|
|
|
|
inline UInt32 delta(UInt32 x, UInt32 y)
|
|
{
|
|
if (x > y)
|
|
return (x - y);
|
|
else
|
|
return (y - x);
|
|
}
|
|
|
|
int get_source(sym_file* symbols, UInt32 codeOffset, char fileName[256], UInt32* fileOffset)
|
|
{
|
|
const DiskSymbolHeaderBlock& header = symbols->mHeader;
|
|
const ResourceTableEntry& codeEntry = symbols->mCodeEntry;
|
|
|
|
// since module entries can't span pages, must compute which page module entry size.
|
|
UInt32 modulesPerPage = (header.dshb_page_size / sizeof(ModulesTableEntry));
|
|
|
|
// search for MTE nearest specified offset.
|
|
// seek to first MTE.
|
|
for (UInt16 i = codeEntry.rte_mte_first; i <= codeEntry.rte_mte_last; i++) {
|
|
ModulesTableEntry moduleEntry;
|
|
UInt32 modulePage = (i / modulesPerPage);
|
|
UInt32 moduleIndex = (i % modulesPerPage);
|
|
symbols->seek((header.dshb_mte.dti_first_page + modulePage) * header.dshb_page_size + moduleIndex * sizeof(ModulesTableEntry));
|
|
if (symbols->read(&moduleEntry, sizeof(moduleEntry)) == sizeof(moduleEntry)) {
|
|
const UInt8* moduleName = symbols->getName(moduleEntry.mte_nte_index);
|
|
// printf("module name = %#s\n", moduleName);
|
|
if (isMeatyModule(moduleEntry) && (codeOffset >= moduleEntry.mte_res_offset) && (codeOffset - moduleEntry.mte_res_offset) < moduleEntry.mte_size) {
|
|
FileReferenceTableEntry frte;
|
|
if (getFileReferenceTableEntry(symbols, moduleEntry.mte_imp_fref, &frte)) {
|
|
// get the name of the file.
|
|
const UInt8* name = symbols->getName(frte.frte_fn.nte_index);
|
|
UInt32 length = name[0];
|
|
BlockMoveData(name + 1, fileName, length);
|
|
fileName[length] = '\0';
|
|
// printf("file name = %s\n", fileName);
|
|
// try to refine the location, using the contained statements table entries.
|
|
UInt32 closestFileOffset = moduleEntry.mte_imp_fref.fref_offset;
|
|
UInt32 closestCodeOffset = moduleEntry.mte_res_offset;
|
|
UInt32 closestCodeDelta = 0xFFFFFFFF;
|
|
UInt32 currentFileOffset, currentCodeOffset = moduleEntry.mte_res_offset, currentCodeDelta;
|
|
for (UInt32 j = moduleEntry.mte_csnte_idx_1; j <= moduleEntry.mte_csnte_idx_2; j++) {
|
|
// only consider offsets less than the actual code offset, so we'll be sure
|
|
// to match the nearest line before the code offset. this could probably be
|
|
// a termination condition as well.
|
|
if (currentCodeOffset > codeOffset)
|
|
break;
|
|
ContainedStatementsTableEntry statementEntry;
|
|
if (getContainedStatementTableEntry(symbols, j, &statementEntry)) {
|
|
switch (statementEntry.csnte_file.change) {
|
|
case kSourceFileChange:
|
|
currentFileOffset = statementEntry.csnte_file.fref.fref_offset;
|
|
break;
|
|
case kEndOfList:
|
|
break;
|
|
default:
|
|
currentFileOffset += statementEntry.csnte.file_delta;
|
|
currentCodeOffset = moduleEntry.mte_res_offset + statementEntry.csnte.mte_offset;
|
|
if (currentCodeOffset <= codeOffset) {
|
|
currentCodeDelta = delta(currentCodeOffset, codeOffset);
|
|
if (currentCodeDelta < closestCodeDelta) {
|
|
closestFileOffset = currentFileOffset;
|
|
closestCodeOffset = currentCodeOffset;
|
|
closestCodeDelta = currentCodeDelta;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
*fileOffset = closestFileOffset;
|
|
// printf("closest file offset = %d\n", closestFileOffset);
|
|
// printf("closest code offset = %d\n", closestCodeOffset);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
sym_file* open_sym_file(const FSSpec* symSpec)
|
|
{
|
|
sym_file* symbols = new sym_file(symSpec);
|
|
if (symbols != NULL) {
|
|
if (!symbols->init()) {
|
|
delete symbols;
|
|
return NULL;
|
|
}
|
|
// don't leave the file open, if possible.
|
|
symbols->close();
|
|
}
|
|
return symbols;
|
|
}
|
|
|
|
void close_sym_file(sym_file* symbols)
|
|
{
|
|
if (symbols != NULL) {
|
|
delete symbols;
|
|
}
|
|
}
|