| //===- lib/ReaderWriter/YAML/ReaderWriterYAML.cpp -------------------------===// |
| // |
| // The LLVM Linker |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| |
| #include "lld/Core/ArchiveLibraryFile.h" |
| #include "lld/Core/DefinedAtom.h" |
| #include "lld/Core/Error.h" |
| #include "lld/Core/File.h" |
| #include "lld/Core/LLVM.h" |
| #include "lld/Core/Reference.h" |
| #include "lld/ReaderWriter/ReaderYAML.h" |
| #include "lld/ReaderWriter/WriterYAML.h" |
| |
| #include "llvm/ADT/ArrayRef.h" |
| #include "llvm/ADT/OwningPtr.h" |
| #include "llvm/ADT/StringMap.h" |
| #include "llvm/ADT/Twine.h" |
| #include "llvm/Support/Debug.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include "llvm/Support/Format.h" |
| #include "llvm/Support/MemoryBuffer.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include "llvm/Support/system_error.h" |
| #include "llvm/Support/YAMLTraits.h" |
| |
| #include <string> |
| |
| using llvm::yaml::MappingTraits; |
| using llvm::yaml::ScalarEnumerationTraits; |
| using llvm::yaml::ScalarTraits; |
| using llvm::yaml::IO; |
| using llvm::yaml::SequenceTraits; |
| using llvm::yaml::DocumentListTraits; |
| |
| |
| /// The conversion of Atoms to and from YAML uses LLVM's YAML I/O. This |
| /// file just defines template specializations on the lld types which control |
| /// how the mapping is done to and from YAML. |
| |
| |
| namespace { |
| /// Most of the traits are context-free and always do the same transformation. |
| /// But, there are some traits that need some contextual information to properly |
| /// do their transform. This struct is available via io.getContext() and |
| /// supplies contextual information. |
| class ContextInfo { |
| public: |
| ContextInfo(const lld::ReaderOptionsYAML &ro) |
| : _currentFile(nullptr), _readerOptions(&ro), _writerOptions(nullptr) { } |
| ContextInfo(const lld::WriterOptionsYAML &wo) |
| : _currentFile(nullptr), _readerOptions(nullptr), _writerOptions(&wo) { } |
| |
| lld::File *_currentFile; |
| const lld::ReaderOptionsYAML *_readerOptions; |
| const lld::WriterOptionsYAML *_writerOptions; |
| }; |
| |
| |
| /// Used when writing yaml files. |
| /// In most cases, atoms names are unambiguous, so references can just |
| /// use the atom name as the target (e.g. target: foo). But in a few |
| /// cases that does not work, so ref-names are added. These are labels |
| /// used only in yaml. The labels do not exist in the Atom model. |
| /// |
| /// One need for ref-names are when atoms have no user supplied name |
| /// (e.g. c-string literal). Another case is when two object files with |
| /// identically named static functions are merged (ld -r) into one object file. |
| /// In that case referencing the function by name is ambiguous, so a unique |
| /// ref-name is added. |
| class RefNameBuilder { |
| public: |
| RefNameBuilder(const lld::File &file) |
| : _collisionCount(0), _unnamedCounter(0) { |
| if (&file == nullptr) |
| return; |
| // visit all atoms |
| for (const lld::DefinedAtom *atom : file.defined()) { |
| // Build map of atoms names to detect duplicates |
| if (!atom->name().empty()) |
| buildDuplicateNameMap(*atom); |
| |
| // Find references to unnamed atoms and create ref-names for them. |
| for (const lld::Reference *ref : *atom) { |
| // create refname for any unnamed reference target |
| const lld::Atom *target = ref->target(); |
| if ((target != nullptr) && target->name().empty()) { |
| std::string storage; |
| llvm::raw_string_ostream buffer(storage); |
| buffer << llvm::format("L%03d", _unnamedCounter++); |
| llvm::StringRef newName = copyString(buffer.str()); |
| _refNames[target] = newName; |
| DEBUG_WITH_TYPE("WriterYAML", llvm::dbgs() |
| << "unnamed atom: creating ref-name: '" << newName |
| << "' (" << (void*)newName.data() << ", " |
| << newName.size() << ")\n"); |
| } |
| } |
| } |
| for (const lld::UndefinedAtom *undefAtom : file.undefined()) { |
| buildDuplicateNameMap(*undefAtom); |
| } |
| for (const lld::SharedLibraryAtom *shlibAtom : file.sharedLibrary()) { |
| buildDuplicateNameMap(*shlibAtom); |
| } |
| for (const lld::AbsoluteAtom *absAtom : file.absolute()) { |
| buildDuplicateNameMap(*absAtom); |
| } |
| } |
| |
| void buildDuplicateNameMap(const lld::Atom &atom) { |
| assert(!atom.name().empty()); |
| NameToAtom::iterator pos = _nameMap.find(atom.name()); |
| if ( pos != _nameMap.end() ) { |
| // Found name collision, give each a unique ref-name. |
| std::string Storage; |
| llvm::raw_string_ostream buffer(Storage); |
| buffer << atom.name() << llvm::format(".%03d", ++_collisionCount); |
| llvm::StringRef newName = copyString(buffer.str()); |
| _refNames[&atom] = newName; |
| DEBUG_WITH_TYPE("WriterYAML", llvm::dbgs() |
| << "name collsion: creating ref-name: '" << newName |
| << "' (" << (void*)newName.data() << ", " |
| << newName.size() << ")\n"); |
| const lld::Atom *prevAtom = pos->second; |
| AtomToRefName::iterator pos2 = _refNames.find(prevAtom); |
| if ( pos2 == _refNames.end() ) { |
| // Only create ref-name for previous if none already created. |
| std::string Storage2; |
| llvm::raw_string_ostream buffer2(Storage2); |
| buffer2 << prevAtom->name() << llvm::format(".%03d", ++_collisionCount); |
| llvm::StringRef newName2 = copyString(buffer2.str()); |
| _refNames[prevAtom] = newName2; |
| DEBUG_WITH_TYPE("WriterYAML", llvm::dbgs() |
| << "name collsion: creating ref-name: '" << newName2 |
| << "' (" << (void*)newName2.data() << ", " |
| << newName2.size() << ")\n"); |
| } |
| } |
| else { |
| // First time we've seen this name, just add it to map. |
| _nameMap[atom.name()] = &atom; |
| DEBUG_WITH_TYPE("WriterYAML", llvm::dbgs() |
| << "atom name seen for first time: '" << atom.name() |
| << "' (" << (void*)atom.name().data() << ", " |
| << atom.name().size() << ")\n"); |
| } |
| } |
| |
| bool hasRefName(const lld::Atom *atom) { |
| return _refNames.count(atom); |
| } |
| |
| llvm::StringRef refName(const lld::Atom *atom) { |
| return _refNames.find(atom)->second; |
| } |
| |
| private: |
| typedef llvm::StringMap<const lld::Atom*> NameToAtom; |
| typedef llvm::DenseMap<const lld::Atom*, std::string> AtomToRefName; |
| |
| // Allocate a new copy of this string and keep track of allocations |
| // in _stringCopies, so they can be freed when RefNameBuilder is destroyed. |
| llvm::StringRef copyString(llvm::StringRef str) { |
| // We want _stringCopies to own the string memory so it is deallocated |
| // when the File object is destroyed. But we need a StringRef that |
| // points into that memory. |
| std::unique_ptr<char> s = std::unique_ptr<char>(new char[str.size()]); |
| memcpy(s.get(), str.data(), str.size()); |
| llvm::StringRef r = llvm::StringRef(s.get(), str.size()); |
| _stringCopies.push_back(std::move(s)); |
| return r; |
| } |
| |
| unsigned int _collisionCount; |
| unsigned int _unnamedCounter; |
| NameToAtom _nameMap; |
| AtomToRefName _refNames; |
| std::vector<std::unique_ptr<char>> _stringCopies; |
| }; |
| |
| |
| /// Used when reading yaml files to find the target of a reference |
| /// that could be a name or ref-name. |
| class RefNameResolver { |
| public: |
| RefNameResolver(const lld::File *file, IO &io); |
| |
| const lld::Atom *lookup(llvm::StringRef name) const { |
| NameToAtom::const_iterator pos = _nameMap.find(name); |
| if (pos != _nameMap.end()) { |
| return pos->second; |
| } |
| else { |
| _io.setError(llvm::Twine("no such atom name: ") + name); |
| return nullptr; |
| } |
| } |
| |
| private: |
| typedef llvm::StringMap<const lld::Atom*> NameToAtom; |
| |
| void add(llvm::StringRef name, const lld::Atom *atom) { |
| if (_nameMap.count(name)) { |
| _io.setError(llvm::Twine("duplicate atom name: ") + name); |
| } |
| else { |
| _nameMap[name] = atom; |
| } |
| } |
| |
| IO &_io; |
| NameToAtom _nameMap; |
| }; |
| |
| |
| // Used in NormalizedFile to hold the atoms lists. |
| template <typename T> |
| class AtomList : public lld::File::atom_collection<T> { |
| public: |
| virtual lld::File::atom_iterator<T> begin() const { |
| return lld::File::atom_iterator<T>(*this, reinterpret_cast<const void*> |
| (_atoms.data())); |
| } |
| virtual lld::File::atom_iterator<T> end() const{ |
| return lld::File::atom_iterator<T>(*this, reinterpret_cast<const void*> |
| (_atoms.data() + _atoms.size())); |
| } |
| virtual const T *deref(const void *it) const { |
| return *reinterpret_cast<const T *const*>(it); |
| } |
| virtual void next(const void *&it) const { |
| const T *const *p = reinterpret_cast<const T *const *>(it); |
| ++p; |
| it = reinterpret_cast<const void*>(p); |
| } |
| virtual void push_back(const T *element) { |
| _atoms.push_back(element); |
| } |
| std::vector<const T*> _atoms; |
| }; |
| |
| /// Mapping of kind: field in yaml files. |
| enum FileKinds { |
| fileKindObjectAtoms, // atom based object file encoded in yaml |
| fileKindArchive, // static archive library encoded in yaml |
| fileKindObjectELF, // ELF object files encoded in yaml |
| fileKindObjectMachO // mach-o object files encoded in yaml |
| }; |
| |
| struct ArchMember { |
| FileKinds _kind; |
| llvm::StringRef _name; |
| const lld::File *_content; |
| }; |
| |
| |
| // The content bytes in a DefinedAtom are just uint8_t but we want |
| // special formatting, so define a strong type. |
| LLVM_YAML_STRONG_TYPEDEF(uint8_t, ImplicitHex8) |
| |
| // SharedLibraryAtoms have a bool canBeNull() method which we'd like to be |
| // more readable than just true/false. |
| LLVM_YAML_STRONG_TYPEDEF(bool, ShlibCanBeNull) |
| |
| // lld::Reference::Kind is a typedef of int32. We need a stronger |
| // type to make template matching work, so invent RefKind. |
| LLVM_YAML_STRONG_TYPEDEF(lld::Reference::Kind, RefKind) |
| |
| |
| } // namespace anon |
| |
| |
| LLVM_YAML_IS_SEQUENCE_VECTOR(ArchMember); |
| LLVM_YAML_IS_SEQUENCE_VECTOR(const lld::Reference*) |
| |
| // Always write DefinedAtoms content bytes as a flow sequence. |
| LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(ImplicitHex8); |
| |
| // for compatibility with gcc-4.7 in C++11 mode, add extra namespace |
| namespace llvm { |
| namespace yaml { |
| |
| // This is a custom formatter for RefKind |
| template<> |
| struct ScalarTraits<RefKind> { |
| static void output(const RefKind &value, void *ctxt, |
| llvm::raw_ostream &out) { |
| assert(ctxt != nullptr); |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(ctxt); |
| out << info->_writerOptions->kindToString(value); |
| } |
| |
| static StringRef input(StringRef scalar, void *ctxt, RefKind &value) { |
| assert(ctxt != nullptr); |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(ctxt); |
| value = info->_readerOptions->kindFromString(scalar); |
| return StringRef(); |
| } |
| }; |
| |
| |
| template <> |
| struct ScalarEnumerationTraits<lld::File::Kind> { |
| static void enumeration(IO &io, lld::File::Kind &value) { |
| io.enumCase(value, "object", lld::File::kindObject); |
| io.enumCase(value, "shared-library", lld::File::kindSharedLibrary); |
| io.enumCase(value, "static-library", lld::File::kindArchiveLibrary); |
| } |
| }; |
| |
| template <> |
| struct ScalarEnumerationTraits<lld::Atom::Scope> { |
| static void enumeration(IO &io, lld::Atom::Scope &value) { |
| io.enumCase(value, "global", lld::Atom::scopeGlobal); |
| io.enumCase(value, "hidden", lld::Atom::scopeLinkageUnit); |
| io.enumCase(value, "static", lld::Atom::scopeTranslationUnit); |
| } |
| }; |
| |
| template <> |
| struct ScalarEnumerationTraits<lld::DefinedAtom::SectionChoice> { |
| static void enumeration(IO &io, lld::DefinedAtom::SectionChoice &value) { |
| io.enumCase(value, "content", lld::DefinedAtom::sectionBasedOnContent); |
| io.enumCase(value, "custom", lld::DefinedAtom::sectionCustomPreferred); |
| io.enumCase(value, "custom-required", |
| lld::DefinedAtom::sectionCustomRequired); |
| } |
| }; |
| |
| template <> |
| struct ScalarEnumerationTraits<lld::DefinedAtom::Interposable> { |
| static void enumeration(IO &io, lld::DefinedAtom::Interposable &value) { |
| io.enumCase(value, "no", lld::DefinedAtom::interposeNo); |
| io.enumCase(value, "yes", lld::DefinedAtom::interposeYes); |
| io.enumCase(value, "yes-and-weak", |
| lld::DefinedAtom::interposeYesAndRuntimeWeak); |
| } |
| }; |
| |
| template <> |
| struct ScalarEnumerationTraits<lld::DefinedAtom::Merge> { |
| static void enumeration(IO &io, lld::DefinedAtom::Merge &value) { |
| io.enumCase(value, "no", lld::DefinedAtom::mergeNo); |
| io.enumCase(value, "as-tentative", lld::DefinedAtom::mergeAsTentative); |
| io.enumCase(value, "as-weak", lld::DefinedAtom::mergeAsWeak); |
| io.enumCase(value, "as-addressed-weak", |
| lld::DefinedAtom::mergeAsWeakAndAddressUsed); |
| } |
| }; |
| |
| template <> |
| struct ScalarEnumerationTraits<lld::DefinedAtom::DeadStripKind> { |
| static void enumeration(IO &io, lld::DefinedAtom::DeadStripKind &value) { |
| io.enumCase(value, "normal", lld::DefinedAtom::deadStripNormal); |
| io.enumCase(value, "never", lld::DefinedAtom::deadStripNever); |
| io.enumCase(value, "always", lld::DefinedAtom::deadStripAlways); |
| } |
| }; |
| |
| template <> |
| struct ScalarEnumerationTraits<lld::DefinedAtom::ContentPermissions> { |
| static void enumeration(IO &io, lld::DefinedAtom::ContentPermissions &value) { |
| io.enumCase(value, "---", lld::DefinedAtom::perm___); |
| io.enumCase(value, "r--", lld::DefinedAtom::permR__); |
| io.enumCase(value, "r-x", lld::DefinedAtom::permR_X); |
| io.enumCase(value, "rw-", lld::DefinedAtom::permRW_); |
| io.enumCase(value, "rwx", lld::DefinedAtom::permRWX); |
| io.enumCase(value, "rw-l", lld::DefinedAtom::permRW_L); |
| io.enumCase(value, "unknown", lld::DefinedAtom::permUnknown); |
| } |
| }; |
| |
| template <> |
| struct ScalarEnumerationTraits<lld::DefinedAtom::ContentType> { |
| static void enumeration(IO &io, lld::DefinedAtom::ContentType &value) { |
| io.enumCase(value, "unknown", |
| lld::DefinedAtom::typeUnknown); |
| io.enumCase(value, "code", |
| lld::DefinedAtom::typeCode); |
| io.enumCase(value, "stub", |
| lld::DefinedAtom::typeStub); |
| io.enumCase(value, "constant", |
| lld::DefinedAtom::typeConstant); |
| io.enumCase(value, "data", |
| lld::DefinedAtom::typeData); |
| io.enumCase(value, "zero-fill", |
| lld::DefinedAtom::typeZeroFill); |
| io.enumCase(value, "const-data", |
| lld::DefinedAtom::typeConstData); |
| io.enumCase(value, "got", |
| lld::DefinedAtom::typeGOT); |
| io.enumCase(value, "resolver", |
| lld::DefinedAtom::typeResolver); |
| io.enumCase(value, "branch-island", |
| lld::DefinedAtom::typeBranchIsland); |
| io.enumCase(value, "branch-shim", |
| lld::DefinedAtom::typeBranchShim); |
| io.enumCase(value, "stub-helper", |
| lld::DefinedAtom::typeStubHelper); |
| io.enumCase(value, "c-string", |
| lld::DefinedAtom::typeCString); |
| io.enumCase(value, "utf16-string", |
| lld::DefinedAtom::typeUTF16String); |
| io.enumCase(value, "unwind-cfi", |
| lld::DefinedAtom::typeCFI); |
| io.enumCase(value, "unwind-lsda", |
| lld::DefinedAtom::typeLSDA); |
| io.enumCase(value, "const-4-byte", |
| lld::DefinedAtom::typeLiteral4); |
| io.enumCase(value, "const-8-byte", |
| lld::DefinedAtom::typeLiteral8); |
| io.enumCase(value, "const-16-byte", |
| lld::DefinedAtom::typeLiteral16); |
| io.enumCase(value, "lazy-pointer", |
| lld::DefinedAtom::typeLazyPointer); |
| io.enumCase(value, "lazy-dylib-pointer", |
| lld::DefinedAtom::typeLazyDylibPointer); |
| io.enumCase(value, "cfstring", |
| lld::DefinedAtom::typeCFString); |
| io.enumCase(value, "initializer-pointer", |
| lld::DefinedAtom::typeInitializerPtr); |
| io.enumCase(value, "terminator-pointer", |
| lld::DefinedAtom::typeTerminatorPtr); |
| io.enumCase(value, "c-string-pointer", |
| lld::DefinedAtom::typeCStringPtr); |
| io.enumCase(value, "objc-class-pointer", |
| lld::DefinedAtom::typeObjCClassPtr); |
| io.enumCase(value, "objc-category-list", |
| lld::DefinedAtom::typeObjC2CategoryList); |
| io.enumCase(value, "objc-class1", |
| lld::DefinedAtom::typeObjC1Class); |
| io.enumCase(value, "dtraceDOF", |
| lld::DefinedAtom::typeDTraceDOF); |
| io.enumCase(value, "lto-temp", |
| lld::DefinedAtom::typeTempLTO); |
| io.enumCase(value, "compact-unwind", |
| lld::DefinedAtom::typeCompactUnwindInfo); |
| io.enumCase(value, "tlv-thunk", |
| lld::DefinedAtom::typeThunkTLV); |
| io.enumCase(value, "tlv-data", |
| lld::DefinedAtom::typeTLVInitialData); |
| io.enumCase(value, "tlv-zero-fill", |
| lld::DefinedAtom::typeTLVInitialZeroFill); |
| io.enumCase(value, "tlv-initializer-ptr", |
| lld::DefinedAtom::typeTLVInitializerPtr); |
| io.enumCase(value, "first-in-section", |
| lld::DefinedAtom::typeFirstInSection); |
| io.enumCase(value, "last-in-section", |
| lld::DefinedAtom::typeLastInSection); |
| } |
| }; |
| |
| template <> |
| struct ScalarEnumerationTraits<lld::UndefinedAtom::CanBeNull> { |
| static void enumeration(IO &io, lld::UndefinedAtom::CanBeNull &value) { |
| io.enumCase(value, "never", lld::UndefinedAtom::canBeNullNever); |
| io.enumCase(value, "at-runtime", lld::UndefinedAtom::canBeNullAtRuntime); |
| io.enumCase(value, "at-buildtime", lld::UndefinedAtom::canBeNullAtBuildtime); |
| } |
| }; |
| |
| |
| template <> |
| struct ScalarEnumerationTraits<ShlibCanBeNull> { |
| static void enumeration(IO &io, ShlibCanBeNull &value) { |
| io.enumCase(value, "never", false); |
| io.enumCase(value, "at-runtime", true); |
| } |
| }; |
| |
| |
| |
| /// This is a custom formatter for lld::DefinedAtom::Alignment. Values look |
| /// like: |
| /// 2^3 # 8-byte aligned |
| /// 7 mod 2^4 # 16-byte aligned plus 7 bytes |
| template<> |
| struct ScalarTraits<lld::DefinedAtom::Alignment> { |
| static void output(const lld::DefinedAtom::Alignment &value, void *ctxt, |
| llvm::raw_ostream &out) { |
| if (value.modulus == 0) { |
| out << llvm::format("2^%d", value.powerOf2); |
| } |
| else { |
| out << llvm::format("%d mod 2^%d", value.modulus, value.powerOf2); |
| } |
| } |
| |
| static StringRef input(StringRef scalar, void *ctxt, |
| lld::DefinedAtom::Alignment &value) { |
| value.modulus = 0; |
| size_t modStart = scalar.find("mod"); |
| if (modStart != StringRef::npos) { |
| StringRef modStr = scalar.slice(0, modStart); |
| modStr = modStr.rtrim(); |
| unsigned int modulus; |
| if (modStr.getAsInteger(0, modulus)) { |
| return "malformed alignment modulus"; |
| } |
| value.modulus = modulus; |
| scalar = scalar.drop_front(modStart+3); |
| scalar = scalar.ltrim(); |
| } |
| if (!scalar.startswith("2^")) { |
| return "malformed alignment"; |
| } |
| StringRef powerStr = scalar.drop_front(2); |
| unsigned int power; |
| if (powerStr.getAsInteger(0, power)) { |
| return "malformed alignment power"; |
| } |
| value.powerOf2 = power; |
| if (value.modulus > (1<<value.powerOf2)) { |
| return "malformed alignment, modulus too large for power"; |
| } |
| return StringRef(); // returning empty string means success |
| } |
| }; |
| |
| |
| |
| |
| template <> |
| struct ScalarEnumerationTraits<FileKinds> { |
| static void enumeration(IO &io, FileKinds &value) { |
| io.enumCase(value, "object", fileKindObjectAtoms); |
| io.enumCase(value, "archive", fileKindArchive); |
| io.enumCase(value, "object-elf", fileKindObjectELF); |
| io.enumCase(value, "object-mach-o", fileKindObjectMachO); |
| } |
| }; |
| |
| template <> |
| struct MappingTraits<ArchMember> { |
| static void mapping(IO &io, ArchMember &member) { |
| io.mapOptional("kind", member._kind, fileKindObjectAtoms); |
| io.mapOptional("name", member._name); |
| io.mapRequired("content", member._content); |
| } |
| }; |
| |
| |
| |
| // Declare that an AtomList is a yaml sequence. |
| template<typename T> |
| struct SequenceTraits<AtomList<T>> { |
| static size_t size(IO &io, AtomList<T> &seq) { |
| return seq._atoms.size(); |
| } |
| static const T *&element(IO &io, AtomList<T> &seq, size_t index) { |
| if (index >= seq._atoms.size()) |
| seq._atoms.resize(index+1); |
| return seq._atoms[index]; |
| } |
| }; |
| |
| // Used to allow DefinedAtom content bytes to be a flow sequence of |
| // two-digit hex numbers without the leading 0x (e.g. FF, 04, 0A) |
| template<> |
| struct ScalarTraits<ImplicitHex8> { |
| static void output(const ImplicitHex8 &val, void*, llvm::raw_ostream &out) { |
| uint8_t num = val; |
| out << llvm::format("%02X", num); |
| } |
| |
| static llvm::StringRef input(llvm::StringRef str, void*, ImplicitHex8 &val) { |
| unsigned long long n; |
| if (getAsUnsignedInteger(str, 16, n)) |
| return "invalid two-digit-hex number"; |
| if (n > 0xFF) |
| return "out of range two-digit-hex number"; |
| val = n; |
| return StringRef(); // returning empty string means success |
| } |
| }; |
| |
| |
| // YAML conversion for std::vector<const lld::File*> |
| template<> |
| struct DocumentListTraits< std::vector<const lld::File*> > { |
| static size_t size(IO &io, std::vector<const lld::File*> &seq) { |
| return seq.size(); |
| } |
| static const lld::File *&element(IO &io, std::vector<const lld::File*> &seq, |
| size_t index) { |
| if (index >= seq.size()) |
| seq.resize(index+1); |
| return seq[index]; |
| } |
| }; |
| |
| |
| // YAML conversion for const lld::File* |
| template <> |
| struct MappingTraits<const lld::File*> { |
| |
| class NormArchiveFile : public lld::ArchiveLibraryFile { |
| public: |
| NormArchiveFile(IO &io) : ArchiveLibraryFile(""), _path() { |
| } |
| NormArchiveFile(IO &io, const lld::File *file) |
| : ArchiveLibraryFile(file->path()), |
| _path(file->path()) { |
| // If we want to support writing archives, this constructor would |
| // need to populate _members. |
| } |
| |
| const lld::File *denormalize(IO &io) { |
| return this; |
| } |
| |
| virtual void addAtom(const lld::Atom&) { |
| llvm_unreachable("cannot add atoms to yaml .o files"); |
| } |
| virtual const atom_collection<lld::DefinedAtom> &defined() const { |
| return _noDefinedAtoms; |
| } |
| virtual const atom_collection<lld::UndefinedAtom> &undefined() const { |
| return _noUndefinedAtoms; |
| } |
| virtual const atom_collection<lld::SharedLibraryAtom> &sharedLibrary()const{ |
| return _noSharedLibaryAtoms; |
| } |
| virtual const atom_collection<lld::AbsoluteAtom> &absolute() const { |
| return _noAbsoluteAtoms; |
| } |
| virtual const File *find(StringRef name, bool dataSymbolOnly) const { |
| for (const ArchMember &member : _members) { |
| for (const lld::DefinedAtom *atom : member._content->defined() ) { |
| if (name == atom->name()) { |
| if (!dataSymbolOnly) |
| return member._content; |
| switch (atom->contentType()) { |
| case lld::DefinedAtom::typeData: |
| case lld::DefinedAtom::typeZeroFill: |
| return member._content; |
| default: |
| break; |
| } |
| } |
| } |
| } |
| return nullptr; |
| } |
| |
| StringRef _path; |
| std::vector<ArchMember> _members; |
| }; |
| |
| |
| class NormalizedFile : public lld::File { |
| public: |
| NormalizedFile(IO &io) : File(""), _rnb(nullptr) { |
| } |
| NormalizedFile(IO &io, const lld::File *file) |
| : File(file->path()), |
| _rnb(new RefNameBuilder(*file)), |
| _path(file->path()) { |
| for (const lld::DefinedAtom *a : file->defined()) |
| _definedAtoms.push_back(a); |
| for (const lld::UndefinedAtom *a : file->undefined()) |
| _undefinedAtoms.push_back(a); |
| for (const lld::SharedLibraryAtom *a : file->sharedLibrary()) |
| _sharedLibraryAtoms.push_back(a); |
| for (const lld::AbsoluteAtom *a : file->absolute()) |
| _absoluteAtoms.push_back(a); |
| } |
| const lld::File *denormalize(IO &io); |
| |
| |
| virtual void addAtom(const lld::Atom&) { |
| llvm_unreachable("cannot add atoms to yaml .o files"); |
| } |
| virtual const atom_collection<lld::DefinedAtom> &defined() const { |
| return _definedAtoms; |
| } |
| virtual const atom_collection<lld::UndefinedAtom> &undefined() const { |
| return _undefinedAtoms; |
| } |
| virtual const atom_collection<lld::SharedLibraryAtom> &sharedLibrary()const{ |
| return _sharedLibraryAtoms; |
| } |
| virtual const atom_collection<lld::AbsoluteAtom> &absolute() const { |
| return _absoluteAtoms; |
| } |
| |
| // Allocate a new copy of this string and keep track of allocations |
| // in _stringCopies, so they can be freed when File is destroyed. |
| StringRef copyString(StringRef str) { |
| // We want _stringCopies to own the string memory so it is deallocated |
| // when the File object is destroyed. But we need a StringRef that |
| // points into that memory. |
| std::unique_ptr<char> s = std::unique_ptr<char>(new char[str.size()]); |
| memcpy(s.get(), str.data(), str.size()); |
| llvm::StringRef r = llvm::StringRef(s.get(), str.size()); |
| _stringCopies.push_back(std::move(s)); |
| return r; |
| } |
| |
| RefNameBuilder *_rnb; |
| StringRef _path; |
| AtomList<lld::DefinedAtom> _definedAtoms; |
| AtomList<lld::UndefinedAtom> _undefinedAtoms; |
| AtomList<lld::SharedLibraryAtom> _sharedLibraryAtoms; |
| AtomList<lld::AbsoluteAtom> _absoluteAtoms; |
| std::vector<std::unique_ptr<char>> _stringCopies; |
| }; |
| |
| |
| static void mapping(IO &io, const lld::File *&file) { |
| // We only support writing atom based YAML |
| FileKinds kind = fileKindObjectAtoms; |
| // If reading, peek ahead to see what kind of file this is. |
| io.mapOptional("kind", kind, fileKindObjectAtoms); |
| // |
| switch (kind) { |
| case fileKindObjectAtoms: |
| mappingAtoms(io, file); |
| break; |
| case fileKindArchive: |
| mappingArchive(io, file); |
| break; |
| case fileKindObjectELF: |
| case fileKindObjectMachO: |
| // Eventually we will have an external function to call, similar |
| // to mappingAtoms() and mappingArchive() but implememented |
| // with coresponding file format code. |
| llvm_unreachable("section based YAML not supported yet"); |
| } |
| } |
| |
| static void mappingAtoms(IO &io, const lld::File *&file) { |
| MappingNormalizationHeap<NormalizedFile, const lld::File*> keys(io, file); |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| info->_currentFile = keys.operator->(); |
| |
| io.mapOptional("path", keys->_path); |
| io.mapOptional("defined-atoms", keys->_definedAtoms); |
| io.mapOptional("undefined-atoms", keys->_undefinedAtoms); |
| io.mapOptional("shared-library-atoms", keys->_sharedLibraryAtoms); |
| io.mapOptional("absolute-atoms", keys->_absoluteAtoms); |
| } |
| |
| static void mappingArchive(IO &io, const lld::File *&file) { |
| MappingNormalizationHeap<NormArchiveFile, const lld::File*> keys(io, file); |
| |
| io.mapOptional("path", keys->_path); |
| io.mapOptional("members", keys->_members); |
| } |
| |
| }; |
| |
| |
| |
| // YAML conversion for const lld::Reference* |
| template <> |
| struct MappingTraits<const lld::Reference*> { |
| |
| class NormalizedReference : public lld::Reference { |
| public: |
| NormalizedReference(IO &io) |
| : _target(nullptr), _targetName(), _offset(0), _addend(0) , _kind(0) { |
| } |
| NormalizedReference(IO &io, const lld::Reference *ref) |
| : _target(nullptr), |
| _targetName(targetName(io, ref)), |
| _offset(ref->offsetInAtom()), |
| _addend(ref->addend()), |
| _kind(ref->kind()) { |
| } |
| const lld::Reference *denormalize(IO &io) { |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| typedef MappingTraits<const lld::File*>::NormalizedFile NormalizedFile; |
| NormalizedFile *f = reinterpret_cast<NormalizedFile*>(info->_currentFile); |
| if (!_targetName.empty()) |
| _targetName = f->copyString(_targetName); |
| DEBUG_WITH_TYPE("WriterYAML", llvm::dbgs() |
| << "created Reference to name: '" << _targetName |
| << "' (" << (void*)_targetName.data() << ", " |
| << _targetName.size() << ")\n"); |
| return this; |
| } |
| void bind(const RefNameResolver&); |
| static StringRef targetName(IO &io, const lld::Reference *ref); |
| |
| virtual uint64_t offsetInAtom() const { return _offset; } |
| virtual Kind kind() const { return _kind; } |
| virtual const lld::Atom *target() const { return _target; } |
| virtual Addend addend() const { return _addend; } |
| virtual void setKind(Kind k) { _kind = k; } |
| virtual void setAddend(Addend a) { _addend = a; } |
| virtual void setTarget(const lld::Atom *a) { _target = a; } |
| |
| const lld::Atom *_target; |
| StringRef _targetName; |
| uint32_t _offset; |
| Addend _addend; |
| RefKind _kind; |
| }; |
| |
| |
| static void mapping(IO &io, const lld::Reference *&ref) { |
| MappingNormalizationHeap<NormalizedReference, |
| const lld::Reference*> keys(io, ref); |
| |
| io.mapRequired("kind", keys->_kind); |
| io.mapOptional("offset", keys->_offset); |
| io.mapOptional("target", keys->_targetName); |
| io.mapOptional("addend", keys->_addend, (lld::Reference::Addend)0); |
| } |
| }; |
| |
| |
| |
| // YAML conversion for const lld::DefinedAtom* |
| template <> |
| struct MappingTraits<const lld::DefinedAtom*> { |
| |
| class NormalizedAtom : public lld::DefinedAtom { |
| public: |
| NormalizedAtom(IO &io) |
| : _file(fileFromContext(io)), _name(), _refName(), |
| _alignment(0), _content(), _references() { |
| } |
| NormalizedAtom(IO &io, const lld::DefinedAtom *atom) |
| : _file(fileFromContext(io)), |
| _name(atom->name()), |
| _refName(), |
| _scope(atom->scope()), |
| _interpose(atom->interposable()), |
| _merge(atom->merge()), |
| _contentType(atom->contentType()), |
| _alignment(atom->alignment()), |
| _sectionChoice(atom->sectionChoice()), |
| _deadStrip(atom->deadStrip()), |
| _permissions(atom->permissions()), |
| _size(atom->size()), |
| _sectionName(atom->customSectionName()) { |
| for ( const lld::Reference *r : *atom ) |
| _references.push_back(r); |
| ArrayRef<uint8_t> cont = atom->rawContent(); |
| _content.reserve(cont.size()); |
| for (uint8_t x : cont) |
| _content.push_back(x); |
| } |
| const lld::DefinedAtom *denormalize(IO &io) { |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| typedef MappingTraits<const lld::File*>::NormalizedFile NormalizedFile; |
| NormalizedFile *f = reinterpret_cast<NormalizedFile*>(info->_currentFile); |
| if ( !_name.empty() ) |
| _name = f->copyString(_name); |
| if ( !_refName.empty() ) |
| _refName = f->copyString(_refName); |
| if ( !_sectionName.empty() ) |
| _sectionName = f->copyString(_sectionName); |
| DEBUG_WITH_TYPE("WriterYAML", llvm::dbgs() |
| << "created DefinedAtom named: '" << _name |
| << "' (" << (void*)_name.data() << ", " |
| << _name.size() << ")\n"); |
| return this; |
| } |
| void bind(const RefNameResolver&); |
| // Extract current File object from YAML I/O parsing context |
| const lld::File &fileFromContext(IO &io) { |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| assert(info->_currentFile != nullptr); |
| return *info->_currentFile; |
| } |
| |
| virtual const lld::File &file() const { return _file; } |
| virtual StringRef name() const { return _name; } |
| virtual uint64_t size() const { return _size; } |
| virtual Scope scope() const { return _scope; } |
| virtual Interposable interposable() const { return _interpose; } |
| virtual Merge merge() const { return _merge; } |
| virtual ContentType contentType() const { return _contentType; } |
| virtual Alignment alignment() const { return _alignment; } |
| virtual SectionChoice sectionChoice() const { return _sectionChoice; } |
| virtual StringRef customSectionName() const { return _sectionName;} |
| virtual DeadStripKind deadStrip() const { return _deadStrip; } |
| virtual ContentPermissions permissions() const { return _permissions; } |
| virtual bool isThumb() const { return false; } |
| virtual bool isAlias() const { return false; } |
| ArrayRef<uint8_t> rawContent() const { |
| return ArrayRef<uint8_t>((uint8_t*)&_content.operator[](0), |
| _content.size()); } |
| virtual uint64_t ordinal() const { return 0; } |
| |
| reference_iterator begin() const { |
| uintptr_t index = 0; |
| const void *it = reinterpret_cast<const void*>(index); |
| return reference_iterator(*this, it); |
| } |
| reference_iterator end() const { |
| uintptr_t index = _references.size(); |
| const void *it = reinterpret_cast<const void*>(index); |
| return reference_iterator(*this, it); |
| } |
| const lld::Reference *derefIterator(const void *it) const { |
| uintptr_t index = reinterpret_cast<uintptr_t>(it); |
| assert(index < _references.size()); |
| return _references[index]; |
| } |
| void incrementIterator(const void *&it) const { |
| uintptr_t index = reinterpret_cast<uintptr_t>(it); |
| ++index; |
| it = reinterpret_cast<const void*>(index); |
| } |
| |
| const lld::File &_file; |
| StringRef _name; |
| StringRef _refName; |
| Scope _scope; |
| Interposable _interpose; |
| Merge _merge; |
| ContentType _contentType; |
| Alignment _alignment; |
| SectionChoice _sectionChoice; |
| DeadStripKind _deadStrip; |
| ContentPermissions _permissions; |
| std::vector<ImplicitHex8> _content; |
| uint64_t _size; |
| StringRef _sectionName; |
| std::vector<const lld::Reference*> _references; |
| }; |
| |
| static void mapping(IO &io, const lld::DefinedAtom *&atom) { |
| MappingNormalizationHeap<NormalizedAtom, |
| const lld::DefinedAtom*> keys(io, atom); |
| if ( io.outputting() ) { |
| // If writing YAML, check if atom needs a ref-name. |
| typedef MappingTraits<const lld::File*>::NormalizedFile NormalizedFile; |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| NormalizedFile *f = reinterpret_cast<NormalizedFile*>(info->_currentFile); |
| assert(f); |
| assert(f->_rnb); |
| if ( f->_rnb->hasRefName(atom) ) { |
| keys->_refName = f->_rnb->refName(atom); |
| } |
| } |
| |
| io.mapOptional("name", keys->_name, |
| StringRef()); |
| io.mapOptional("ref-name", keys->_refName, |
| StringRef()); |
| io.mapOptional("scope", keys->_scope, |
| lld::DefinedAtom::scopeTranslationUnit); |
| io.mapOptional("type", keys->_contentType, |
| lld::DefinedAtom::typeCode); |
| io.mapOptional("content", keys->_content); |
| io.mapOptional("size", keys->_size, |
| (uint64_t)keys->_content.size()); |
| io.mapOptional("interposable", keys->_interpose, |
| lld::DefinedAtom::interposeNo); |
| io.mapOptional("merge", keys->_merge, |
| lld::DefinedAtom::mergeNo); |
| io.mapOptional("alignment", keys->_alignment, |
| lld::DefinedAtom::Alignment(0)); |
| io.mapOptional("section-choice", keys->_sectionChoice, |
| lld::DefinedAtom::sectionBasedOnContent); |
| io.mapOptional("section-name", keys->_sectionName, |
| StringRef()); |
| io.mapOptional("dead-strip", keys->_deadStrip, |
| lld::DefinedAtom::deadStripNormal); |
| // default permissions based on content type |
| io.mapOptional("permissions", keys->_permissions, |
| lld::DefinedAtom::permissions( |
| keys->_contentType)); |
| io.mapOptional("references", keys->_references); |
| } |
| }; |
| |
| |
| |
| |
| // YAML conversion for const lld::UndefinedAtom* |
| template <> |
| struct MappingTraits<const lld::UndefinedAtom*> { |
| |
| class NormalizedAtom : public lld::UndefinedAtom { |
| public: |
| NormalizedAtom(IO &io) |
| : _file(fileFromContext(io)), _name(), _canBeNull(canBeNullNever) { |
| } |
| NormalizedAtom(IO &io, const lld::UndefinedAtom *atom) |
| : _file(fileFromContext(io)), |
| _name(atom->name()), |
| _canBeNull(atom->canBeNull()) { |
| } |
| const lld::UndefinedAtom *denormalize(IO &io) { |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| typedef MappingTraits<const lld::File*>::NormalizedFile NormalizedFile; |
| NormalizedFile *f = reinterpret_cast<NormalizedFile*>(info->_currentFile); |
| if ( !_name.empty() ) |
| _name = f->copyString(_name); |
| |
| DEBUG_WITH_TYPE("WriterYAML", llvm::dbgs() |
| << "created UndefinedAtom named: '" << _name |
| << "' (" << (void*)_name.data() << ", " |
| << _name.size() << ")\n"); |
| return this; |
| } |
| // Extract current File object from YAML I/O parsing context |
| const lld::File &fileFromContext(IO &io) { |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| assert(info->_currentFile != nullptr); |
| return *info->_currentFile; |
| } |
| |
| virtual const lld::File &file() const { return _file; } |
| virtual StringRef name() const { return _name; } |
| virtual CanBeNull canBeNull() const { return _canBeNull; } |
| |
| const lld::File &_file; |
| StringRef _name; |
| CanBeNull _canBeNull; |
| }; |
| |
| |
| static void mapping(IO &io, const lld::UndefinedAtom* &atom) { |
| MappingNormalizationHeap<NormalizedAtom, |
| const lld::UndefinedAtom*> keys(io, atom); |
| |
| io.mapRequired("name", keys->_name); |
| io.mapOptional("can-be-null", keys->_canBeNull, |
| lld::UndefinedAtom::canBeNullNever); |
| } |
| }; |
| |
| |
| // YAML conversion for const lld::SharedLibraryAtom* |
| template <> |
| struct MappingTraits<const lld::SharedLibraryAtom*> { |
| |
| class NormalizedAtom : public lld::SharedLibraryAtom { |
| public: |
| NormalizedAtom(IO &io) |
| : _file(fileFromContext(io)), _name(), _loadName(), _canBeNull(false) { |
| } |
| NormalizedAtom(IO &io, const lld::SharedLibraryAtom *atom) |
| : _file(fileFromContext(io)), |
| _name(atom->name()), |
| _loadName(atom->loadName()), |
| _canBeNull(atom->canBeNullAtRuntime()) { |
| } |
| const lld::SharedLibraryAtom *denormalize(IO &io) { |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| typedef MappingTraits<const lld::File*>::NormalizedFile NormalizedFile; |
| NormalizedFile *f = reinterpret_cast<NormalizedFile*>(info->_currentFile); |
| if ( !_name.empty() ) |
| _name = f->copyString(_name); |
| if ( !_loadName.empty() ) |
| _loadName = f->copyString(_loadName); |
| |
| DEBUG_WITH_TYPE("WriterYAML", llvm::dbgs() |
| << "created SharedLibraryAtom named: '" << _name |
| << "' (" << (void*)_name.data() << ", " |
| << _name.size() << ")\n"); |
| return this; |
| } |
| // Extract current File object from YAML I/O parsing context |
| const lld::File &fileFromContext(IO &io) { |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| assert(info->_currentFile != nullptr); |
| return *info->_currentFile; |
| } |
| |
| virtual const lld::File &file() const { return _file; } |
| virtual StringRef name() const { return _name; } |
| virtual StringRef loadName() const { return _loadName;} |
| virtual bool canBeNullAtRuntime() const { return _canBeNull; } |
| |
| const lld::File &_file; |
| StringRef _name; |
| StringRef _loadName; |
| ShlibCanBeNull _canBeNull; |
| }; |
| |
| |
| static void mapping(IO &io, const lld::SharedLibraryAtom *&atom) { |
| |
| MappingNormalizationHeap<NormalizedAtom, |
| const lld::SharedLibraryAtom*> keys(io, atom); |
| |
| io.mapRequired("name", keys->_name); |
| io.mapOptional("load-name", keys->_loadName); |
| io.mapOptional("can-be-null", keys->_canBeNull, |
| (ShlibCanBeNull)false); |
| } |
| }; |
| |
| |
| // YAML conversion for const lld::AbsoluteAtom* |
| template <> |
| struct MappingTraits<const lld::AbsoluteAtom*> { |
| |
| class NormalizedAtom : public lld::AbsoluteAtom { |
| public: |
| NormalizedAtom(IO &io) |
| : _file(fileFromContext(io)), _name(), _scope(), _value(0) { |
| } |
| NormalizedAtom(IO &io, const lld::AbsoluteAtom *atom) |
| : _file(fileFromContext(io)), |
| _name(atom->name()), |
| _scope(atom->scope()), |
| _value(atom->value()) { |
| } |
| const lld::AbsoluteAtom *denormalize(IO &io) { |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| typedef MappingTraits<const lld::File*>::NormalizedFile NormalizedFile; |
| NormalizedFile *f = reinterpret_cast<NormalizedFile*>(info->_currentFile); |
| if ( !_name.empty() ) |
| _name = f->copyString(_name); |
| |
| DEBUG_WITH_TYPE("WriterYAML", llvm::dbgs() |
| << "created AbsoluteAtom named: '" << _name |
| << "' (" << (void*)_name.data() << ", " |
| << _name.size() << ")\n"); |
| return this; |
| } |
| // Extract current File object from YAML I/O parsing context |
| const lld::File &fileFromContext(IO &io) { |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| assert(info->_currentFile != nullptr); |
| return *info->_currentFile; |
| } |
| |
| virtual const lld::File &file() const { return _file; } |
| virtual StringRef name() const { return _name; } |
| virtual uint64_t value() const { return _value; } |
| virtual Scope scope() const { return _scope; } |
| |
| const lld::File &_file; |
| StringRef _name; |
| StringRef _refName; |
| Scope _scope; |
| Hex64 _value; |
| }; |
| |
| |
| static void mapping(IO &io, const lld::AbsoluteAtom *&atom) { |
| MappingNormalizationHeap<NormalizedAtom, |
| const lld::AbsoluteAtom*> keys(io, atom); |
| |
| if ( io.outputting() ) { |
| typedef MappingTraits<const lld::File*>::NormalizedFile NormalizedFile; |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| NormalizedFile *f = reinterpret_cast<NormalizedFile*>(info->_currentFile); |
| assert(f); |
| assert(f->_rnb); |
| if ( f->_rnb->hasRefName(atom) ) { |
| keys->_refName = f->_rnb->refName(atom); |
| } |
| } |
| |
| io.mapRequired("name", keys->_name); |
| io.mapOptional("ref-name", keys->_refName, StringRef()); |
| io.mapOptional("scope", keys->_scope); |
| io.mapRequired("value", keys->_value); |
| } |
| }; |
| |
| } // namespace llvm |
| } // namespace yaml |
| |
| |
| RefNameResolver::RefNameResolver(const lld::File *file, IO &io) : _io(io) { |
| typedef MappingTraits<const lld::DefinedAtom*>::NormalizedAtom NormalizedAtom; |
| for (const lld::DefinedAtom *a : file->defined() ) { |
| NormalizedAtom *na = (NormalizedAtom*)a; |
| if ( na->_refName.empty() ) |
| add(na->_name, a); |
| else |
| add(na->_refName, a); |
| } |
| |
| for (const lld::UndefinedAtom *a : file->undefined() ) |
| add(a->name(), a); |
| |
| for (const lld::SharedLibraryAtom *a : file->sharedLibrary() ) |
| add(a->name(), a); |
| |
| typedef MappingTraits<const lld::AbsoluteAtom*>::NormalizedAtom NormAbsAtom; |
| for (const lld::AbsoluteAtom *a : file->absolute() ) { |
| NormAbsAtom *na = (NormAbsAtom*)a; |
| if ( na->_refName.empty() ) |
| add(na->_name, a); |
| else |
| add(na->_refName, a); |
| } |
| } |
| |
| |
| |
| inline |
| const lld::File* |
| MappingTraits<const lld::File*>::NormalizedFile::denormalize(IO &io) { |
| typedef MappingTraits<const lld::DefinedAtom*>::NormalizedAtom NormalizedAtom; |
| |
| RefNameResolver nameResolver(this, io); |
| // Now that all atoms are parsed, references can be bound. |
| for (const lld::DefinedAtom *a : this->defined() ) { |
| NormalizedAtom *normAtom = (NormalizedAtom*)a; |
| normAtom->bind(nameResolver); |
| } |
| return this; |
| } |
| |
| inline |
| void MappingTraits<const lld::DefinedAtom*>:: |
| NormalizedAtom::bind(const RefNameResolver &resolver) { |
| typedef MappingTraits<const lld::Reference*>::NormalizedReference |
| NormalizedReference; |
| for (const lld::Reference *ref : _references) { |
| NormalizedReference *normRef = (NormalizedReference*)ref; |
| normRef->bind(resolver); |
| } |
| } |
| |
| inline |
| void MappingTraits<const lld::Reference*>:: |
| NormalizedReference::bind(const RefNameResolver &resolver) { |
| _target = resolver.lookup(_targetName); |
| } |
| |
| |
| inline |
| llvm::StringRef MappingTraits<const lld::Reference*>::NormalizedReference:: |
| targetName(IO &io, const lld::Reference *ref) { |
| if ( ref->target() == nullptr ) |
| return llvm::StringRef(); |
| ContextInfo *info = reinterpret_cast<ContextInfo*>(io.getContext()); |
| assert(info != nullptr); |
| typedef MappingTraits<const lld::File*>::NormalizedFile NormalizedFile; |
| NormalizedFile *f = reinterpret_cast<NormalizedFile*>(info->_currentFile); |
| RefNameBuilder *rnb = f->_rnb; |
| if ( rnb->hasRefName(ref->target()) ) |
| return rnb->refName(ref->target()); |
| return ref->target()->name(); |
| } |
| |
| |
| |
| namespace lld { |
| namespace yaml { |
| |
| class Writer : public lld::Writer { |
| public: |
| Writer(const WriterOptionsYAML &options) : _options(options) { |
| } |
| |
| virtual error_code writeFile(const lld::File &file, StringRef outPath) { |
| // Create stream to path. |
| std::string errorInfo; |
| llvm::raw_fd_ostream out(outPath.data(), errorInfo); |
| if (!errorInfo.empty()) |
| return llvm::make_error_code(llvm::errc::no_such_file_or_directory); |
| |
| // Create yaml Output writer, using yaml options for context. |
| ContextInfo context(_options); |
| llvm::yaml::Output yout(out, &context); |
| |
| // Write yaml output. |
| const lld::File *fileRef = &file; |
| yout << fileRef; |
| |
| return error_code::success(); |
| } |
| |
| virtual StubsPass *stubPass() { |
| return _options.stubPass(); |
| } |
| |
| virtual GOTPass *gotPass() { |
| return _options.gotPass(); |
| } |
| |
| |
| private: |
| const WriterOptionsYAML &_options; |
| }; |
| |
| |
| |
| class ReaderYAML : public Reader { |
| public: |
| ReaderYAML(const ReaderOptionsYAML &options) : _options(options) { |
| } |
| |
| error_code parseFile(std::unique_ptr<MemoryBuffer> mb, |
| std::vector<std::unique_ptr<File>> &result) { |
| // Note: we do not take ownership of the MemoryBuffer. That is |
| // because yaml may produce multiple File objects, so there is no |
| // *one* File to take ownership. Therefore, the yaml File objects |
| // produced must make copies of all strings that come from YAML I/O. |
| // Otherwise the strings will become invalid when this MemoryBuffer |
| // is deallocated. |
| |
| // Create YAML Input parser. |
| ContextInfo context(_options); |
| llvm::yaml::Input yin(mb->getBuffer(), &context); |
| |
| // Fill vector with File objects created by parsing yaml. |
| std::vector<const lld::File*> createdFiles; |
| yin >> createdFiles; |
| |
| // Quit now if there were parsing errors. |
| if ( yin.error() ) |
| return make_error_code(lld::yaml_reader_error::illegal_value); |
| |
| for (const File *file : createdFiles) { |
| // Note: parseFile() should return vector of *const* File |
| File *f = const_cast<File*>(file); |
| result.emplace_back(f); |
| } |
| return make_error_code(lld::yaml_reader_error::success); |
| } |
| |
| private: |
| const ReaderOptionsYAML &_options; |
| }; |
| |
| |
| |
| } // namespace yaml |
| |
| |
| Writer *createWriterYAML(const WriterOptionsYAML &options) { |
| return new lld::yaml::Writer(options); |
| } |
| |
| WriterOptionsYAML::WriterOptionsYAML() { |
| } |
| |
| WriterOptionsYAML::~WriterOptionsYAML() { |
| } |
| |
| |
| |
| Reader *createReaderYAML(const ReaderOptionsYAML &options) { |
| return new lld::yaml::ReaderYAML(options); |
| } |
| |
| ReaderOptionsYAML::ReaderOptionsYAML() { |
| } |
| |
| ReaderOptionsYAML::~ReaderOptionsYAML() { |
| } |
| |
| |
| } // namespace lld |
| |