6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-22 10:29:35 +00:00
Code Issues Projects Releases Wiki Activity

Use the current local variable naming style.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199417 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rui Ueyama 2014-01-16 20:11:48 +00:00
parent 40c7e400fe
commit 671a9e2ce0
1 changed files with 242 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

486
lib/Object/COFFObjectFile.cpp
View File

@ -32,9 +32,9 @@ using support::little16_t;
namespace { namespace {
// Returns false if size is greater than the buffer size. And sets ec. // Returns false if size is greater than the buffer size. And sets ec.
bool checkSize(const MemoryBuffer *m, error_code &ec, uint64_t size) { bool checkSize(const MemoryBuffer *M, error_code &EC, uint64_t Size) {
if (m->getBufferSize() < size) { if (M->getBufferSize() < Size) {
ec = object_error::unexpected_eof; EC = object_error::unexpected_eof;
return false; return false;
} }
return true; return true;
@ -56,104 +56,104 @@ error_code getObject(const T *&Obj, const MemoryBuffer *M, const uint8_t *Ptr,
} }
} }
const coff_symbol *COFFObjectFile::toSymb(DataRefImpl Symb) const { const coff_symbol *COFFObjectFile::toSymb(DataRefImpl Ref) const {
const coff_symbol *addr = reinterpret_cast<const coff_symbol*>(Symb.p); const coff_symbol *Addr = reinterpret_cast<const coff_symbol*>(Ref.p);
# ifndef NDEBUG # ifndef NDEBUG
// Verify that the symbol points to a valid entry in the symbol table. // Verify that the symbol points to a valid entry in the symbol table.
uintptr_t offset = uintptr_t(addr) - uintptr_t(base()); uintptr_t Offset = uintptr_t(Addr) - uintptr_t(base());
if (offset < COFFHeader->PointerToSymbolTable if (Offset < COFFHeader->PointerToSymbolTable
|| offset >= COFFHeader->PointerToSymbolTable || Offset >= COFFHeader->PointerToSymbolTable
+ (COFFHeader->NumberOfSymbols * sizeof(coff_symbol))) + (COFFHeader->NumberOfSymbols * sizeof(coff_symbol)))
report_fatal_error("Symbol was outside of symbol table."); report_fatal_error("Symbol was outside of symbol table.");
assert((offset - COFFHeader->PointerToSymbolTable) % sizeof(coff_symbol) assert((Offset - COFFHeader->PointerToSymbolTable) % sizeof(coff_symbol)
== 0 && "Symbol did not point to the beginning of a symbol"); == 0 && "Symbol did not point to the beginning of a symbol");
# endif # endif
return addr; return Addr;
} }
const coff_section *COFFObjectFile::toSec(DataRefImpl Sec) const { const coff_section *COFFObjectFile::toSec(DataRefImpl Ref) const {
const coff_section *addr = reinterpret_cast<const coff_section*>(Sec.p); const coff_section *Addr = reinterpret_cast<const coff_section*>(Ref.p);
# ifndef NDEBUG # ifndef NDEBUG
// Verify that the section points to a valid entry in the section table. // Verify that the section points to a valid entry in the section table.
if (addr < SectionTable if (Addr < SectionTable
|| addr >= (SectionTable + COFFHeader->NumberOfSections)) || Addr >= (SectionTable + COFFHeader->NumberOfSections))
report_fatal_error("Section was outside of section table."); report_fatal_error("Section was outside of section table.");
uintptr_t offset = uintptr_t(addr) - uintptr_t(SectionTable); uintptr_t Offset = uintptr_t(Addr) - uintptr_t(SectionTable);
assert(offset % sizeof(coff_section) == 0 && assert(Offset % sizeof(coff_section) == 0 &&
"Section did not point to the beginning of a section"); "Section did not point to the beginning of a section");
# endif # endif
return addr; return Addr;
} }
error_code COFFObjectFile::getSymbolNext(DataRefImpl Symb, error_code COFFObjectFile::getSymbolNext(DataRefImpl Ref,
SymbolRef &Result) const { SymbolRef &Result) const {
const coff_symbol *symb = toSymb(Symb); const coff_symbol *Symb = toSymb(Ref);
symb += 1 + symb->NumberOfAuxSymbols; Symb += 1 + Symb->NumberOfAuxSymbols;
Symb.p = reinterpret_cast<uintptr_t>(symb); Ref.p = reinterpret_cast<uintptr_t>(Symb);
Result = SymbolRef(Symb, this); Result = SymbolRef(Ref, this);
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSymbolName(DataRefImpl Symb, error_code COFFObjectFile::getSymbolName(DataRefImpl Ref,
StringRef &Result) const { StringRef &Result) const {
const coff_symbol *symb = toSymb(Symb); const coff_symbol *Symb = toSymb(Ref);
return getSymbolName(symb, Result); return getSymbolName(Symb, Result);
} }
error_code COFFObjectFile::getSymbolFileOffset(DataRefImpl Symb, error_code COFFObjectFile::getSymbolFileOffset(DataRefImpl Ref,
uint64_t &Result) const { uint64_t &Result) const {
const coff_symbol *symb = toSymb(Symb); const coff_symbol *Symb = toSymb(Ref);
const coff_section *Section = NULL; const coff_section *Section = NULL;
if (error_code ec = getSection(symb->SectionNumber, Section)) if (error_code EC = getSection(Symb->SectionNumber, Section))
return ec; return EC;
if (symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED) if (Symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED)
Result = UnknownAddressOrSize; Result = UnknownAddressOrSize;
else if (Section) else if (Section)
Result = Section->PointerToRawData + symb->Value; Result = Section->PointerToRawData + Symb->Value;
else else
Result = symb->Value; Result = Symb->Value;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSymbolAddress(DataRefImpl Symb, error_code COFFObjectFile::getSymbolAddress(DataRefImpl Ref,
uint64_t &Result) const { uint64_t &Result) const {
const coff_symbol *symb = toSymb(Symb); const coff_symbol *Symb = toSymb(Ref);
const coff_section *Section = NULL; const coff_section *Section = NULL;
if (error_code ec = getSection(symb->SectionNumber, Section)) if (error_code EC = getSection(Symb->SectionNumber, Section))
return ec; return EC;
if (symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED) if (Symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED)
Result = UnknownAddressOrSize; Result = UnknownAddressOrSize;
else if (Section) else if (Section)
Result = Section->VirtualAddress + symb->Value; Result = Section->VirtualAddress + Symb->Value;
else else
Result = symb->Value; Result = Symb->Value;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSymbolType(DataRefImpl Symb, error_code COFFObjectFile::getSymbolType(DataRefImpl Ref,
SymbolRef::Type &Result) const { SymbolRef::Type &Result) const {
const coff_symbol *symb = toSymb(Symb); const coff_symbol *Symb = toSymb(Ref);
Result = SymbolRef::ST_Other; Result = SymbolRef::ST_Other;
if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL && if (Symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL &&
symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED) { Symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED) {
Result = SymbolRef::ST_Unknown; Result = SymbolRef::ST_Unknown;
} else { } else {
if (symb->getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION) { if (Symb->getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION) {
Result = SymbolRef::ST_Function; Result = SymbolRef::ST_Function;
} else { } else {
uint32_t Characteristics = 0; uint32_t Characteristics = 0;
if (symb->SectionNumber > 0) { if (Symb->SectionNumber > 0) {
const coff_section *Section = NULL; const coff_section *Section = NULL;
if (error_code ec = getSection(symb->SectionNumber, Section)) if (error_code EC = getSection(Symb->SectionNumber, Section))
return ec; return EC;
Characteristics = Section->Characteristics; Characteristics = Section->Characteristics;
} }
if (Characteristics & COFF::IMAGE_SCN_MEM_READ && if (Characteristics & COFF::IMAGE_SCN_MEM_READ &&
@ -164,210 +164,210 @@ error_code COFFObjectFile::getSymbolType(DataRefImpl Symb,
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSymbolFlags(DataRefImpl Symb, error_code COFFObjectFile::getSymbolFlags(DataRefImpl Ref,
uint32_t &Result) const { uint32_t &Result) const {
const coff_symbol *symb = toSymb(Symb); const coff_symbol *Symb = toSymb(Ref);
Result = SymbolRef::SF_None; Result = SymbolRef::SF_None;
// TODO: Correctly set SF_FormatSpecific, SF_ThreadLocal, SF_Common // TODO: Correctly set SF_FormatSpecific, SF_ThreadLocal, SF_Common
if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL && if (Symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL &&
symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED) Symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED)
Result |= SymbolRef::SF_Undefined; Result |= SymbolRef::SF_Undefined;
// TODO: This are certainly too restrictive. // TODO: This are certainly too restrictive.
if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL) if (Symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL)
Result |= SymbolRef::SF_Global; Result |= SymbolRef::SF_Global;
if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL) if (Symb->StorageClass == COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL)
Result |= SymbolRef::SF_Weak; Result |= SymbolRef::SF_Weak;
if (symb->SectionNumber == COFF::IMAGE_SYM_ABSOLUTE) if (Symb->SectionNumber == COFF::IMAGE_SYM_ABSOLUTE)
Result |= SymbolRef::SF_Absolute; Result |= SymbolRef::SF_Absolute;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSymbolSize(DataRefImpl Symb, error_code COFFObjectFile::getSymbolSize(DataRefImpl Ref,
uint64_t &Result) const { uint64_t &Result) const {
// FIXME: Return the correct size. This requires looking at all the symbols // FIXME: Return the correct size. This requires looking at all the symbols
// in the same section as this symbol, and looking for either the next // in the same section as this symbol, and looking for either the next
// symbol, or the end of the section. // symbol, or the end of the section.
const coff_symbol *symb = toSymb(Symb); const coff_symbol *Symb = toSymb(Ref);
const coff_section *Section = NULL; const coff_section *Section = NULL;
if (error_code ec = getSection(symb->SectionNumber, Section)) if (error_code EC = getSection(Symb->SectionNumber, Section))
return ec; return EC;
if (symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED) if (Symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED)
Result = UnknownAddressOrSize; Result = UnknownAddressOrSize;
else if (Section) else if (Section)
Result = Section->SizeOfRawData - symb->Value; Result = Section->SizeOfRawData - Symb->Value;
else else
Result = 0; Result = 0;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSymbolSection(DataRefImpl Symb, error_code COFFObjectFile::getSymbolSection(DataRefImpl Ref,
section_iterator &Result) const { section_iterator &Result) const {
const coff_symbol *symb = toSymb(Symb); const coff_symbol *Symb = toSymb(Ref);
if (symb->SectionNumber <= COFF::IMAGE_SYM_UNDEFINED) if (Symb->SectionNumber <= COFF::IMAGE_SYM_UNDEFINED)
Result = end_sections(); Result = end_sections();
else { else {
const coff_section *sec = 0; const coff_section *Sec = 0;
if (error_code ec = getSection(symb->SectionNumber, sec)) return ec; if (error_code EC = getSection(Symb->SectionNumber, Sec)) return EC;
DataRefImpl Sec; DataRefImpl Ref;
Sec.p = reinterpret_cast<uintptr_t>(sec); Ref.p = reinterpret_cast<uintptr_t>(Sec);
Result = section_iterator(SectionRef(Sec, this)); Result = section_iterator(SectionRef(Ref, this));
} }
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSymbolValue(DataRefImpl Symb, error_code COFFObjectFile::getSymbolValue(DataRefImpl Ref,
uint64_t &Val) const { uint64_t &Val) const {
report_fatal_error("getSymbolValue unimplemented in COFFObjectFile"); report_fatal_error("getSymbolValue unimplemented in COFFObjectFile");
} }
error_code COFFObjectFile::getSectionNext(DataRefImpl Sec, error_code COFFObjectFile::getSectionNext(DataRefImpl Ref,
SectionRef &Result) const { SectionRef &Result) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(Ref);
sec += 1; Sec += 1;
Sec.p = reinterpret_cast<uintptr_t>(sec); Ref.p = reinterpret_cast<uintptr_t>(Sec);
Result = SectionRef(Sec, this); Result = SectionRef(Ref, this);
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSectionName(DataRefImpl Sec, error_code COFFObjectFile::getSectionName(DataRefImpl Ref,
StringRef &Result) const { StringRef &Result) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(Ref);
return getSectionName(sec, Result); return getSectionName(Sec, Result);
} }
error_code COFFObjectFile::getSectionAddress(DataRefImpl Sec, error_code COFFObjectFile::getSectionAddress(DataRefImpl Ref,
uint64_t &Result) const { uint64_t &Result) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(Ref);
Result = sec->VirtualAddress; Result = Sec->VirtualAddress;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSectionSize(DataRefImpl Sec, error_code COFFObjectFile::getSectionSize(DataRefImpl Ref,
uint64_t &Result) const { uint64_t &Result) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(Ref);
Result = sec->SizeOfRawData; Result = Sec->SizeOfRawData;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSectionContents(DataRefImpl Sec, error_code COFFObjectFile::getSectionContents(DataRefImpl Ref,
StringRef &Result) const { StringRef &Result) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(Ref);
ArrayRef<uint8_t> Res; ArrayRef<uint8_t> Res;
error_code EC = getSectionContents(sec, Res); error_code EC = getSectionContents(Sec, Res);
Result = StringRef(reinterpret_cast<const char*>(Res.data()), Res.size()); Result = StringRef(reinterpret_cast<const char*>(Res.data()), Res.size());
return EC; return EC;
} }
error_code COFFObjectFile::getSectionAlignment(DataRefImpl Sec, error_code COFFObjectFile::getSectionAlignment(DataRefImpl Ref,
uint64_t &Res) const { uint64_t &Res) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(Ref);
if (!sec) if (!Sec)
return object_error::parse_failed; return object_error::parse_failed;
Res = uint64_t(1) << (((sec->Characteristics & 0x00F00000) >> 20) - 1); Res = uint64_t(1) << (((Sec->Characteristics & 0x00F00000) >> 20) - 1);
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::isSectionText(DataRefImpl Sec, error_code COFFObjectFile::isSectionText(DataRefImpl Ref,
bool &Result) const { bool &Result) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(Ref);
Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_CODE; Result = Sec->Characteristics & COFF::IMAGE_SCN_CNT_CODE;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::isSectionData(DataRefImpl Sec, error_code COFFObjectFile::isSectionData(DataRefImpl Ref,
bool &Result) const { bool &Result) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(Ref);
Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA; Result = Sec->Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::isSectionBSS(DataRefImpl Sec, error_code COFFObjectFile::isSectionBSS(DataRefImpl Ref,
bool &Result) const { bool &Result) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(Ref);
Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA; Result = Sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::isSectionRequiredForExecution(DataRefImpl Sec, error_code COFFObjectFile::isSectionRequiredForExecution(DataRefImpl Ref,
bool &Result) const { bool &Result) const {
// FIXME: Unimplemented // FIXME: Unimplemented
Result = true; Result = true;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::isSectionVirtual(DataRefImpl Sec, error_code COFFObjectFile::isSectionVirtual(DataRefImpl Ref,
bool &Result) const { bool &Result) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(Ref);
Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA; Result = Sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::isSectionZeroInit(DataRefImpl Sec, error_code COFFObjectFile::isSectionZeroInit(DataRefImpl Ref,
bool &Result) const { bool &Result) const {
// FIXME: Unimplemented. // FIXME: Unimplemented.
Result = false; Result = false;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::isSectionReadOnlyData(DataRefImpl Sec, error_code COFFObjectFile::isSectionReadOnlyData(DataRefImpl Ref,
bool &Result) const { bool &Result) const {
// FIXME: Unimplemented. // FIXME: Unimplemented.
Result = false; Result = false;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::sectionContainsSymbol(DataRefImpl Sec, error_code COFFObjectFile::sectionContainsSymbol(DataRefImpl SecRef,
DataRefImpl Symb, DataRefImpl SymbRef,
bool &Result) const { bool &Result) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(SecRef);
const coff_symbol *symb = toSymb(Symb); const coff_symbol *Symb = toSymb(SymbRef);
const coff_section *symb_sec = 0; const coff_section *SymbSec = 0;
if (error_code ec = getSection(symb->SectionNumber, symb_sec)) return ec; if (error_code EC = getSection(Symb->SectionNumber, SymbSec)) return EC;
if (symb_sec == sec) if (SymbSec == Sec)
Result = true; Result = true;
else else
Result = false; Result = false;
return object_error::success; return object_error::success;
} }
relocation_iterator COFFObjectFile::section_rel_begin(DataRefImpl Sec) const { relocation_iterator COFFObjectFile::section_rel_begin(DataRefImpl Ref) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(Ref);
DataRefImpl ret; DataRefImpl Ret;
if (sec->NumberOfRelocations == 0) if (Sec->NumberOfRelocations == 0)
ret.p = 0; Ret.p = 0;
else else
ret.p = reinterpret_cast<uintptr_t>(base() + sec->PointerToRelocations); Ret.p = reinterpret_cast<uintptr_t>(base() + Sec->PointerToRelocations);
return relocation_iterator(RelocationRef(ret, this)); return relocation_iterator(RelocationRef(Ret, this));
} }
relocation_iterator COFFObjectFile::section_rel_end(DataRefImpl Sec) const { relocation_iterator COFFObjectFile::section_rel_end(DataRefImpl Ref) const {
const coff_section *sec = toSec(Sec); const coff_section *Sec = toSec(Ref);
DataRefImpl ret; DataRefImpl Ret;
if (sec->NumberOfRelocations == 0) if (Sec->NumberOfRelocations == 0)
ret.p = 0; Ret.p = 0;
else else
ret.p = reinterpret_cast<uintptr_t>( Ret.p = reinterpret_cast<uintptr_t>(
reinterpret_cast<const coff_relocation*>( reinterpret_cast<const coff_relocation*>(
base() + sec->PointerToRelocations) base() + Sec->PointerToRelocations)
+ sec->NumberOfRelocations); + Sec->NumberOfRelocations);
return relocation_iterator(RelocationRef(ret, this)); return relocation_iterator(RelocationRef(Ret, this));
} }
// Initialize the pointer to the symbol table. // Initialize the pointer to the symbol table.
error_code COFFObjectFile::initSymbolTablePtr() { error_code COFFObjectFile::initSymbolTablePtr() {
if (error_code ec = getObject( if (error_code EC = getObject(
SymbolTable, Data, base() + COFFHeader->PointerToSymbolTable, SymbolTable, Data, base() + COFFHeader->PointerToSymbolTable,
COFFHeader->NumberOfSymbols * sizeof(coff_symbol))) COFFHeader->NumberOfSymbols * sizeof(coff_symbol)))
return ec; return EC;
// Find string table. The first four byte of the string table contains the // Find string table. The first four byte of the string table contains the
// total size of the string table, including the size field itself. If the // total size of the string table, including the size field itself. If the
@ -376,12 +376,12 @@ error_code COFFObjectFile::initSymbolTablePtr() {
base() + COFFHeader->PointerToSymbolTable + base() + COFFHeader->PointerToSymbolTable +
COFFHeader->NumberOfSymbols * sizeof(coff_symbol); COFFHeader->NumberOfSymbols * sizeof(coff_symbol);
const ulittle32_t *StringTableSizePtr; const ulittle32_t *StringTableSizePtr;
if (error_code ec = getObject(StringTableSizePtr, Data, StringTableAddr)) if (error_code EC = getObject(StringTableSizePtr, Data, StringTableAddr))
return ec; return EC;
StringTableSize = *StringTableSizePtr; StringTableSize = *StringTableSizePtr;
if (error_code ec = if (error_code EC =
getObject(StringTable, Data, StringTableAddr, StringTableSize)) getObject(StringTable, Data, StringTableAddr, StringTableSize))
return ec; return EC;
// Check that the string table is null terminated if has any in it. // Check that the string table is null terminated if has any in it.
if (StringTableSize < 4 || if (StringTableSize < 4 ||
@ -392,12 +392,12 @@ error_code COFFObjectFile::initSymbolTablePtr() {
// Returns the file offset for the given RVA. // Returns the file offset for the given RVA.
error_code COFFObjectFile::getRvaPtr(uint32_t Rva, uintptr_t &Res) const { error_code COFFObjectFile::getRvaPtr(uint32_t Rva, uintptr_t &Res) const {
error_code ec; error_code EC;
for (section_iterator i = begin_sections(), e = end_sections(); i != e; for (section_iterator I = begin_sections(), E = end_sections(); I != E;
i.increment(ec)) { I.increment(EC)) {
if (ec) if (EC)
return ec; return EC;
const coff_section *Section = getCOFFSection(i); const coff_section *Section = getCOFFSection(I);
uint32_t SectionStart = Section->VirtualAddress; uint32_t SectionStart = Section->VirtualAddress;
uint32_t SectionEnd = Section->VirtualAddress + Section->VirtualSize; uint32_t SectionEnd = Section->VirtualAddress + Section->VirtualSize;
if (SectionStart <= Rva && Rva < SectionEnd) { if (SectionStart <= Rva && Rva < SectionEnd) {
@ -414,8 +414,8 @@ error_code COFFObjectFile::getRvaPtr(uint32_t Rva, uintptr_t &Res) const {
error_code COFFObjectFile:: error_code COFFObjectFile::
getHintName(uint32_t Rva, uint16_t &Hint, StringRef &Name) const { getHintName(uint32_t Rva, uint16_t &Hint, StringRef &Name) const {
uintptr_t IntPtr = 0; uintptr_t IntPtr = 0;
if (error_code ec = getRvaPtr(Rva, IntPtr)) if (error_code EC = getRvaPtr(Rva, IntPtr))
return ec; return EC;
const uint8_t *Ptr = reinterpret_cast<const uint8_t *>(IntPtr); const uint8_t *Ptr = reinterpret_cast<const uint8_t *>(IntPtr);
Hint = *reinterpret_cast<const ulittle16_t *>(Ptr); Hint = *reinterpret_cast<const ulittle16_t *>(Ptr);
Name = StringRef(reinterpret_cast<const char *>(Ptr + 2)); Name = StringRef(reinterpret_cast<const char *>(Ptr + 2));
@ -441,8 +441,8 @@ error_code COFFObjectFile::initImportTablePtr() {
// Find the section that contains the RVA. This is needed because the RVA is // Find the section that contains the RVA. This is needed because the RVA is
// the import table's memory address which is different from its file offset. // the import table's memory address which is different from its file offset.
uintptr_t IntPtr = 0; uintptr_t IntPtr = 0;
if (error_code ec = getRvaPtr(ImportTableRva, IntPtr)) if (error_code EC = getRvaPtr(ImportTableRva, IntPtr))
return ec; return EC;
ImportDirectory = reinterpret_cast< ImportDirectory = reinterpret_cast<
const import_directory_table_entry *>(IntPtr); const import_directory_table_entry *>(IntPtr);
return object_error::success; return object_error::success;
@ -468,49 +468,42 @@ error_code COFFObjectFile::initExportTablePtr() {
return object_error::success; return object_error::success;
} }
COFFObjectFile::COFFObjectFile(MemoryBuffer *Object, error_code &ec) COFFObjectFile::COFFObjectFile(MemoryBuffer *Object, error_code &EC)
: ObjectFile(Binary::ID_COFF, Object) : ObjectFile(Binary::ID_COFF, Object), COFFHeader(0), PE32Header(0),
, COFFHeader(0) DataDirectory(0), SectionTable(0), SymbolTable(0), StringTable(0),
, PE32Header(0) StringTableSize(0), ImportDirectory(0), NumberOfImportDirectory(0),
, DataDirectory(0) ExportDirectory(0) {
, SectionTable(0)
, SymbolTable(0)
, StringTable(0)
, StringTableSize(0)
, ImportDirectory(0)
, NumberOfImportDirectory(0)
, ExportDirectory(0) {
// Check that we at least have enough room for a header. // Check that we at least have enough room for a header.
if (!checkSize(Data, ec, sizeof(coff_file_header))) return; if (!checkSize(Data, EC, sizeof(coff_file_header))) return;
// The current location in the file where we are looking at. // The current location in the file where we are looking at.
uint64_t CurPtr = 0; uint64_t CurPtr = 0;
// PE header is optional and is present only in executables. If it exists, // PE header is optional and is present only in executables. If it exists,
// it is placed right after COFF header. // it is placed right after COFF header.
bool hasPEHeader = false; bool HasPEHeader = false;
// Check if this is a PE/COFF file. // Check if this is a PE/COFF file.
if (base()[0] == 0x4d && base()[1] == 0x5a) { if (base()[0] == 0x4d && base()[1] == 0x5a) {
// PE/COFF, seek through MS-DOS compatibility stub and 4-byte // PE/COFF, seek through MS-DOS compatibility stub and 4-byte
// PE signature to find 'normal' COFF header. // PE signature to find 'normal' COFF header.
if (!checkSize(Data, ec, 0x3c + 8)) return; if (!checkSize(Data, EC, 0x3c + 8)) return;
CurPtr = *reinterpret_cast<const ulittle16_t *>(base() + 0x3c); CurPtr = *reinterpret_cast<const ulittle16_t *>(base() + 0x3c);
// Check the PE magic bytes. ("PE\0\0") // Check the PE magic bytes. ("PE\0\0")
if (std::memcmp(base() + CurPtr, "PE\0\0", 4) != 0) { if (std::memcmp(base() + CurPtr, "PE\0\0", 4) != 0) {
ec = object_error::parse_failed; EC = object_error::parse_failed;
return; return;
} }
CurPtr += 4; // Skip the PE magic bytes. CurPtr += 4; // Skip the PE magic bytes.
hasPEHeader = true; HasPEHeader = true;
} }
if ((ec = getObject(COFFHeader, Data, base() + CurPtr))) if ((EC = getObject(COFFHeader, Data, base() + CurPtr)))
return; return;
CurPtr += sizeof(coff_file_header); CurPtr += sizeof(coff_file_header);
if (hasPEHeader) { if (HasPEHeader) {
if ((ec = getObject(PE32Header, Data, base() + CurPtr))) if ((EC = getObject(PE32Header, Data, base() + CurPtr)))
return; return;
if (PE32Header->Magic != 0x10b) { if (PE32Header->Magic != 0x10b) {
// We only support PE32. If this is PE32 (not PE32+), the magic byte // We only support PE32. If this is PE32 (not PE32+), the magic byte
@ -518,46 +511,46 @@ COFFObjectFile::COFFObjectFile(MemoryBuffer *Object, error_code &ec)
// header in this file. // header in this file.
PE32Header = 0; PE32Header = 0;
} else if (PE32Header->NumberOfRvaAndSize > 0) { } else if (PE32Header->NumberOfRvaAndSize > 0) {
const uint8_t *addr = base() + CurPtr + sizeof(pe32_header); const uint8_t *Addr = base() + CurPtr + sizeof(pe32_header);
uint64_t size = sizeof(data_directory) * PE32Header->NumberOfRvaAndSize; uint64_t size = sizeof(data_directory) * PE32Header->NumberOfRvaAndSize;
if ((ec = getObject(DataDirectory, Data, addr, size))) if ((EC = getObject(DataDirectory, Data, Addr, size)))
return; return;
} }
CurPtr += COFFHeader->SizeOfOptionalHeader; CurPtr += COFFHeader->SizeOfOptionalHeader;
} }
if (!COFFHeader->isImportLibrary()) if (!COFFHeader->isImportLibrary())
if ((ec = getObject(SectionTable, Data, base() + CurPtr, if ((EC = getObject(SectionTable, Data, base() + CurPtr,
COFFHeader->NumberOfSections * sizeof(coff_section)))) COFFHeader->NumberOfSections * sizeof(coff_section))))
return; return;
// Initialize the pointer to the symbol table. // Initialize the pointer to the symbol table.
if (COFFHeader->PointerToSymbolTable != 0) if (COFFHeader->PointerToSymbolTable != 0)
if ((ec = initSymbolTablePtr())) if ((EC = initSymbolTablePtr()))
return; return;
// Initialize the pointer to the beginning of the import table. // Initialize the pointer to the beginning of the import table.
if ((ec = initImportTablePtr())) if ((EC = initImportTablePtr()))
return; return;
// Initialize the pointer to the export table. // Initialize the pointer to the export table.
if ((ec = initExportTablePtr())) if ((EC = initExportTablePtr()))
return; return;
ec = object_error::success; EC = object_error::success;
} }
symbol_iterator COFFObjectFile::begin_symbols() const { symbol_iterator COFFObjectFile::begin_symbols() const {
DataRefImpl ret; DataRefImpl Ret;
ret.p = reinterpret_cast<uintptr_t>(SymbolTable); Ret.p = reinterpret_cast<uintptr_t>(SymbolTable);
return symbol_iterator(SymbolRef(ret, this)); return symbol_iterator(SymbolRef(Ret, this));
} }
symbol_iterator COFFObjectFile::end_symbols() const { symbol_iterator COFFObjectFile::end_symbols() const {
// The symbol table ends where the string table begins. // The symbol table ends where the string table begins.
DataRefImpl ret; DataRefImpl Ret;
ret.p = reinterpret_cast<uintptr_t>(StringTable); Ret.p = reinterpret_cast<uintptr_t>(StringTable);
return symbol_iterator(SymbolRef(ret, this)); return symbol_iterator(SymbolRef(Ret, this));
} }
symbol_iterator COFFObjectFile::begin_dynamic_symbols() const { symbol_iterator COFFObjectFile::begin_dynamic_symbols() const {
@ -603,23 +596,23 @@ export_directory_iterator COFFObjectFile::export_directory_begin() const {
export_directory_iterator COFFObjectFile::export_directory_end() const { export_directory_iterator COFFObjectFile::export_directory_end() const {
if (ExportDirectory == 0) if (ExportDirectory == 0)
return export_directory_iterator(ExportDirectoryEntryRef(0, 0, this)); return export_directory_iterator(ExportDirectoryEntryRef(0, 0, this));
ExportDirectoryEntryRef ref(ExportDirectory, ExportDirectoryEntryRef Ref(ExportDirectory,
ExportDirectory->AddressTableEntries, this); ExportDirectory->AddressTableEntries, this);
return export_directory_iterator(ref); return export_directory_iterator(Ref);
} }
section_iterator COFFObjectFile::begin_sections() const { section_iterator COFFObjectFile::begin_sections() const {
DataRefImpl ret; DataRefImpl Ret;
ret.p = reinterpret_cast<uintptr_t>(SectionTable); Ret.p = reinterpret_cast<uintptr_t>(SectionTable);
return section_iterator(SectionRef(ret, this)); return section_iterator(SectionRef(Ret, this));
} }
section_iterator COFFObjectFile::end_sections() const { section_iterator COFFObjectFile::end_sections() const {
DataRefImpl ret; DataRefImpl Ret;
int numSections = COFFHeader->isImportLibrary() int NumSections = COFFHeader->isImportLibrary()
? 0 : COFFHeader->NumberOfSections; ? 0 : COFFHeader->NumberOfSections;
ret.p = reinterpret_cast<uintptr_t>(SectionTable + numSections); Ret.p = reinterpret_cast<uintptr_t>(SectionTable + NumSections);
return section_iterator(SectionRef(ret, this)); return section_iterator(SectionRef(Ret, this));
} }
uint8_t COFFObjectFile::getBytesInAddress() const { uint8_t COFFObjectFile::getBytesInAddress() const {
@ -664,89 +657,89 @@ error_code COFFObjectFile::getPE32Header(const pe32_header *&Res) const {
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getDataDirectory(uint32_t index, error_code COFFObjectFile::getDataDirectory(uint32_t Index,
const data_directory *&Res) const { const data_directory *&Res) const {
// Error if if there's no data directory or the index is out of range. // Error if if there's no data directory or the index is out of range.
if (!DataDirectory || index > PE32Header->NumberOfRvaAndSize) if (!DataDirectory || Index > PE32Header->NumberOfRvaAndSize)
return object_error::parse_failed; return object_error::parse_failed;
Res = &DataDirectory[index]; Res = &DataDirectory[Index];
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSection(int32_t index, error_code COFFObjectFile::getSection(int32_t Index,
const coff_section *&Result) const { const coff_section *&Result) const {
// Check for special index values. // Check for special index values.
if (index == COFF::IMAGE_SYM_UNDEFINED || if (Index == COFF::IMAGE_SYM_UNDEFINED ||
index == COFF::IMAGE_SYM_ABSOLUTE || Index == COFF::IMAGE_SYM_ABSOLUTE ||
index == COFF::IMAGE_SYM_DEBUG) Index == COFF::IMAGE_SYM_DEBUG)
Result = NULL; Result = NULL;
else if (index > 0 && index <= COFFHeader->NumberOfSections) else if (Index > 0 && Index <= COFFHeader->NumberOfSections)
// We already verified the section table data, so no need to check again. // We already verified the section table data, so no need to check again.
Result = SectionTable + (index - 1); Result = SectionTable + (Index - 1);
else else
return object_error::parse_failed; return object_error::parse_failed;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getString(uint32_t offset, error_code COFFObjectFile::getString(uint32_t Offset,
StringRef &Result) const { StringRef &Result) const {
if (StringTableSize <= 4) if (StringTableSize <= 4)
// Tried to get a string from an empty string table. // Tried to get a string from an empty string table.
return object_error::parse_failed; return object_error::parse_failed;
if (offset >= StringTableSize) if (Offset >= StringTableSize)
return object_error::unexpected_eof; return object_error::unexpected_eof;
Result = StringRef(StringTable + offset); Result = StringRef(StringTable + Offset);
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSymbol(uint32_t index, error_code COFFObjectFile::getSymbol(uint32_t Index,
const coff_symbol *&Result) const { const coff_symbol *&Result) const {
if (index < COFFHeader->NumberOfSymbols) if (Index < COFFHeader->NumberOfSymbols)
Result = SymbolTable + index; Result = SymbolTable + Index;
else else
return object_error::parse_failed; return object_error::parse_failed;
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getSymbolName(const coff_symbol *symbol, error_code COFFObjectFile::getSymbolName(const coff_symbol *Symbol,
StringRef &Res) const { StringRef &Res) const {
// Check for string table entry. First 4 bytes are 0. // Check for string table entry. First 4 bytes are 0.
if (symbol->Name.Offset.Zeroes == 0) { if (Symbol->Name.Offset.Zeroes == 0) {
uint32_t Offset = symbol->Name.Offset.Offset; uint32_t Offset = Symbol->Name.Offset.Offset;
if (error_code ec = getString(Offset, Res)) if (error_code EC = getString(Offset, Res))
return ec; return EC;
return object_error::success; return object_error::success;
} }
if (symbol->Name.ShortName[7] == 0) if (Symbol->Name.ShortName[7] == 0)
// Null terminated, let ::strlen figure out the length. // Null terminated, let ::strlen figure out the length.
Res = StringRef(symbol->Name.ShortName); Res = StringRef(Symbol->Name.ShortName);
else else
// Not null terminated, use all 8 bytes. // Not null terminated, use all 8 bytes.
Res = StringRef(symbol->Name.ShortName, 8); Res = StringRef(Symbol->Name.ShortName, 8);
return object_error::success; return object_error::success;
} }
ArrayRef<uint8_t> COFFObjectFile::getSymbolAuxData( ArrayRef<uint8_t> COFFObjectFile::getSymbolAuxData(
const coff_symbol *symbol) const { const coff_symbol *Symbol) const {
const uint8_t *aux = NULL; const uint8_t *Aux = NULL;
if ( symbol->NumberOfAuxSymbols > 0 ) { if (Symbol->NumberOfAuxSymbols > 0) {
// AUX data comes immediately after the symbol in COFF // AUX data comes immediately after the symbol in COFF
aux = reinterpret_cast<const uint8_t *>(symbol + 1); Aux = reinterpret_cast<const uint8_t *>(Symbol + 1);
# ifndef NDEBUG # ifndef NDEBUG
// Verify that the aux symbol points to a valid entry in the symbol table. // Verify that the Aux symbol points to a valid entry in the symbol table.
uintptr_t offset = uintptr_t(aux) - uintptr_t(base()); uintptr_t Offset = uintptr_t(Aux) - uintptr_t(base());
if (offset < COFFHeader->PointerToSymbolTable if (Offset < COFFHeader->PointerToSymbolTable
|| offset >= COFFHeader->PointerToSymbolTable || Offset >= COFFHeader->PointerToSymbolTable
+ (COFFHeader->NumberOfSymbols * sizeof(coff_symbol))) + (COFFHeader->NumberOfSymbols * sizeof(coff_symbol)))
report_fatal_error("Aux Symbol data was outside of symbol table."); report_fatal_error("Aux Symbol data was outside of symbol table.");
assert((offset - COFFHeader->PointerToSymbolTable) % sizeof(coff_symbol) assert((Offset - COFFHeader->PointerToSymbolTable) % sizeof(coff_symbol)
== 0 && "Aux Symbol data did not point to the beginning of a symbol"); == 0 && "Aux Symbol data did not point to the beginning of a symbol");
# endif # endif
} }
return ArrayRef<uint8_t>(aux, symbol->NumberOfAuxSymbols * sizeof(coff_symbol)); return ArrayRef<uint8_t>(Aux, Symbol->NumberOfAuxSymbols * sizeof(coff_symbol));
} }
error_code COFFObjectFile::getSectionName(const coff_section *Sec, error_code COFFObjectFile::getSectionName(const coff_section *Sec,
@ -764,8 +757,8 @@ error_code COFFObjectFile::getSectionName(const coff_section *Sec,
uint32_t Offset; uint32_t Offset;
if (Name.substr(1).getAsInteger(10, Offset)) if (Name.substr(1).getAsInteger(10, Offset))
return object_error::parse_failed; return object_error::parse_failed;
if (error_code ec = getString(Offset, Name)) if (error_code EC = getString(Offset, Name))
return ec; return EC;
} }
Res = Name; Res = Name;
@ -789,6 +782,7 @@ error_code COFFObjectFile::getSectionContents(const coff_section *Sec,
const coff_relocation *COFFObjectFile::toRel(DataRefImpl Rel) const { const coff_relocation *COFFObjectFile::toRel(DataRefImpl Rel) const {
return reinterpret_cast<const coff_relocation*>(Rel.p); return reinterpret_cast<const coff_relocation*>(Rel.p);
} }
error_code COFFObjectFile::getRelocationNext(DataRefImpl Rel, error_code COFFObjectFile::getRelocationNext(DataRefImpl Rel,
RelocationRef &Res) const { RelocationRef &Res) const {
Rel.p = reinterpret_cast<uintptr_t>( Rel.p = reinterpret_cast<uintptr_t>(
@ -796,21 +790,25 @@ error_code COFFObjectFile::getRelocationNext(DataRefImpl Rel,
Res = RelocationRef(Rel, this); Res = RelocationRef(Rel, this);
return object_error::success; return object_error::success;
} }
error_code COFFObjectFile::getRelocationAddress(DataRefImpl Rel, error_code COFFObjectFile::getRelocationAddress(DataRefImpl Rel,
uint64_t &Res) const { uint64_t &Res) const {
report_fatal_error("getRelocationAddress not implemented in COFFObjectFile"); report_fatal_error("getRelocationAddress not implemented in COFFObjectFile");
} }
error_code COFFObjectFile::getRelocationOffset(DataRefImpl Rel, error_code COFFObjectFile::getRelocationOffset(DataRefImpl Rel,
uint64_t &Res) const { uint64_t &Res) const {
Res = toRel(Rel)->VirtualAddress; Res = toRel(Rel)->VirtualAddress;
return object_error::success; return object_error::success;
} }
symbol_iterator COFFObjectFile::getRelocationSymbol(DataRefImpl Rel) const { symbol_iterator COFFObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
const coff_relocation* R = toRel(Rel); const coff_relocation* R = toRel(Rel);
DataRefImpl Symb; DataRefImpl Ref;
Symb.p = reinterpret_cast<uintptr_t>(SymbolTable + R->SymbolTableIndex); Ref.p = reinterpret_cast<uintptr_t>(SymbolTable + R->SymbolTableIndex);
return symbol_iterator(SymbolRef(Symb, this)); return symbol_iterator(SymbolRef(Ref, this));
} }
error_code COFFObjectFile::getRelocationType(DataRefImpl Rel, error_code COFFObjectFile::getRelocationType(DataRefImpl Rel,
uint64_t &Res) const { uint64_t &Res) const {
const coff_relocation* R = toRel(Rel); const coff_relocation* R = toRel(Rel);
@ -832,15 +830,15 @@ const coff_relocation *COFFObjectFile::getCOFFRelocation(
} }
#define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(enum) \ #define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(enum) \
case COFF::enum: res = #enum; break; case COFF::enum: Res = #enum; break;
error_code COFFObjectFile::getRelocationTypeName(DataRefImpl Rel, error_code COFFObjectFile::getRelocationTypeName(DataRefImpl Rel,
SmallVectorImpl<char> &Result) const { SmallVectorImpl<char> &Result) const {
const coff_relocation *reloc = toRel(Rel); const coff_relocation *Reloc = toRel(Rel);
StringRef res; StringRef Res;
switch (COFFHeader->Machine) { switch (COFFHeader->Machine) {
case COFF::IMAGE_FILE_MACHINE_AMD64: case COFF::IMAGE_FILE_MACHINE_AMD64:
switch (reloc->Type) { switch (Reloc->Type) {
LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ABSOLUTE); LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ABSOLUTE);
LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR64); LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR64);
LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR32); LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR32);
@ -859,11 +857,11 @@ error_code COFFObjectFile::getRelocationTypeName(DataRefImpl Rel,
LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_PAIR); LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_PAIR);
LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SSPAN32); LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SSPAN32);
default: default:
res = "Unknown"; Res = "Unknown";
} }
break; break;
case COFF::IMAGE_FILE_MACHINE_I386: case COFF::IMAGE_FILE_MACHINE_I386:
switch (reloc->Type) { switch (Reloc->Type) {
LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_ABSOLUTE); LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_ABSOLUTE);
LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR16); LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR16);
LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL16); LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL16);
@ -876,13 +874,13 @@ error_code COFFObjectFile::getRelocationTypeName(DataRefImpl Rel,
LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECREL7); LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECREL7);
LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL32); LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL32);
default: default:
res = "Unknown"; Res = "Unknown";
} }
break; break;
default: default:
res = "Unknown"; Res = "Unknown";
} }
Result.append(res.begin(), res.end()); Result.append(Res.begin(), Res.end());
return object_error::success; return object_error::success;
} }
@ -890,14 +888,14 @@ error_code COFFObjectFile::getRelocationTypeName(DataRefImpl Rel,
error_code COFFObjectFile::getRelocationValueString(DataRefImpl Rel, error_code COFFObjectFile::getRelocationValueString(DataRefImpl Rel,
SmallVectorImpl<char> &Result) const { SmallVectorImpl<char> &Result) const {
const coff_relocation *reloc = toRel(Rel); const coff_relocation *Reloc = toRel(Rel);
const coff_symbol *symb = 0; const coff_symbol *Symb = 0;
if (error_code ec = getSymbol(reloc->SymbolTableIndex, symb)) return ec; if (error_code EC = getSymbol(Reloc->SymbolTableIndex, Symb)) return EC;
DataRefImpl sym; DataRefImpl Sym;
sym.p = reinterpret_cast<uintptr_t>(symb); Sym.p = reinterpret_cast<uintptr_t>(Symb);
StringRef symname; StringRef SymName;
if (error_code ec = getSymbolName(sym, symname)) return ec; if (error_code EC = getSymbolName(Sym, SymName)) return EC;
Result.append(symname.begin(), symname.end()); Result.append(SymName.begin(), SymName.end());
return object_error::success; return object_error::success;
} }
@ -1004,7 +1002,7 @@ error_code ExportDirectoryEntryRef::getName(StringRef &Result) const {
namespace llvm { namespace llvm {
ObjectFile *ObjectFile::createCOFFObjectFile(MemoryBuffer *Object) { ObjectFile *ObjectFile::createCOFFObjectFile(MemoryBuffer *Object) {
error_code ec; error_code EC;
return new COFFObjectFile(Object, ec); return new COFFObjectFile(Object, EC);
} }
} // end namespace llvm } // end namespace llvm