// The structure of the yaml files is not an exact 1:1 match to COFF. In order
// to use yaml::IO, we use these structures which are closer to the source.
namespace COFFYAML {
+ /// In an object file this is just a binary blob. In an yaml file it is an hex
+ /// string. Using this avoid having to allocate temporary strings.
+ /// FIXME: not COFF specific.
+ class BinaryRef {
+ union {
+ ArrayRef<uint8_t> BinaryData;
+ StringRef HexData;
+ };
+ bool isBinary;
+ public:
+ BinaryRef(ArrayRef<uint8_t> BinaryData)
+ : BinaryData(BinaryData), isBinary(true) {}
+ BinaryRef(StringRef HexData) : HexData(HexData), isBinary(false) {}
+ BinaryRef() : isBinary(false) {}
+ StringRef getHex() const {
+ assert(!isBinary);
+ return HexData;
+ }
+ ArrayRef<uint8_t> getBinary() const {
+ assert(isBinary);
+ return BinaryData;
+ }
+ };
+
struct Section {
COFF::section Header;
unsigned Alignment;
- StringRef SectionData;
+ BinaryRef SectionData;
std::vector<COFF::relocation> Relocations;
StringRef Name;
Section();
COFF::symbol Header;
COFF::SymbolBaseType SimpleType;
COFF::SymbolComplexType ComplexType;
- StringRef AuxiliaryData;
+ BinaryRef AuxiliaryData;
StringRef Name;
Symbol();
};
namespace llvm {
namespace yaml {
+template<>
+struct ScalarTraits<COFFYAML::BinaryRef> {
+ static void output(const COFFYAML::BinaryRef &, void*, llvm::raw_ostream &);
+ static StringRef input(StringRef, void*, COFFYAML::BinaryRef &);
+};
+
template <>
struct ScalarEnumerationTraits<COFF::MachineTypes> {
static void enumeration(IO &IO, COFF::MachineTypes &Value);
}
+void ScalarTraits<COFFYAML::BinaryRef>::output(const COFFYAML::BinaryRef &Val,
+ void *, llvm::raw_ostream &Out) {
+ ArrayRef<uint8_t> Data = Val.getBinary();
+ for (ArrayRef<uint8_t>::iterator I = Data.begin(), E = Data.end(); I != E;
+ ++I) {
+ uint8_t Byte = *I;
+ Out << hexdigit(Byte >> 4);
+ Out << hexdigit(Byte & 0xf);
+ }
+}
+
+StringRef ScalarTraits<COFFYAML::BinaryRef>::input(StringRef Scalar, void *,
+ COFFYAML::BinaryRef &Val) {
+ Val = COFFYAML::BinaryRef(Scalar);
+ return StringRef();
+}
+
void MappingTraits<COFF::relocation>::mapping(IO &IO, COFF::relocation &Rel) {
MappingNormalization<NType, uint16_t> NT(IO, Rel.Type);
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/YAMLTraits.h"
-#include <list>
-
using namespace llvm;
namespace {
void dumpHeader(const object::coff_file_header *Header);
void dumpSections(unsigned numSections);
void dumpSymbols(unsigned numSymbols);
- StringRef getHexString(ArrayRef<uint8_t> Data);
- std::list<std::string> Strings;
public:
COFFDumper(const object::COFFObjectFile &Obj);
ArrayRef<uint8_t> sectionData;
Obj.getSectionContents(Sect, sectionData);
- Sec.SectionData = getHexString(sectionData);
+ Sec.SectionData = COFFYAML::BinaryRef(sectionData);
std::vector<COFF::relocation> Relocations;
for (object::relocation_iterator rIter = iter->begin_relocations();
Sym.Header.Value = Symbol->Value;
Sym.Header.SectionNumber = Symbol->SectionNumber;
Sym.Header.NumberOfAuxSymbols = Symbol->NumberOfAuxSymbols;
- Sym.AuxiliaryData = getHexString(Obj.getSymbolAuxData(Symbol));
+ Sym.AuxiliaryData = COFFYAML::BinaryRef(Obj.getSymbolAuxData(Symbol));
Symbols.push_back(Sym);
}
}
-StringRef COFFDumper::getHexString(ArrayRef<uint8_t> Data) {
- std::string S;
- for (ArrayRef<uint8_t>::iterator I = Data.begin(), E = Data.end(); I != E;
- ++I) {
- uint8_t Byte = *I;
- S.push_back(hexdigit(Byte >> 4));
- S.push_back(hexdigit(Byte & 0xf));
- }
- Strings.push_back(S);
- return Strings.back();
-}
-
COFFYAML::Object &COFFDumper::getYAMLObj() {
return YAMLObj;
}
for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
e = CP.Obj.Sections.end();
i != e; ++i) {
- if (!i->SectionData.empty()) {
- i->Header.SizeOfRawData = i->SectionData.size()/2;
+ StringRef SecData = i->SectionData.getHex();
+ if (!SecData.empty()) {
+ i->Header.SizeOfRawData = SecData.size()/2;
i->Header.PointerToRawData = CurrentSectionDataOffset;
CurrentSectionDataOffset += i->Header.SizeOfRawData;
if (!i->Relocations.empty()) {
for (std::vector<COFFYAML::Symbol>::iterator i = CP.Obj.Symbols.begin(),
e = CP.Obj.Symbols.end();
i != e; ++i) {
- unsigned AuxBytes = i->AuxiliaryData.size() / 2;
+ unsigned AuxBytes = i->AuxiliaryData.getHex().size() / 2;
if (AuxBytes % COFF::SymbolSize != 0) {
errs() << "AuxiliaryData size not a multiple of symbol size!\n";
return false;
for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
e = CP.Obj.Sections.end();
i != e; ++i) {
- if (!i->SectionData.empty()) {
- if (!writeHexData(i->SectionData, OS)) {
+ StringRef SecData = i->SectionData.getHex();
+ if (!SecData.empty()) {
+ if (!writeHexData(SecData, OS)) {
errs() << "SectionData must be a collection of pairs of hex bytes";
return false;
}
<< binary_le(i->Header.Type)
<< binary_le(i->Header.StorageClass)
<< binary_le(i->Header.NumberOfAuxSymbols);
- if (!i->AuxiliaryData.empty()) {
- if (!writeHexData(i->AuxiliaryData, OS)) {
+ StringRef Data = i->AuxiliaryData.getHex();
+ if (!Data.empty()) {
+ if (!writeHexData(Data, OS)) {
errs() << "AuxiliaryData must be a collection of pairs of hex bytes";
return false;
}