mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-26 08:56:06 +00:00
26db845536
The section headers for XCOFF files have a subtype flag for Dwarf sections. This PR updates obj2yaml, yaml2obj, and llvm-readobj so that they recognize the subtype.
416 lines
15 KiB
C++
416 lines
15 KiB
C++
//===------ xcoff2yaml.cpp - XCOFF YAMLIO implementation --------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "obj2yaml.h"
|
|
#include "llvm/Object/XCOFFObjectFile.h"
|
|
#include "llvm/ObjectYAML/XCOFFYAML.h"
|
|
#include "llvm/Support/Errc.h"
|
|
#include "llvm/Support/YAMLTraits.h"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::object;
|
|
namespace {
|
|
|
|
class XCOFFDumper {
|
|
const object::XCOFFObjectFile &Obj;
|
|
XCOFFYAML::Object YAMLObj;
|
|
void dumpHeader();
|
|
Error dumpSections();
|
|
Error dumpSymbols();
|
|
template <typename Shdr, typename Reloc>
|
|
Error dumpSections(ArrayRef<Shdr> Sections);
|
|
|
|
// Dump auxiliary symbols.
|
|
Error dumpFileAuxSym(XCOFFYAML::Symbol &Sym,
|
|
const XCOFFSymbolRef &SymbolEntRef);
|
|
Error dumpStatAuxSym(XCOFFYAML::Symbol &Sym,
|
|
const XCOFFSymbolRef &SymbolEntRef);
|
|
Error dumpBlockAuxSym(XCOFFYAML::Symbol &Sym,
|
|
const XCOFFSymbolRef &SymbolEntRef);
|
|
Error dumpDwarfAuxSym(XCOFFYAML::Symbol &Sym,
|
|
const XCOFFSymbolRef &SymbolEntRef);
|
|
Error dumpAuxSyms(XCOFFYAML::Symbol &Sym, const XCOFFSymbolRef &SymbolEntRef);
|
|
void dumpFuncAuxSym(XCOFFYAML::Symbol &Sym, const uintptr_t AuxAddress);
|
|
void dumpExpAuxSym(XCOFFYAML::Symbol &Sym, const uintptr_t AuxAddress);
|
|
void dumpCsectAuxSym(XCOFFYAML::Symbol &Sym,
|
|
const object::XCOFFCsectAuxRef &AuxEntPtr);
|
|
|
|
public:
|
|
XCOFFDumper(const object::XCOFFObjectFile &obj) : Obj(obj) {}
|
|
Error dump();
|
|
XCOFFYAML::Object &getYAMLObj() { return YAMLObj; }
|
|
|
|
template <typename T> const T *getAuxEntPtr(uintptr_t AuxAddress) {
|
|
Obj.checkSymbolEntryPointer(AuxAddress);
|
|
return reinterpret_cast<const T *>(AuxAddress);
|
|
}
|
|
};
|
|
} // namespace
|
|
|
|
Error XCOFFDumper::dump() {
|
|
dumpHeader();
|
|
if (Error E = dumpSections())
|
|
return E;
|
|
return dumpSymbols();
|
|
}
|
|
|
|
void XCOFFDumper::dumpHeader() {
|
|
YAMLObj.Header.Magic = Obj.getMagic();
|
|
YAMLObj.Header.NumberOfSections = Obj.getNumberOfSections();
|
|
YAMLObj.Header.TimeStamp = Obj.getTimeStamp();
|
|
YAMLObj.Header.SymbolTableOffset = Obj.is64Bit()
|
|
? Obj.getSymbolTableOffset64()
|
|
: Obj.getSymbolTableOffset32();
|
|
YAMLObj.Header.NumberOfSymTableEntries =
|
|
Obj.is64Bit() ? Obj.getNumberOfSymbolTableEntries64()
|
|
: Obj.getRawNumberOfSymbolTableEntries32();
|
|
YAMLObj.Header.AuxHeaderSize = Obj.getOptionalHeaderSize();
|
|
YAMLObj.Header.Flags = Obj.getFlags();
|
|
}
|
|
|
|
Error XCOFFDumper::dumpSections() {
|
|
if (Obj.is64Bit())
|
|
return dumpSections<XCOFFSectionHeader64, XCOFFRelocation64>(
|
|
Obj.sections64());
|
|
return dumpSections<XCOFFSectionHeader32, XCOFFRelocation32>(
|
|
Obj.sections32());
|
|
}
|
|
|
|
template <typename Shdr, typename Reloc>
|
|
Error XCOFFDumper::dumpSections(ArrayRef<Shdr> Sections) {
|
|
std::vector<XCOFFYAML::Section> &YamlSections = YAMLObj.Sections;
|
|
for (const Shdr &S : Sections) {
|
|
XCOFFYAML::Section YamlSec;
|
|
YamlSec.SectionName = S.getName();
|
|
YamlSec.Address = S.PhysicalAddress;
|
|
YamlSec.Size = S.SectionSize;
|
|
YamlSec.NumberOfRelocations = S.NumberOfRelocations;
|
|
YamlSec.NumberOfLineNumbers = S.NumberOfLineNumbers;
|
|
YamlSec.FileOffsetToData = S.FileOffsetToRawData;
|
|
YamlSec.FileOffsetToRelocations = S.FileOffsetToRelocationInfo;
|
|
YamlSec.FileOffsetToLineNumbers = S.FileOffsetToLineNumberInfo;
|
|
YamlSec.Flags = S.Flags;
|
|
if (YamlSec.Flags & XCOFF::STYP_DWARF) {
|
|
unsigned Mask = Obj.is64Bit()
|
|
? XCOFFSectionHeader64::SectionFlagsTypeMask
|
|
: XCOFFSectionHeader32::SectionFlagsTypeMask;
|
|
YamlSec.SectionSubtype =
|
|
static_cast<XCOFF::DwarfSectionSubtypeFlags>(S.Flags & ~Mask);
|
|
}
|
|
|
|
// Dump section data.
|
|
if (S.FileOffsetToRawData) {
|
|
DataRefImpl SectionDRI;
|
|
SectionDRI.p = reinterpret_cast<uintptr_t>(&S);
|
|
Expected<ArrayRef<uint8_t>> SecDataRefOrErr =
|
|
Obj.getSectionContents(SectionDRI);
|
|
if (!SecDataRefOrErr)
|
|
return SecDataRefOrErr.takeError();
|
|
YamlSec.SectionData = SecDataRefOrErr.get();
|
|
}
|
|
|
|
// Dump relocations.
|
|
if (S.NumberOfRelocations) {
|
|
auto RelRefOrErr = Obj.relocations<Shdr, Reloc>(S);
|
|
if (!RelRefOrErr)
|
|
return RelRefOrErr.takeError();
|
|
for (const Reloc &R : RelRefOrErr.get()) {
|
|
XCOFFYAML::Relocation YamlRel;
|
|
YamlRel.Type = R.Type;
|
|
YamlRel.Info = R.Info;
|
|
YamlRel.SymbolIndex = R.SymbolIndex;
|
|
YamlRel.VirtualAddress = R.VirtualAddress;
|
|
YamlSec.Relocations.push_back(YamlRel);
|
|
}
|
|
}
|
|
YamlSections.push_back(YamlSec);
|
|
}
|
|
return Error::success();
|
|
}
|
|
|
|
Error XCOFFDumper::dumpFileAuxSym(XCOFFYAML::Symbol &Sym,
|
|
const XCOFFSymbolRef &SymbolEntRef) {
|
|
for (uint8_t I = 1; I <= Sym.NumberOfAuxEntries; ++I) {
|
|
uintptr_t AuxAddress = XCOFFObjectFile::getAdvancedSymbolEntryAddress(
|
|
SymbolEntRef.getEntryAddress(), I);
|
|
const XCOFFFileAuxEnt *FileAuxEntPtr =
|
|
getAuxEntPtr<XCOFFFileAuxEnt>(AuxAddress);
|
|
auto FileNameOrError = Obj.getCFileName(FileAuxEntPtr);
|
|
if (!FileNameOrError)
|
|
return FileNameOrError.takeError();
|
|
|
|
XCOFFYAML::FileAuxEnt FileAuxSym;
|
|
FileAuxSym.FileNameOrString = FileNameOrError.get();
|
|
FileAuxSym.FileStringType = FileAuxEntPtr->Type;
|
|
Sym.AuxEntries.push_back(
|
|
std::make_unique<XCOFFYAML::FileAuxEnt>(FileAuxSym));
|
|
}
|
|
return Error::success();
|
|
}
|
|
|
|
Error XCOFFDumper::dumpStatAuxSym(XCOFFYAML::Symbol &Sym,
|
|
const XCOFFSymbolRef &SymbolEntRef) {
|
|
if (Sym.NumberOfAuxEntries != 1) {
|
|
uint32_t SymbolIndex = Obj.getSymbolIndex(SymbolEntRef.getEntryAddress());
|
|
return createError("failed to parse symbol \"" + Sym.SymbolName +
|
|
"\" with index of " + Twine(SymbolIndex) +
|
|
": expected 1 aux symbol for C_STAT, while got " +
|
|
Twine(static_cast<uint32_t>(*Sym.NumberOfAuxEntries)));
|
|
}
|
|
|
|
const XCOFFSectAuxEntForStat *AuxEntPtr =
|
|
getAuxEntPtr<XCOFFSectAuxEntForStat>(
|
|
XCOFFObjectFile::getAdvancedSymbolEntryAddress(
|
|
SymbolEntRef.getEntryAddress(), 1));
|
|
XCOFFYAML::SectAuxEntForStat StatAuxSym;
|
|
StatAuxSym.SectionLength = AuxEntPtr->SectionLength;
|
|
StatAuxSym.NumberOfLineNum = AuxEntPtr->NumberOfLineNum;
|
|
StatAuxSym.NumberOfRelocEnt = AuxEntPtr->NumberOfRelocEnt;
|
|
Sym.AuxEntries.push_back(
|
|
std::make_unique<XCOFFYAML::SectAuxEntForStat>(StatAuxSym));
|
|
return Error::success();
|
|
}
|
|
|
|
void XCOFFDumper::dumpFuncAuxSym(XCOFFYAML::Symbol &Sym,
|
|
const uintptr_t AuxAddress) {
|
|
XCOFFYAML::FunctionAuxEnt FunAuxSym;
|
|
|
|
if (Obj.is64Bit()) {
|
|
const XCOFFFunctionAuxEnt64 *AuxEntPtr =
|
|
getAuxEntPtr<XCOFFFunctionAuxEnt64>(AuxAddress);
|
|
FunAuxSym.PtrToLineNum = AuxEntPtr->PtrToLineNum;
|
|
FunAuxSym.SizeOfFunction = AuxEntPtr->SizeOfFunction;
|
|
FunAuxSym.SymIdxOfNextBeyond = AuxEntPtr->SymIdxOfNextBeyond;
|
|
} else {
|
|
const XCOFFFunctionAuxEnt32 *AuxEntPtr =
|
|
getAuxEntPtr<XCOFFFunctionAuxEnt32>(AuxAddress);
|
|
FunAuxSym.OffsetToExceptionTbl = AuxEntPtr->OffsetToExceptionTbl;
|
|
FunAuxSym.PtrToLineNum = AuxEntPtr->PtrToLineNum;
|
|
FunAuxSym.SizeOfFunction = AuxEntPtr->SizeOfFunction;
|
|
FunAuxSym.SymIdxOfNextBeyond = AuxEntPtr->SymIdxOfNextBeyond;
|
|
}
|
|
|
|
Sym.AuxEntries.push_back(
|
|
std::make_unique<XCOFFYAML::FunctionAuxEnt>(FunAuxSym));
|
|
}
|
|
|
|
void XCOFFDumper::dumpExpAuxSym(XCOFFYAML::Symbol &Sym,
|
|
const uintptr_t AuxAddress) {
|
|
const XCOFFExceptionAuxEnt *AuxEntPtr =
|
|
getAuxEntPtr<XCOFFExceptionAuxEnt>(AuxAddress);
|
|
XCOFFYAML::ExcpetionAuxEnt ExceptAuxSym;
|
|
ExceptAuxSym.OffsetToExceptionTbl = AuxEntPtr->OffsetToExceptionTbl;
|
|
ExceptAuxSym.SizeOfFunction = AuxEntPtr->SizeOfFunction;
|
|
ExceptAuxSym.SymIdxOfNextBeyond = AuxEntPtr->SymIdxOfNextBeyond;
|
|
Sym.AuxEntries.push_back(
|
|
std::make_unique<XCOFFYAML::ExcpetionAuxEnt>(ExceptAuxSym));
|
|
}
|
|
|
|
void XCOFFDumper::dumpCsectAuxSym(XCOFFYAML::Symbol &Sym,
|
|
const object::XCOFFCsectAuxRef &AuxEntPtr) {
|
|
XCOFFYAML::CsectAuxEnt CsectAuxSym;
|
|
CsectAuxSym.ParameterHashIndex = AuxEntPtr.getParameterHashIndex();
|
|
CsectAuxSym.TypeChkSectNum = AuxEntPtr.getTypeChkSectNum();
|
|
CsectAuxSym.SymbolAlignment = AuxEntPtr.getAlignmentLog2();
|
|
CsectAuxSym.SymbolType =
|
|
static_cast<XCOFF::SymbolType>(AuxEntPtr.getSymbolType());
|
|
CsectAuxSym.StorageMappingClass = AuxEntPtr.getStorageMappingClass();
|
|
|
|
if (Obj.is64Bit()) {
|
|
CsectAuxSym.SectionOrLengthLo =
|
|
static_cast<uint32_t>(AuxEntPtr.getSectionOrLength64());
|
|
CsectAuxSym.SectionOrLengthHi =
|
|
static_cast<uint32_t>(AuxEntPtr.getSectionOrLength64() >> 32);
|
|
} else {
|
|
CsectAuxSym.SectionOrLength = AuxEntPtr.getSectionOrLength32();
|
|
CsectAuxSym.StabInfoIndex = AuxEntPtr.getStabInfoIndex32();
|
|
CsectAuxSym.StabSectNum = AuxEntPtr.getStabSectNum32();
|
|
}
|
|
|
|
Sym.AuxEntries.push_back(
|
|
std::make_unique<XCOFFYAML::CsectAuxEnt>(CsectAuxSym));
|
|
}
|
|
|
|
Error XCOFFDumper::dumpAuxSyms(XCOFFYAML::Symbol &Sym,
|
|
const XCOFFSymbolRef &SymbolEntRef) {
|
|
auto ErrOrCsectAuxRef = SymbolEntRef.getXCOFFCsectAuxRef();
|
|
if (!ErrOrCsectAuxRef)
|
|
return ErrOrCsectAuxRef.takeError();
|
|
XCOFFCsectAuxRef CsectAuxRef = ErrOrCsectAuxRef.get();
|
|
|
|
for (uint8_t I = 1; I <= Sym.NumberOfAuxEntries; ++I) {
|
|
|
|
if (I == Sym.NumberOfAuxEntries && !Obj.is64Bit()) {
|
|
dumpCsectAuxSym(Sym, CsectAuxRef);
|
|
return Error::success();
|
|
}
|
|
|
|
uintptr_t AuxAddress = XCOFFObjectFile::getAdvancedSymbolEntryAddress(
|
|
SymbolEntRef.getEntryAddress(), I);
|
|
|
|
if (Obj.is64Bit()) {
|
|
XCOFF::SymbolAuxType Type = *Obj.getSymbolAuxType(AuxAddress);
|
|
if (Type == XCOFF::SymbolAuxType::AUX_CSECT)
|
|
dumpCsectAuxSym(Sym, CsectAuxRef);
|
|
else if (Type == XCOFF::SymbolAuxType::AUX_FCN)
|
|
dumpFuncAuxSym(Sym, AuxAddress);
|
|
else if (Type == XCOFF::SymbolAuxType::AUX_EXCEPT)
|
|
dumpExpAuxSym(Sym, AuxAddress);
|
|
else {
|
|
uint32_t SymbolIndex =
|
|
Obj.getSymbolIndex(SymbolEntRef.getEntryAddress());
|
|
return createError("failed to parse symbol \"" + Sym.SymbolName +
|
|
"\" with index of " + Twine(SymbolIndex) +
|
|
": invalid auxiliary symbol type: " +
|
|
Twine(static_cast<uint32_t>(Type)));
|
|
}
|
|
|
|
} else
|
|
dumpFuncAuxSym(Sym, AuxAddress);
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
Error XCOFFDumper::dumpBlockAuxSym(XCOFFYAML::Symbol &Sym,
|
|
const XCOFFSymbolRef &SymbolEntRef) {
|
|
if (Sym.NumberOfAuxEntries != 1) {
|
|
uint32_t SymbolIndex = Obj.getSymbolIndex(SymbolEntRef.getEntryAddress());
|
|
return createError(
|
|
"failed to parse symbol \"" + Sym.SymbolName + "\" with index of " +
|
|
Twine(SymbolIndex) +
|
|
": expected 1 aux symbol for C_BLOCK or C_FCN, while got " +
|
|
Twine(static_cast<uint32_t>(*Sym.NumberOfAuxEntries)));
|
|
}
|
|
|
|
uintptr_t AuxAddress = XCOFFObjectFile::getAdvancedSymbolEntryAddress(
|
|
SymbolEntRef.getEntryAddress(), 1);
|
|
XCOFFYAML::BlockAuxEnt BlockAuxSym;
|
|
|
|
if (Obj.is64Bit()) {
|
|
const XCOFFBlockAuxEnt64 *AuxEntPtr =
|
|
getAuxEntPtr<XCOFFBlockAuxEnt64>(AuxAddress);
|
|
BlockAuxSym.LineNum = AuxEntPtr->LineNum;
|
|
} else {
|
|
const XCOFFBlockAuxEnt32 *AuxEntPtr =
|
|
getAuxEntPtr<XCOFFBlockAuxEnt32>(AuxAddress);
|
|
BlockAuxSym.LineNumLo = AuxEntPtr->LineNumLo;
|
|
BlockAuxSym.LineNumHi = AuxEntPtr->LineNumHi;
|
|
}
|
|
|
|
Sym.AuxEntries.push_back(
|
|
std::make_unique<XCOFFYAML::BlockAuxEnt>(BlockAuxSym));
|
|
return Error::success();
|
|
}
|
|
|
|
Error XCOFFDumper::dumpDwarfAuxSym(XCOFFYAML::Symbol &Sym,
|
|
const XCOFFSymbolRef &SymbolEntRef) {
|
|
if (Sym.NumberOfAuxEntries != 1) {
|
|
uint32_t SymbolIndex = Obj.getSymbolIndex(SymbolEntRef.getEntryAddress());
|
|
return createError("failed to parse symbol \"" + Sym.SymbolName +
|
|
"\" with index of " + Twine(SymbolIndex) +
|
|
": expected 1 aux symbol for C_DWARF, while got " +
|
|
Twine(static_cast<uint32_t>(*Sym.NumberOfAuxEntries)));
|
|
}
|
|
|
|
uintptr_t AuxAddress = XCOFFObjectFile::getAdvancedSymbolEntryAddress(
|
|
SymbolEntRef.getEntryAddress(), 1);
|
|
XCOFFYAML::SectAuxEntForDWARF DwarfAuxSym;
|
|
|
|
if (Obj.is64Bit()) {
|
|
const XCOFFSectAuxEntForDWARF64 *AuxEntPtr =
|
|
getAuxEntPtr<XCOFFSectAuxEntForDWARF64>(AuxAddress);
|
|
DwarfAuxSym.LengthOfSectionPortion = AuxEntPtr->LengthOfSectionPortion;
|
|
DwarfAuxSym.NumberOfRelocEnt = AuxEntPtr->NumberOfRelocEnt;
|
|
} else {
|
|
const XCOFFSectAuxEntForDWARF32 *AuxEntPtr =
|
|
getAuxEntPtr<XCOFFSectAuxEntForDWARF32>(AuxAddress);
|
|
DwarfAuxSym.LengthOfSectionPortion = AuxEntPtr->LengthOfSectionPortion;
|
|
DwarfAuxSym.NumberOfRelocEnt = AuxEntPtr->NumberOfRelocEnt;
|
|
}
|
|
|
|
Sym.AuxEntries.push_back(
|
|
std::make_unique<XCOFFYAML::SectAuxEntForDWARF>(DwarfAuxSym));
|
|
return Error::success();
|
|
}
|
|
|
|
Error XCOFFDumper::dumpSymbols() {
|
|
std::vector<XCOFFYAML::Symbol> &Symbols = YAMLObj.Symbols;
|
|
|
|
for (const SymbolRef &S : Obj.symbols()) {
|
|
DataRefImpl SymbolDRI = S.getRawDataRefImpl();
|
|
const XCOFFSymbolRef SymbolEntRef = Obj.toSymbolRef(SymbolDRI);
|
|
XCOFFYAML::Symbol Sym;
|
|
|
|
Expected<StringRef> SymNameRefOrErr = Obj.getSymbolName(SymbolDRI);
|
|
if (!SymNameRefOrErr) {
|
|
return SymNameRefOrErr.takeError();
|
|
}
|
|
Sym.SymbolName = SymNameRefOrErr.get();
|
|
|
|
Sym.Value = SymbolEntRef.getValue();
|
|
|
|
Expected<StringRef> SectionNameRefOrErr =
|
|
Obj.getSymbolSectionName(SymbolEntRef);
|
|
if (!SectionNameRefOrErr)
|
|
return SectionNameRefOrErr.takeError();
|
|
|
|
Sym.SectionName = SectionNameRefOrErr.get();
|
|
|
|
Sym.Type = SymbolEntRef.getSymbolType();
|
|
Sym.StorageClass = SymbolEntRef.getStorageClass();
|
|
Sym.NumberOfAuxEntries = SymbolEntRef.getNumberOfAuxEntries();
|
|
|
|
if (Sym.NumberOfAuxEntries) {
|
|
switch (Sym.StorageClass) {
|
|
case XCOFF::C_FILE:
|
|
if (Error E = dumpFileAuxSym(Sym, SymbolEntRef))
|
|
return E;
|
|
break;
|
|
case XCOFF::C_STAT:
|
|
if (Error E = dumpStatAuxSym(Sym, SymbolEntRef))
|
|
return E;
|
|
break;
|
|
case XCOFF::C_EXT:
|
|
case XCOFF::C_WEAKEXT:
|
|
case XCOFF::C_HIDEXT:
|
|
if (Error E = dumpAuxSyms(Sym, SymbolEntRef))
|
|
return E;
|
|
break;
|
|
case XCOFF::C_BLOCK:
|
|
case XCOFF::C_FCN:
|
|
if (Error E = dumpBlockAuxSym(Sym, SymbolEntRef))
|
|
return E;
|
|
break;
|
|
case XCOFF::C_DWARF:
|
|
if (Error E = dumpDwarfAuxSym(Sym, SymbolEntRef))
|
|
return E;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
Symbols.push_back(std::move(Sym));
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
Error xcoff2yaml(raw_ostream &Out, const object::XCOFFObjectFile &Obj) {
|
|
XCOFFDumper Dumper(Obj);
|
|
|
|
if (Error E = Dumper.dump())
|
|
return E;
|
|
|
|
yaml::Output Yout(Out);
|
|
Yout << Dumper.getYAMLObj();
|
|
|
|
return Error::success();
|
|
}
|