6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-11-02 07:11:49 +00:00
Code Issues Projects Releases Wiki Activity

Fix some formatting, grammar and style issues and add a couple of missing comments.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@155793 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eli Bendersky 2012-04-29 12:40:47 +00:00
parent 30183bf042
commit 5fe019835c
6 changed files with 37 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/llvm/ExecutionEngine/RuntimeDyld.h
View File

@ -65,12 +65,15 @@ public:
RuntimeDyld(RTDyldMemoryManager*);
~RuntimeDyld();
/// Load an in-memory object file into the dynamic linker.
bool loadObject(MemoryBuffer *InputBuffer);
// Get the address of our local copy of the symbol. This may or may not
// be the address used for relocation (clients can copy the data around
// and resolve relocatons based on where they put it).
/// Get the address of our local copy of the symbol. This may or may not
/// be the address used for relocation (clients can copy the data around
/// and resolve relocatons based on where they put it).
void *getSymbolAddress(StringRef Name);
// Resolve the relocations for all symbols we currently know about.
/// Resolve the relocations for all symbols we currently know about.
void resolveRelocations();
/// mapSectionAddress - map a section to its target address space value.

2
lib/ExecutionEngine/RuntimeDyld/ObjectImage.h
View File

@ -48,7 +48,7 @@ public:
virtual void updateSymbolAddress(const object::SymbolRef &Sym, uint64_t Addr)
{}
// Subclasses can override this method to provide JIT debugging support
// Subclasses can override these methods to provide JIT debugging support
virtual void registerWithDebugger() {}
virtual void deregisterWithDebugger() {}
};

15
lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
View File

@ -59,7 +59,7 @@ void RuntimeDyldImpl::mapSectionAddress(void *LocalAddress,
llvm_unreachable("Attempting to remap address of unknown section!");
}
// Subclasses can implement this method to create specialized image instances
// Subclasses can implement this method to create specialized image instances.
// The caller owns the the pointer that is returned.
ObjectImage *RuntimeDyldImpl::createObjectImage(const MemoryBuffer *InputBuffer) {
ObjectFile *ObjFile = ObjectFile::createObjectFile(const_cast<MemoryBuffer*>
@ -106,26 +106,27 @@ bool RuntimeDyldImpl::loadObject(const MemoryBuffer *InputBuffer) {
if (SymType == object::SymbolRef::ST_Function ||
SymType == object::SymbolRef::ST_Data) {
uint64_t FileOffset;
StringRef sData;
StringRef SectionData;
section_iterator si = obj->end_sections();
Check(i->getFileOffset(FileOffset));
Check(i->getSection(si));
if (si == obj->end_sections()) continue;
Check(si->getContents(sData));
Check(si->getContents(SectionData));
const uint8_t* SymPtr = (const uint8_t*)InputBuffer->getBufferStart() +
(uintptr_t)FileOffset;
uintptr_t SectOffset = (uintptr_t)(SymPtr - (const uint8_t*)sData.begin());
uintptr_t SectOffset = (uintptr_t)(SymPtr -
(const uint8_t*)SectionData.begin());
unsigned SectionID =
findOrEmitSection(*obj,
*si,
SymType == object::SymbolRef::ST_Function,
LocalSections);
bool isGlobal = flags & SymbolRef::SF_Global;
LocalSymbols[Name.data()] = SymbolLoc(SectionID, SectOffset);
DEBUG(dbgs() << "\tFileOffset: " << format("%p", (uintptr_t)FileOffset)
<< " flags: " << flags
<< " SID: " << SectionID
<< " Offset: " << format("%p", SectOffset));
bool isGlobal = flags & SymbolRef::SF_Global;
if (isGlobal)
SymbolTable[Name] = SymbolLoc(SectionID, SectOffset);
}
@ -137,7 +138,7 @@ bool RuntimeDyldImpl::loadObject(const MemoryBuffer *InputBuffer) {
if (CommonSize != 0)
emitCommonSymbols(*obj, CommonSymbols, CommonSize, LocalSymbols);
// Parse and proccess relocations
// Parse and process relocations
DEBUG(dbgs() << "Parse relocations:\n");
for (section_iterator si = obj->begin_sections(),
se = obj->end_sections(); si != se; si.increment(err)) {
@ -150,7 +151,7 @@ bool RuntimeDyldImpl::loadObject(const MemoryBuffer *InputBuffer) {
e = si->end_relocations(); i != e; i.increment(err)) {
Check(err);
// If it's first relocation in this section, find its SectionID
// If it's the first relocation in this section, find its SectionID
if (isFirstRelocation) {
SectionID = findOrEmitSection(*obj, *si, true, LocalSections);
DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n");

19
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
View File

@ -44,10 +44,10 @@ public:
// considered to live at for relocations. The same
// as the pointer to the above memory block for
// hosted JITs.
uintptr_t StubOffset; // It's used for architecturies with stub
uintptr_t StubOffset; // It's used for architectures with stub
// functions for far relocations like ARM.
uintptr_t ObjAddress; // Section address in object file. It's use for
// calculate MachO relocation addend
uintptr_t ObjAddress; // Section address in object file. It's used for
// calculating the MachO relocation addend.
SectionEntry(uint8_t *address, size_t size, uintptr_t stubOffset,
uintptr_t objAddress)
: Address(address), Size(size), LoadAddress((uintptr_t)address),
@ -58,8 +58,8 @@ class RelocationEntry {
public:
unsigned SectionID; // Section the relocation is contained in.
uintptr_t Offset; // Offset into the section for the relocation.
uint32_t Data; // Relocatino data. Including type of relocation
// and another flags and parameners from
uint32_t Data; // Relocation data. Including type of relocation
// and other flags.
intptr_t Addend; // Addend encoded in the instruction itself, if any,
// plus the offset into the source section for
// the symbol once the relocation is resolvable.
@ -162,7 +162,7 @@ protected:
/// \brief Emits section data from the object file to the MemoryManager.
/// \param IsCode if it's true then allocateCodeSection() will be
/// used for emmits, else allocateDataSection() will be used.
/// used for emits, else allocateDataSection() will be used.
/// \return SectionID.
unsigned emitSection(ObjectImage &Obj,
const SectionRef &Section,
@ -203,12 +203,13 @@ protected:
uint32_t Type,
int64_t Addend) = 0;
/// \brief Parses the object file relocation and store it to Relocations
/// or SymbolRelocations. Its depend from object file type.
/// \brief Parses the object file relocation and stores it to Relocations
/// or SymbolRelocations (this depends on the object file type).
virtual void processRelocationRef(const ObjRelocationInfo &Rel,
ObjectImage &Obj,
ObjSectionToIDMap &ObjSectionToID,
LocalSymbolMap &Symbols, StubMap &Stubs) = 0;
LocalSymbolMap &Symbols,
StubMap &Stubs) = 0;
void resolveSymbols();
virtual ObjectImage *createObjectImage(const MemoryBuffer *InputBuffer);