[llvm-commits] [lld] r171592 - in /lld/trunk: include/lld/Core/ include/lld/ReaderWriter/ lib/Core/ lib/ReaderWriter/YAML/ test/ test/darwin/ test/elf/
Nick Kledzik
kledzik at apple.com
Fri Jan 4 18:22:36 PST 2013
Author: kledzik
Date: Fri Jan 4 20:22:35 2013
New Revision: 171592
URL: http://llvm.org/viewvc/llvm-project?rev=171592&view=rev
Log:
Removes files for separate ReaderYAML.cpp and WriterYAML.cpp
and adds a new file ReaderWriterYAML.cpp that uses YAML I/O.
Lots of tweaks to test suite for slightly different YAML encoding.
Added:
lld/trunk/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp
Removed:
lld/trunk/lib/ReaderWriter/YAML/ReaderYAML.cpp
lld/trunk/lib/ReaderWriter/YAML/WriterYAML.cpp
lld/trunk/lib/ReaderWriter/YAML/YamlKeyValues.cpp
lld/trunk/lib/ReaderWriter/YAML/YamlKeyValues.h
Modified:
lld/trunk/include/lld/Core/DefinedAtom.h
lld/trunk/include/lld/Core/File.h
lld/trunk/include/lld/ReaderWriter/ReaderArchive.h
lld/trunk/lib/Core/File.cpp
lld/trunk/lib/ReaderWriter/YAML/CMakeLists.txt
lld/trunk/test/absolute-basic.objtxt
lld/trunk/test/absolute-local.objtxt
lld/trunk/test/archive-basic.objtxt
lld/trunk/test/archive-chain.objtxt
lld/trunk/test/archive-tentdef-search.objtxt
lld/trunk/test/auto-hide-coalesce.objtxt
lld/trunk/test/cstring-coalesce.objtxt
lld/trunk/test/custom-section.objtxt
lld/trunk/test/darwin/hello-world.objtxt
lld/trunk/test/dead-strip-attributes.objtxt
lld/trunk/test/dead-strip-basic.objtxt
lld/trunk/test/dead-strip-globals.objtxt
lld/trunk/test/elf/abs.objtxt
lld/trunk/test/elf/archive-elf-forceload.objtxt
lld/trunk/test/elf/archive-elf.objtxt
lld/trunk/test/elf/branch.objtxt
lld/trunk/test/elf/check.objtxt
lld/trunk/test/elf/reloc.objtxt
lld/trunk/test/elf/x86.objtxt
lld/trunk/test/error-atom-attribute.objtxt
lld/trunk/test/error-atom-content-byte-value.objtxt
lld/trunk/test/error-atom-content-bytes.objtxt
lld/trunk/test/error-atom-type.objtxt
lld/trunk/test/error-atom-undefined-wrong-attribue.objtxt
lld/trunk/test/error-file-attribute.objtxt
lld/trunk/test/error-fixup-attribute.objtxt
lld/trunk/test/error-fixup-target.objtxt
lld/trunk/test/fixups-addend.objtxt
lld/trunk/test/fixups-dup-named.objtxt
lld/trunk/test/fixups-named.objtxt
lld/trunk/test/fixups-unnamed.objtxt
lld/trunk/test/inline-coalesce.objtxt
lld/trunk/test/multiple-def-error.objtxt
lld/trunk/test/pass-got-basic.objtxt
lld/trunk/test/pass-stubs-basic.objtxt
lld/trunk/test/shared-library-basic.objtxt
lld/trunk/test/shared-library-coalesce.objtxt
lld/trunk/test/tent-merge.objtxt
lld/trunk/test/undef-coalesce-error.objtxt
lld/trunk/test/undef-coalesce.objtxt
lld/trunk/test/undef-weak-coalesce.objtxt
lld/trunk/test/weak-coalesce.objtxt
Modified: lld/trunk/include/lld/Core/DefinedAtom.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/include/lld/Core/DefinedAtom.h?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/include/lld/Core/DefinedAtom.h (original)
+++ lld/trunk/include/lld/Core/DefinedAtom.h Fri Jan 4 20:22:35 2013
@@ -173,6 +173,10 @@
uint16_t powerOf2;
uint16_t modulus;
+
+ bool operator==(const Alignment &rhs) const {
+ return (powerOf2 == rhs.powerOf2) && (modulus == rhs.modulus);
+ }
};
/// \brief returns a value for the order of this Atom within its file.
Modified: lld/trunk/include/lld/Core/File.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/include/lld/Core/File.h?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/include/lld/Core/File.h (original)
+++ lld/trunk/include/lld/Core/File.h Fri Jan 4 20:22:35 2013
@@ -16,6 +16,7 @@
#include "lld/Core/UndefinedAtom.h"
#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorHandling.h"
#include <vector>
@@ -66,9 +67,8 @@
return true;
}
-protected:
- template <typename T> class atom_iterator; // forward reference
public:
+ template <typename T> class atom_iterator; // forward reference
/// For use interating over DefinedAtoms in this File.
typedef atom_iterator<DefinedAtom> defined_iterator;
@@ -91,10 +91,6 @@
/// call this method when no longer iterating over the File's Atoms.
virtual void addAtom(const Atom&) = 0;
-protected:
- /// only subclasses of File can be instantiated
- File(StringRef p) : _path(p) {}
-
/// Different object file readers may instantiate and manage atoms with
/// different data structures. This class is a collection abstraction.
/// Each concrete File instance must implement these atom_collection
@@ -105,8 +101,8 @@
virtual ~atom_collection() { }
virtual atom_iterator<T> begin() const = 0;
virtual atom_iterator<T> end() const = 0;
- virtual const T* deref(const void* it) const = 0;
- virtual void next(const void*& it) const = 0;
+ virtual const T *deref(const void *it) const = 0;
+ virtual void next(const void *&it) const = 0;
};
/// The class is the iterator type used to iterate through a File's Atoms.
@@ -140,7 +136,7 @@
const void* _it;
};
-public:
+
/// Must be implemented to return the atom_collection object for
/// all DefinedAtoms in this File.
virtual const atom_collection<DefinedAtom>& defined() const = 0;
@@ -158,6 +154,10 @@
virtual const atom_collection<AbsoluteAtom>& absolute() const = 0;
protected:
+ /// only subclasses of File can be instantiated
+ File(StringRef p) : _path(p) {}
+
+
/// This is a convenience class for File subclasses which manage their
/// atoms as a simple std::vector<>.
template <typename T>
@@ -182,6 +182,32 @@
std::vector<const T*> _atoms;
};
+ /// This is a convenience class for File subclasses which need to return
+ /// an empty collection
+ template <typename T>
+ class atom_collection_empty : public atom_collection<T> {
+ public:
+ virtual atom_iterator<T> begin() const {
+ return atom_iterator<T>(*this, nullptr);
+ }
+ virtual atom_iterator<T> end() const{
+ return atom_iterator<T>(*this, nullptr);
+ }
+ virtual const T *deref(const void *it) const {
+ llvm_unreachable("empty collection should never be accessed");
+ }
+ virtual void next(const void *&it) const {
+ }
+ virtual void push_back(const T *element) {
+ llvm_unreachable("empty collection should never be grown");
+ }
+ };
+
+ static atom_collection_empty<DefinedAtom> _noDefinedAtoms;
+ static atom_collection_empty<UndefinedAtom> _noUndefinedAtoms;
+ static atom_collection_empty<SharedLibraryAtom> _noSharedLibaryAtoms;
+ static atom_collection_empty<AbsoluteAtom> _noAbsoluteAtoms;
+
StringRef _path;
};
} // namespace lld
Modified: lld/trunk/include/lld/ReaderWriter/ReaderArchive.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/include/lld/ReaderWriter/ReaderArchive.h?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/include/lld/ReaderWriter/ReaderArchive.h (original)
+++ lld/trunk/include/lld/ReaderWriter/ReaderArchive.h Fri Jan 4 20:22:35 2013
@@ -56,7 +56,7 @@
};
/// \brief ReaderArchive is a class for reading archive libraries
-class ReaderArchive {
+class ReaderArchive : public Reader {
public:
ReaderArchive(const ReaderOptionsArchive &options)
: _options(options)
Modified: lld/trunk/lib/Core/File.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/Core/File.cpp?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/lib/Core/File.cpp (original)
+++ lld/trunk/lib/Core/File.cpp Fri Jan 4 20:22:35 2013
@@ -18,4 +18,10 @@
return StringRef();
}
+
+File::atom_collection_empty<DefinedAtom> File::_noDefinedAtoms;
+File::atom_collection_empty<UndefinedAtom> File::_noUndefinedAtoms;
+File::atom_collection_empty<SharedLibraryAtom> File::_noSharedLibaryAtoms;
+File::atom_collection_empty<AbsoluteAtom> File::_noAbsoluteAtoms;
+
}
Modified: lld/trunk/lib/ReaderWriter/YAML/CMakeLists.txt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/YAML/CMakeLists.txt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/YAML/CMakeLists.txt (original)
+++ lld/trunk/lib/ReaderWriter/YAML/CMakeLists.txt Fri Jan 4 20:22:35 2013
@@ -1,7 +1,5 @@
add_lld_library(lldYAML
- YamlKeyValues.cpp
- ReaderYAML.cpp
- WriterYAML.cpp
+ ReaderWriterYAML.cpp
)
target_link_libraries(lldYAML
Added: lld/trunk/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp?rev=171592&view=auto
==============================================================================
--- lld/trunk/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp (added)
+++ lld/trunk/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp Fri Jan 4 20:22:35 2013
@@ -0,0 +1,1357 @@
+//===- 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
+
+
+// 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);
+ }
+};
+
+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, "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);
+ }
+};
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(ArchMember);
+
+
+// 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
+ }
+};
+
+// Always write DefinedAtoms content bytes as a flow sequence.
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(ImplicitHex8);
+
+
+// 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.
+ default:
+ 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);
+ }
+};
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(const lld::Reference*)
+
+
+// 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);
+ io.mapOptional("permissions", keys->_permissions,
+ lld::DefinedAtom::permR_X);
+ io.mapOptional("fixups", keys->_references);
+ }
+};
+
+
+
+
+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);
+}
+
+
+
+// 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);
+ }
+};
+
+
+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
+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
+
Removed: lld/trunk/lib/ReaderWriter/YAML/ReaderYAML.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/YAML/ReaderYAML.cpp?rev=171591&view=auto
==============================================================================
--- lld/trunk/lib/ReaderWriter/YAML/ReaderYAML.cpp (original)
+++ lld/trunk/lib/ReaderWriter/YAML/ReaderYAML.cpp (removed)
@@ -1,1264 +0,0 @@
-//===- lib/ReaderWriter/YAML/ReaderYAML.cpp - Reads YAML object files -----===//
-//
-// The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lld/ReaderWriter/ReaderYAML.h"
-
-#include "lld/Core/AbsoluteAtom.h"
-#include "lld/Core/ArchiveLibraryFile.h"
-#include "lld/Core/Atom.h"
-#include "lld/Core/Error.h"
-#include "lld/Core/File.h"
-#include "lld/Core/LLVM.h"
-#include "lld/Core/Reference.h"
-#include "lld/Core/SharedLibraryAtom.h"
-#include "lld/Core/UndefinedAtom.h"
-
-#include "llvm/ADT/APInt.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/OwningPtr.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
-#include "llvm/Support/DataTypes.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/raw_ostream.h"
-#include "llvm/Support/SourceMgr.h"
-#include "llvm/Support/system_error.h"
-#include "llvm/Support/YAMLParser.h"
-
-#include <cstring>
-#include <vector>
-
-#include "YamlKeyValues.h"
-
-
-namespace lld {
-namespace yaml {
-
-
-///
-/// Concrete instance of lld::Reference created parsing YAML object files
-///
-class YAMLReference : public Reference {
-public:
- YAMLReference()
- : _target(nullptr)
- , _targetNameNode(nullptr)
- , _offsetInAtom(0)
- , _addend(0)
- , _kind(0)
- {}
-
- virtual uint64_t offsetInAtom() const {
- return _offsetInAtom;
- }
-
- virtual Kind kind() const {
- return _kind;
- }
-
- virtual void setKind(Kind k) {
- _kind = k;
- }
-
- virtual const Atom *target() const {
- return _target;
- }
-
- virtual Addend addend() const {
- return _addend;
- }
-
- virtual void setAddend(Addend a) {
- _addend = a;
- }
-
- virtual void setTarget(const Atom *newAtom) {
- _target = newAtom;
- }
-
- typedef llvm::yaml::ScalarNode ScalarNode;
-
- const Atom *_target;
- ScalarNode * _targetNameNode;
- uint64_t _offsetInAtom;
- Addend _addend;
- Kind _kind;
-};
-
-
-///
-/// Concrete instance of lld::File created parsing YAML object files.
-///
-class YAMLFile : public ArchiveLibraryFile {
-public:
- YAMLFile()
- : ArchiveLibraryFile("<anonymous>")
- , _lastRefIndex(0)
- , _kind(File::kindObject) {
- }
-
- ~YAMLFile();
-
- // Depending on the YAML description, this file can be either an
- // lld::ArchiveLibraryFile or lld::File.
- virtual File::Kind kind() const {
- return _kind;
- }
-
- virtual const atom_collection<DefinedAtom> &defined() const {
- return _definedAtoms;
- }
- virtual const atom_collection<UndefinedAtom> &undefined() const {
- return _undefinedAtoms;
- }
- virtual const atom_collection<SharedLibraryAtom> &sharedLibrary() const {
- return _sharedLibraryAtoms;
- }
- virtual const atom_collection<AbsoluteAtom> &absolute() const {
- return _absoluteAtoms;
- }
-
- virtual void addAtom(const Atom&) {
- assert(0 && "cannot add atoms to YAML files");
- }
-
- // Standard way that archives are searched.
- virtual const File *find(StringRef name, bool dataSymbolOnly) const;
-
- error_code bindTargetReferences(llvm::yaml::Stream &stream);
-
- void addDefinedAtom(class YAMLDefinedAtom *atom, StringRef refName);
- void addUndefinedAtom(UndefinedAtom *atom);
- void addSharedLibraryAtom(SharedLibraryAtom *atom);
- void addAbsoluteAtom(AbsoluteAtom *atom);
- Atom *findAtom(StringRef name);
- void addMember(StringRef);
- void setName(StringRef);
-
- StringRef copyString(StringRef);
-
- struct NameAtomPair {
- NameAtomPair(StringRef n, Atom *a) : name(n), atom(a) {}
- StringRef name;
- Atom *atom;
- };
-
- atom_collection_vector<DefinedAtom> _definedAtoms;
- atom_collection_vector<UndefinedAtom> _undefinedAtoms;
- atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
- atom_collection_vector<AbsoluteAtom> _absoluteAtoms;
- std::vector<YAMLReference> _references;
- std::vector<NameAtomPair> _nameToAtomMapping;
- std::vector<std::unique_ptr<YAMLFile>> _memberFiles;
- std::vector<char*> _stringCopies;
- unsigned int _lastRefIndex;
- File::Kind _kind;
-};
-
-
-
-///
-/// Concrete instance of lld::DefinedAtom created parsing YAML object files.
-///
-class YAMLDefinedAtom : public DefinedAtom {
-public:
- YAMLDefinedAtom( uint32_t ord
- , YAMLFile &file
- , DefinedAtom::Scope scope
- , DefinedAtom::ContentType type
- , DefinedAtom::SectionChoice sectionChoice
- , DefinedAtom::Interposable interpose
- , DefinedAtom::Merge merge
- , DefinedAtom::DeadStripKind deadStrip
- , DefinedAtom::ContentPermissions perms
- , bool isThumb
- , bool isAlias
- , DefinedAtom::Alignment alignment
- , StringRef name
- , StringRef sectionName
- , uint64_t size
- , std::vector<uint8_t>& content)
- : _file(file)
- , _name(name)
- , _sectionName(sectionName)
- , _size(size)
- , _ord(ord)
- , _content(content)
- , _alignment(alignment)
- , _scope(scope)
- , _type(type)
- , _sectionChoice(sectionChoice)
- , _interpose(interpose)
- , _merge(merge)
- , _deadStrip(deadStrip)
- , _permissions(perms)
- , _isThumb(isThumb)
- , _isAlias(isAlias)
- , _refStartIndex(file._lastRefIndex)
- , _refEndIndex(file._references.size()) {
- file._lastRefIndex = _refEndIndex;
- }
-
- virtual const class File &file() const {
- return _file;
- }
-
- virtual StringRef name() const {
- return _name;
- }
-
- virtual uint64_t size() const {
- return _content.empty() ? _size : _content.size();
- }
-
- virtual DefinedAtom::Scope scope() const {
- return _scope;
- }
-
- virtual DefinedAtom::Interposable interposable() const {
- return _interpose;
- }
-
- virtual DefinedAtom::Merge merge() const {
- return _merge;
- }
-
- virtual DefinedAtom::ContentType contentType() const {
- return _type;
- }
-
- virtual DefinedAtom::Alignment alignment() const {
- return _alignment;
- }
-
- virtual DefinedAtom::SectionChoice sectionChoice() const {
- return _sectionChoice;
- }
-
- virtual StringRef customSectionName() const {
- return _sectionName;
- }
-
- virtual DefinedAtom::DeadStripKind deadStrip() const {
- return _deadStrip;
- }
-
- virtual DefinedAtom::ContentPermissions permissions() const {
- return _permissions;
- }
-
- virtual bool isThumb() const {
- return _isThumb;
- }
-
- virtual bool isAlias() const {
- return _isAlias;
- }
-
- ArrayRef<uint8_t> rawContent() const {
- return ArrayRef<uint8_t>(_content);
- }
-
- virtual uint64_t ordinal() const {
- return _ord;
- }
-
- DefinedAtom::reference_iterator begin() const {
- uintptr_t index = _refStartIndex;
- const void* it = reinterpret_cast<const void*>(index);
- return reference_iterator(*this, it);
- }
-
- DefinedAtom::reference_iterator end() const {
- uintptr_t index = _refEndIndex;
- const void* it = reinterpret_cast<const void*>(index);
- return reference_iterator(*this, it);
- }
-
- const Reference* derefIterator(const void* it) const {
- uintptr_t index = reinterpret_cast<uintptr_t>(it);
- assert(index >= _refStartIndex);
- assert(index < _refEndIndex);
- assert(index < _file._references.size());
- return &_file._references[index];
- }
-
- void incrementIterator(const void*& it) const {
- uintptr_t index = reinterpret_cast<uintptr_t>(it);
- ++index;
- it = reinterpret_cast<const void*>(index);
- }
-
- // Convert each target name to a pointer to an atom object
- error_code bindTargetReferences(llvm::yaml::Stream &stream) const {
- for (unsigned int i=_refStartIndex; i < _refEndIndex; ++i) {
- llvm::SmallString<32> storage;
- llvm::yaml::ScalarNode *node = _file._references[i]._targetNameNode;
- StringRef name = node->getValue(storage);
- Atom *targetAtom = _file.findAtom(name);
- if ( targetAtom ) {
- _file._references[i]._target = targetAtom;
- }
- else {
- stream.printError(node, "Fixup has target '" + name
- + "' which does not exist");
- return make_error_code(yaml_reader_error::illegal_value);
- }
- }
- return make_error_code(yaml_reader_error::success);
- }
-
-private:
- YAMLFile &_file;
- StringRef _name;
- StringRef _sectionName;
- unsigned long _size;
- uint32_t _ord;
- std::vector<uint8_t> _content;
- DefinedAtom::Alignment _alignment;
- DefinedAtom::Scope _scope;
- DefinedAtom::ContentType _type;
- DefinedAtom::SectionChoice _sectionChoice;
- DefinedAtom::Interposable _interpose;
- DefinedAtom::Merge _merge;
- DefinedAtom::DeadStripKind _deadStrip;
- DefinedAtom::ContentPermissions _permissions;
- bool _isThumb;
- bool _isAlias;
- unsigned int _refStartIndex;
- unsigned int _refEndIndex;
-};
-
-
-
-///
-/// Concrete instance of lld::UndefinedAtom created parsing YAML object files.
-///
-class YAMLUndefinedAtom : public UndefinedAtom {
-public:
- YAMLUndefinedAtom( YAMLFile &f
- , int32_t
- , StringRef name
- , UndefinedAtom::CanBeNull cbn)
- : _file(f)
- , _name(name)
- , _canBeNull(cbn) {
- }
-
- virtual const class File &file() const {
- return _file;
- }
-
- virtual StringRef name() const {
- return _name;
- }
-
- virtual CanBeNull canBeNull() const {
- return _canBeNull;
- }
-
-private:
- YAMLFile &_file;
- StringRef _name;
- UndefinedAtom::CanBeNull _canBeNull;
-};
-
-
-
-///
-/// Concrete instance of lld::SharedLibraryAtom created parsing YAML files.
-///
-class YAMLSharedLibraryAtom : public SharedLibraryAtom {
-public:
- YAMLSharedLibraryAtom( YAMLFile &f
- , int32_t
- , StringRef name
- , StringRef loadName
- , bool cbn)
- : _file(f)
- , _name(name)
- , _loadName(loadName)
- , _canBeNull(cbn) {
- }
-
- virtual const class File &file() const {
- return _file;
- }
-
- virtual StringRef name() const {
- return _name;
- }
-
- virtual StringRef loadName() const {
- return _loadName;
- }
-
- virtual bool canBeNullAtRuntime() const {
- return _canBeNull;
- }
-
-private:
- YAMLFile &_file;
- StringRef _name;
- StringRef _loadName;
- bool _canBeNull;
-};
-
-
-
-///
-/// Concrete instance of lld::AbsoluteAtom created parsing YAML object files.
-///
-class YAMLAbsoluteAtom : public AbsoluteAtom {
-public:
- YAMLAbsoluteAtom(YAMLFile &f, int32_t, StringRef name, uint64_t v, Atom::Scope scope)
- : _file(f)
- , _name(name)
- , _value(v)
- , _scope(scope){
- }
-
- virtual const class File &file() const {
- return _file;
- }
-
- virtual Scope scope() const {
- return _scope;
- }
-
- virtual StringRef name() const {
- return _name;
- }
-
- virtual uint64_t value() const {
- return _value;
- }
-
-private:
- YAMLFile &_file;
- StringRef _name;
- uint64_t _value;
- Atom::Scope _scope;
-};
-
-
-
-
-//===----------------------------------------------------------------------===//
-// YAMLFile methods
-//===----------------------------------------------------------------------===//
-
-YAMLFile::~YAMLFile() {
- for (char *s : _stringCopies) {
- delete [] s;
- }
-}
-
-
-error_code YAMLFile::bindTargetReferences(llvm::yaml::Stream &stream) {
- error_code ec;
- for (const DefinedAtom *defAtom : _definedAtoms) {
- const YAMLDefinedAtom *atom =
- reinterpret_cast<const YAMLDefinedAtom*>(defAtom);
- ec = atom->bindTargetReferences(stream);
- if ( ec )
- return ec;
- }
- return ec;
-}
-
-Atom *YAMLFile::findAtom(StringRef name) {
- for (auto &ci : _nameToAtomMapping) {
- if (ci.name == name)
- return ci.atom;
- }
- return nullptr;
-}
-
-void YAMLFile::addDefinedAtom(YAMLDefinedAtom *atom, StringRef refName) {
- _definedAtoms._atoms.push_back(atom);
- _nameToAtomMapping.push_back(NameAtomPair(refName, atom));
-}
-
-void YAMLFile::addUndefinedAtom(UndefinedAtom *atom) {
- _undefinedAtoms._atoms.push_back(atom);
- _nameToAtomMapping.push_back(NameAtomPair(atom->name(), atom));
-}
-
-void YAMLFile::addSharedLibraryAtom(SharedLibraryAtom *atom) {
- _sharedLibraryAtoms._atoms.push_back(atom);
- _nameToAtomMapping.push_back(NameAtomPair(atom->name(), atom));
-}
-
-void YAMLFile::addAbsoluteAtom(AbsoluteAtom *atom) {
- _absoluteAtoms._atoms.push_back(atom);
- _nameToAtomMapping.push_back(NameAtomPair(atom->name(), atom));
-}
-
-void YAMLFile::setName(StringRef name) {
- _path = StringRef(name);
-}
-
-
-// Allocate a new copy of this string and keep track of allocations
-// in _stringCopies, so they can be freed when YAMLFile is destroyed.
-StringRef YAMLFile::copyString(StringRef str) {
- char* s = new char[str.size()];
- memcpy(s, str.data(), str.size());
- _stringCopies.push_back(s);
- return StringRef(s, str.size());
-}
-
-const File *YAMLFile::find(StringRef name, bool dataSymbolOnly) const {
- for (auto &file : _memberFiles) {
- for (const DefinedAtom *atom : file->defined() ) {
- if (name == atom->name())
- return file.get();
- }
- }
- return nullptr;
-}
-
-
-
-///
-/// The state machine that drives the YAMLParser stream and instantiates
-/// Files and Atoms. This class also buffers all the attribures for the
-/// current atom and current fixup. Once all attributes are accumulated,
-/// a new atom or fixup instance is instantiated.
-///
-class YAMLState {
-public:
- YAMLState(const ReaderOptionsYAML &opts, llvm::yaml::Stream *s, YAMLFile *f);
-
- void parse(llvm::yaml::Node *node, StringRef keyword,
- llvm::yaml::Node *keywordNode=nullptr);
- error_code error() { return _error; }
-
-private:
- typedef llvm::yaml::Node Node;
- typedef llvm::yaml::ScalarNode ScalarNode;
- typedef llvm::yaml::SequenceNode SequenceNode;
- typedef llvm::yaml::MappingNode MappingNode;
- typedef llvm::yaml::Stream Stream;
-
- void resetState();
- void setAlign2(StringRef n);
-
- void makeReference();
- void makeAtom(Node *node);
- void makeDefinedAtom(Node *node);
- void makeUndefinedAtom(Node *node);
- void makeSharedLibraryAtom(Node *node);
- void makeAbsoluteAtom(Node *node);
-
- void parseMemberName(ScalarNode *node);
- void parseAtomName(ScalarNode *node);
- void parseAtomRefName(ScalarNode *node);
- void parseAtomType(ScalarNode *node);
- void parseAtomScope(ScalarNode *node);
- void parseAtomDefinition(ScalarNode *node);
- void parseAtomDeadStrip(ScalarNode *node);
- void parseAtomSectionChoice(ScalarNode *node);
- void parseAtomInterposable(ScalarNode *node);
- void parseAtomMerge(ScalarNode *node);
- void parseAtomIsThumb(ScalarNode *node);
- void parseAtomIsAlias(ScalarNode *node);
- void parseAtomSectionName(ScalarNode *node);
- void parseAtomSize(ScalarNode *node);
- void parseAtomPermissions(ScalarNode *node);
- void parseAtomCanBeNull(ScalarNode *node);
- void parseFixUpOffset(ScalarNode *node);
- void parseFixUpKind(ScalarNode *node);
- void parseFixUpTarget(ScalarNode *node);
- void parseFixUpAddend(ScalarNode *node);
- void parseAtomContentByte(ScalarNode *node);
- void parseAtomLoadName(ScalarNode *node);
- void parseAtomValue(ScalarNode *node);
-
- StringRef extractString(ScalarNode *node);
-
- typedef void (YAMLState:: *ParseScalar)(ScalarNode *node);
- typedef void (YAMLState:: *ParseSeq)(SequenceNode *node);
- typedef void (YAMLState:: *ParseMap)(MappingNode *node);
-
- enum State { inError, inTop, inDoc, inArch, inMemb,
- inAtoms, inAtom, inFixUps, inFixUp, inBytes };
- struct Transistion {
- State state;
- const char* keyword;
- State newState;
- ParseScalar customAction;
- };
-
- static const char* stateName(State);
-
- void moveToState(State s);
- void returnToState(State s, Node *node);
-
- static const Transistion _s_transistions[];
-
- const ReaderOptionsYAML &_options;
- error_code _error;
- llvm::yaml::Stream *_stream;
- YAMLFile *_file;
- YAMLFile *_archiveFile;
- State _state;
- StringRef _name;
- StringRef _refName;
- StringRef _sectionName;
- StringRef _loadName;
- StringRef _memberName;
- unsigned long long _size;
- uint64_t _value;
- uint32_t _ordinal;
- std::vector<uint8_t> _content;
- DefinedAtom::Alignment _alignment;
- Atom::Definition _definition;
- DefinedAtom::Scope _scope;
- DefinedAtom::ContentType _type;
- DefinedAtom::SectionChoice _sectionChoice;
- DefinedAtom::Interposable _interpose;
- DefinedAtom::Merge _merge;
- DefinedAtom::DeadStripKind _deadStrip;
- DefinedAtom::ContentPermissions _permissions;
- bool _isThumb;
- bool _isAlias;
- UndefinedAtom::CanBeNull _canBeNull;
- YAMLReference _ref;
- bool _hasDefinedAtomAttributes;
- bool _hasUndefinedAtomAttributes;
- bool _hasSharedLibraryAtomAttributes;
- bool _hasAbsoluteAtomAttributes;
-};
-
-
-//
-// This transition table is the heart of the state machine.
-// The table is read left-to-right columns A,B,C,D as:
-// If the state is A and key B is seen switch to state C then
-// if D is not nullptr call that method with the key's value,
-// if D is nullptr, recursively parse in the new state.
-//
-const YAMLState::Transistion YAMLState::_s_transistions[] = {
- { inTop, "<root>", inDoc, nullptr },
- { inDoc, "archive", inArch, nullptr },
- { inArch, "<any-seq-item>", inMemb, nullptr },
- { inMemb, "atoms", inAtoms, nullptr },
- { inMemb, "name", inMemb, &YAMLState::parseMemberName },
- { inDoc, "atoms", inAtoms, nullptr },
- { inAtoms, "<any-seq-item>", inAtom, nullptr },
- { inAtom, "name", inAtom, &YAMLState::parseAtomName },
- { inAtom, "ref-name", inAtom, &YAMLState::parseAtomRefName },
- { inAtom, "type", inAtom, &YAMLState::parseAtomType },
- { inAtom, "scope", inAtom, &YAMLState::parseAtomScope },
- { inAtom, "definition", inAtom, &YAMLState::parseAtomDefinition },
- { inAtom, "dead-strip", inAtom, &YAMLState::parseAtomDeadStrip },
- { inAtom, "section-choice", inAtom, &YAMLState::parseAtomSectionChoice },
- { inAtom, "interposable", inAtom, &YAMLState::parseAtomInterposable },
- { inAtom, "merge", inAtom, &YAMLState::parseAtomMerge },
- { inAtom, "is-thumb", inAtom, &YAMLState::parseAtomIsThumb },
- { inAtom, "is-alias", inAtom, &YAMLState::parseAtomIsAlias },
- { inAtom, "section-name", inAtom, &YAMLState::parseAtomSectionName },
- { inAtom, "size", inAtom, &YAMLState::parseAtomSize },
- { inAtom, "permissions", inAtom, &YAMLState::parseAtomPermissions },
- { inAtom, "can-be-null", inAtom, &YAMLState::parseAtomCanBeNull },
- { inAtom, "content", inBytes, nullptr },
- { inAtom, "fixups", inFixUps,nullptr },
- { inBytes, "<any-seq-item>", inBytes, &YAMLState::parseAtomContentByte },
- { inFixUps,"<any-seq-item>", inFixUp, nullptr },
- { inFixUp, "offset", inFixUp, &YAMLState::parseFixUpOffset },
- { inFixUp, "kind", inFixUp, &YAMLState::parseFixUpKind },
- { inFixUp, "target", inFixUp, &YAMLState::parseFixUpTarget },
- { inFixUp, "addend", inFixUp, &YAMLState::parseFixUpAddend },
- { inAtom, "load-name", inAtom, &YAMLState::parseAtomLoadName },
- { inAtom, "value", inAtom, &YAMLState::parseAtomValue },
- { inError, nullptr, inAtom, nullptr },
-};
-
-
-
-YAMLState::YAMLState(const ReaderOptionsYAML &opts, Stream *stream,
- YAMLFile *file)
- : _options(opts)
- , _error(make_error_code(yaml_reader_error::success))
- , _stream(stream)
- , _file(file)
- , _archiveFile(nullptr)
- , _state(inTop)
- , _alignment(0, 0) {
- this->resetState();
-}
-
-void YAMLState::makeAtom(Node *node) {
- switch (_definition ) {
- case Atom::definitionRegular:
- this->makeDefinedAtom(node);
- break;
- case Atom::definitionUndefined:
- this->makeUndefinedAtom(node);
- break;
- case Atom::definitionSharedLibrary:
- this->makeSharedLibraryAtom(node);
- break;
- case Atom::definitionAbsolute:
- this->makeAbsoluteAtom(node);
- break;
- }
- ++_ordinal;
-
- // reset state for next atom
- this->resetState();
-}
-
-void YAMLState::makeDefinedAtom(Node *node) {
- if ( _hasAbsoluteAtomAttributes ) {
- _stream->printError(node, "Defined atom '" + _name
- + "' has attributes only allowed on absolute atoms");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- if ( _hasSharedLibraryAtomAttributes ) {
- _stream->printError(node, "Defined atom '" + _name
- + "' has attributes only allowed on shared library atoms");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
-
- YAMLDefinedAtom *a = new YAMLDefinedAtom(_ordinal, *_file, _scope, _type
- , _sectionChoice, _interpose, _merge, _deadStrip
- , _permissions, _isThumb, _isAlias, _alignment
- , _name, _sectionName, _size, _content);
- _file->addDefinedAtom(a, !_refName.empty() ? _refName : _name);
-}
-
-void YAMLState::makeUndefinedAtom(Node *node) {
- if ( _hasDefinedAtomAttributes ) {
- _stream->printError(node, "Undefined atom '" + _name
- + "' has attributes only allowed on defined atoms");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- if ( _hasAbsoluteAtomAttributes ) {
- _stream->printError(node, "Defined atom '" + _name
- + "' has attributes only allowed on absolute atoms");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- UndefinedAtom *a = new YAMLUndefinedAtom(*_file, _ordinal, _name, _canBeNull);
- _file->addUndefinedAtom(a);
-}
-
-void YAMLState::makeSharedLibraryAtom(Node *node) {
- if ( _hasDefinedAtomAttributes ) {
- _stream->printError(node, "SharedLibrary atom '" + _name
- + "' has attributes only allowed on defined atoms");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- if ( _hasAbsoluteAtomAttributes ) {
- _stream->printError(node, "Defined atom '" + _name
- + "' has attributes only allowed on absolute atoms");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- bool nullable = (_canBeNull == UndefinedAtom::canBeNullAtRuntime);
- SharedLibraryAtom *a = new YAMLSharedLibraryAtom(*_file, _ordinal, _name,
- _loadName, nullable);
- _file->addSharedLibraryAtom(a);
-}
-
-void YAMLState::makeAbsoluteAtom(Node *node) {
- if ( _hasDefinedAtomAttributes ) {
- _stream->printError(node, "Absolute atom '" + _name
- + "' has attributes only allowed on defined atoms");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- if ( _hasSharedLibraryAtomAttributes ) {
- _stream->printError(node, "Absolute atom '" + _name
- + "' has attributes only allowed on shared library atoms");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- AbsoluteAtom *a = new YAMLAbsoluteAtom(*_file, _ordinal, _name, _value,
- _scope);
- _file->addAbsoluteAtom(a);
-}
-
-
-
-void YAMLState::resetState() {
- _name = StringRef();
- _refName = StringRef();
- _sectionName = StringRef();
- _loadName = StringRef();
- _memberName = StringRef();
- _size = 0;
- _value = 0;
- _ordinal = 0;
- _content.clear();
- _alignment.powerOf2 = 0;
- _alignment.modulus = 0;
- _definition = KeyValues::definitionDefault;
- _scope = KeyValues::scopeDefault;
- _type = KeyValues::contentTypeDefault;
- _sectionChoice = KeyValues::sectionChoiceDefault;
- _interpose = KeyValues::interposableDefault;
- _merge = KeyValues::mergeDefault;
- _deadStrip = KeyValues::deadStripKindDefault;
- _permissions = KeyValues::permissionsDefault;
- _isThumb = KeyValues::isThumbDefault;
- _isAlias = KeyValues::isAliasDefault;
- _canBeNull = KeyValues::canBeNullDefault;
- _ref._target = nullptr;
- _ref._targetNameNode= nullptr;
- _ref._addend = 0;
- _ref._offsetInAtom = 0;
- _ref._kind = 0;
-
- _hasDefinedAtomAttributes = false;
- _hasUndefinedAtomAttributes = false;
- _hasSharedLibraryAtomAttributes = false;
- _hasAbsoluteAtomAttributes = false;
-}
-
-
-void YAMLState::makeReference() {
- _file->_references.push_back(_ref);
- // clear for next ref
- _ref._target = nullptr;
- _ref._targetNameNode= nullptr;
- _ref._addend = 0;
- _ref._offsetInAtom = 0;
- _ref._kind = 0;
-}
-
-
-
-void YAMLState::setAlign2(StringRef s) {
- if (StringRef(s).getAsInteger(10, _alignment.powerOf2))
- _alignment.powerOf2 = 1;
-}
-
-
-// For debug logging
-const char* YAMLState::stateName(State s) {
- switch ( s ) {
- case inError:
- return "inError";
- case inTop:
- return "inTop";
- case inDoc:
- return "inDoc";
- case inArch:
- return "inArch";
- case inMemb:
- return "inMemb";
- case inAtoms:
- return "inAtoms";
- case inAtom:
- return "inAtom";
- case inFixUps:
- return "inFixUps";
- case inFixUp:
- return "inFixUp";
- case inBytes:
- return "inBytes";
- }
- return "unknown case";
-}
-
-// Called by parse() when recursing and switching to a new state.
-void YAMLState::moveToState(State newState) {
- if ( newState == _state )
- return;
- DEBUG_WITH_TYPE("objtxt", llvm::dbgs() << "moveToState(" << stateName(newState)
- << "), _state=" << stateName(_state) << "\n");
-
- if ( newState == inArch ) {
- // Seen "archive:", repurpose existing YAMLFile to be archive file
- _file->_kind = File::kindArchiveLibrary;
- _archiveFile = _file;
- _file = nullptr;
- }
-
- if ( newState == inMemb ) {
- assert(_state == inArch);
- // Make new YAMLFile for this member
- std::unique_ptr<YAMLFile> memberFile(new YAMLFile);
- _file = memberFile.get();
- assert(_archiveFile != nullptr);
- _archiveFile->_memberFiles.emplace_back(memberFile.release());
- }
-
- _state = newState;
-}
-
-// Called by parse() when returning from recursion and restoring the old state.
-void YAMLState::returnToState(State prevState, Node *node) {
- if ( prevState == _state )
- return;
- DEBUG_WITH_TYPE("objtxt", llvm::dbgs()
- << "returnToState(" << stateName(prevState)
- << "), _state=" << stateName(_state) << "\n");
- // If done with an atom, instantiate an object for it.
- if ( (_state == inAtom) && (prevState == inAtoms) )
- this->makeAtom(node);
- // If done wit a fixup, instantiate an object for it.
- if ( (_state == inFixUp) && (prevState == inFixUps) )
- this->makeReference();
- _state = prevState;
-}
-
-// If a string in the yaml document is quoted in a way that there is no
-// contiguous range of bytes that a StringRef can point to, then we make
-// a copy of the string and have the StringRef point to that.
-StringRef YAMLState::extractString(ScalarNode *node) {
- llvm::SmallString<32> storage;
- StringRef str = node->getValue(storage);
- //if ( str.data() == storage.begin() ) {
- str = _file->copyString(str);
- //}
- return str;
-}
-
-
-void YAMLState::parseMemberName(ScalarNode *node) {
- _memberName = extractString(node);
-}
-
-void YAMLState::parseAtomName(ScalarNode *node) {
- _name = extractString(node);
-}
-
-void YAMLState::parseAtomRefName(ScalarNode *node) {
- _refName = extractString(node);
-}
-
-void YAMLState::parseAtomScope(ScalarNode *node) {
- llvm::SmallString<32> storage;
- if ( KeyValues::scope(node->getValue(storage), _scope) ) {
- _stream->printError(node, "Invalid value for 'scope:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
-}
-
-void YAMLState::parseAtomDefinition(ScalarNode *node) {
- llvm::SmallString<32> storage;
- if ( KeyValues::definition(node->getValue(storage), _definition) ) {
- _stream->printError(node, "Invalid value for 'definition:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
-}
-
-void YAMLState::parseAtomType(ScalarNode *node) {
- llvm::SmallString<32> storage;
- if ( KeyValues::contentType(node->getValue(storage), _type) ) {
- _stream->printError(node, "Invalid value for 'type:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseAtomDeadStrip(ScalarNode *node) {
- llvm::SmallString<32> storage;
- if ( KeyValues::deadStripKind(node->getValue(storage), _deadStrip) ) {
- _stream->printError(node, "Invalid value for 'dead-strip:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseAtomSectionChoice(ScalarNode *node) {
- llvm::SmallString<32> storage;
- if ( KeyValues::sectionChoice(node->getValue(storage), _sectionChoice) ) {
- _stream->printError(node, "Invalid value for 'section-choice:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseAtomInterposable(ScalarNode *node) {
- llvm::SmallString<32> storage;
- if ( KeyValues::interposable(node->getValue(storage), _interpose) ) {
- _stream->printError(node, "Invalid value for 'interposable:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseAtomMerge(ScalarNode *node) {
- llvm::SmallString<32> storage;
- if ( KeyValues::merge(node->getValue(storage), _merge) ) {
- _stream->printError(node, "Invalid value for 'merge:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseAtomIsThumb(ScalarNode *node) {
- llvm::SmallString<32> storage;
- if ( KeyValues::isThumb(node->getValue(storage), _isThumb) ) {
- _stream->printError(node, "Invalid value for 'thumb:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseAtomIsAlias(ScalarNode *node) {
- llvm::SmallString<32> storage;
- if ( KeyValues::isAlias(node->getValue(storage), _isAlias) ) {
- _stream->printError(node, "Invalid value for 'is-alias:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseAtomSectionName(ScalarNode *node) {
- _sectionName = extractString(node);
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseAtomSize(ScalarNode *node) {
- llvm::SmallString<32> storage;
- StringRef offsetStr = node->getValue(storage);
- if ( offsetStr.getAsInteger(0, _size) ) {
- _stream->printError(node, "Invalid value for atom 'size:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseAtomPermissions(ScalarNode *node) {
- llvm::SmallString<32> storage;
- if ( KeyValues::permissions(node->getValue(storage), _permissions) ) {
- _stream->printError(node, "Invalid value for 'permissions:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseAtomCanBeNull(ScalarNode *node) {
- llvm::SmallString<32> storage;
- if ( KeyValues::canBeNull(node->getValue(storage), _canBeNull) ) {
- _stream->printError(node, "Invalid value for 'can-be-null:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
-}
-
-void YAMLState::parseFixUpOffset(ScalarNode *node) {
- llvm::SmallString<32> storage;
- StringRef offsetStr = node->getValue(storage);
- if ( offsetStr.getAsInteger(0, _ref._offsetInAtom) ) {
- _stream->printError(node, "Invalid value for fixup 'offset:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseFixUpKind(ScalarNode *node) {
- llvm::SmallString<32> storage;
- _ref._kind = _options.kindFromString(node->getValue(storage));
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseFixUpTarget(ScalarNode *node) {
- _ref._targetNameNode = node;
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseFixUpAddend(ScalarNode *node) {
- llvm::SmallString<32> storage;
- StringRef offsetStr = node->getValue(storage);
- if ( offsetStr.getAsInteger(0, _ref._addend) ) {
- _stream->printError(node, "Invalid value for fixup 'addend:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseAtomContentByte(ScalarNode *node) {
- llvm::SmallString<32> storage;
- StringRef str = node->getValue(storage);
- unsigned int contentByte;
- if ( str.getAsInteger(16, contentByte) ) {
- _stream->printError(node, "Invalid content hex byte '0x" + str + "'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- return;
- }
- if (contentByte > 0xFF) {
- _stream->printError(node, "Content hex byte out of range (0x"
- + str + " > 0xFF)");
- _error = make_error_code(yaml_reader_error::illegal_value);
- return;
- }
- _content.push_back(contentByte & 0xFF);
- _hasDefinedAtomAttributes = true;
-}
-
-void YAMLState::parseAtomLoadName(ScalarNode *node) {
- _loadName = extractString(node);
- _hasSharedLibraryAtomAttributes = true;
-}
-
-
-void YAMLState::parseAtomValue(ScalarNode *node) {
- llvm::SmallString<32> storage;
- StringRef offsetStr = node->getValue(storage);
- if ( offsetStr.getAsInteger(0, _value) ) {
- _stream->printError(node, "Invalid value for fixup 'addend:'");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- _hasAbsoluteAtomAttributes = true;
-}
-
-//
-// This is the parsing engine that walks the nodes in the yaml document
-// stream. It is table driven. See _s_transistions.
-//
-void YAMLState::parse(Node *node, StringRef keyword, Node *keywordNode) {
- using namespace llvm::yaml;
- DEBUG_WITH_TYPE("objtxt", llvm::dbgs() << "parse(" << keyword << "), _state="
- << stateName(_state) << "\n");
- if ( _error )
- return;
- State savedState = _state;
- for(const Transistion* t=_s_transistions; t->state != inError; ++t) {
- if ( t->state != _state )
- continue;
- if ( ! keyword.equals(t->keyword) )
- continue;
- ParseScalar action = t->customAction;
- this->moveToState(t->newState);
- if ( ScalarNode *sc = llvm::dyn_cast<ScalarNode>(node) ) {
- if ( action ) {
- (*this.*action)(sc);
- }
- else {
- _stream->printError(node, "unexpected scalar");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- }
- else if ( SequenceNode *seq = llvm::dyn_cast<SequenceNode>(node) ) {
- if ( action ) {
- _stream->printError(node, "unexpected sequence");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- else {
- for (Node &seqEntry : *seq ) {
- this->parse(&seqEntry, StringRef("<any-seq-item>"));
- if ( _error )
- break;
- }
- }
- }
- else if ( MappingNode *map = llvm::dyn_cast<MappingNode>(node) ) {
- if ( action ) {
- _stream->printError(node, "unexpected map");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- else {
- llvm::SmallString<32> storage;
- for (auto &keyVal : *map) {
- ScalarNode *keyScalar = llvm::dyn_cast<ScalarNode>(keyVal.getKey());
- llvm::StringRef keyStr = keyScalar->getValue(storage);
- this->parse(keyVal.getValue(), keyStr, keyScalar);
- if ( _error )
- break;
- }
- }
- }
- else {
- _stream->printError(node, "unexpected node type");
- _error = make_error_code(yaml_reader_error::illegal_value);
- }
- this->returnToState(savedState, node);
- return;
- }
- switch (_state) {
- case inAtom:
- _stream->printError(keywordNode, "Unknown atom attribute '"
- + keyword + ":'");
- break;
- case inFixUp:
- _stream->printError(keywordNode, "Unknown fixup attribute '"
- + keyword + ":'");
- break;
- case inDoc:
- _stream->printError(keywordNode, "Unknown file attribute '"
- + keyword + ":'");
- break;
- default:
- _stream->printError(keywordNode, "Unknown keyword '"
- + keyword + ":'");
- }
- _error = make_error_code(yaml_reader_error::illegal_value);
-}
-
-
-/// parseFile - Parse the specified YAML formatted MemoryBuffer
-/// into lld::File object(s) and append each to the specified vector<File*>.
-static error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
- const ReaderOptionsYAML &options,
- std::vector<std::unique_ptr<File>> &result) {
- llvm::SourceMgr srcMgr;
- llvm::yaml::Stream stream(mb->getBuffer(), srcMgr);
-
- for (llvm::yaml::Document &d : stream) {
- std::unique_ptr<yaml::YAMLFile> curFile(new yaml::YAMLFile);
- if (llvm::isa<llvm::yaml::NullNode>(d.getRoot()))
- continue; // Empty files are allowed.
- yaml::YAMLState yamlState(options, &stream, curFile.get());
- yamlState.parse(d.getRoot(), StringRef("<root>"));
-
- if ( stream.failed() )
- return make_error_code(yaml_reader_error::illegal_value);
- if ( yamlState.error() )
- return yamlState.error();
-
- error_code ec = curFile->bindTargetReferences(stream);
- if ( ec )
- return ec;
- result.emplace_back(curFile.release());
- }
-
- return make_error_code(yaml_reader_error::success);
-}
-
-
-
-} // namespace yaml
-
-
-
-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) {
- return lld::yaml::parseFile(mb, _options, result);
- }
-
-private:
- const ReaderOptionsYAML &_options;
-};
-
-
-
-Reader* createReaderYAML(const ReaderOptionsYAML &options) {
- return new ReaderYAML(options);
-}
-
-ReaderOptionsYAML::ReaderOptionsYAML() {
-}
-
-ReaderOptionsYAML::~ReaderOptionsYAML() {
-}
-
-
-
-
-} // namespace lld
Removed: lld/trunk/lib/ReaderWriter/YAML/WriterYAML.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/YAML/WriterYAML.cpp?rev=171591&view=auto
==============================================================================
--- lld/trunk/lib/ReaderWriter/YAML/WriterYAML.cpp (original)
+++ lld/trunk/lib/ReaderWriter/YAML/WriterYAML.cpp (removed)
@@ -1,505 +0,0 @@
-//===- lib/ReaderWriter/YAML/WriterYAML.cpp - Writes YAML object files ----===//
-//
-// The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lld/ReaderWriter/WriterYAML.h"
-
-#include "lld/Core/Atom.h"
-#include "lld/Core/File.h"
-#include "lld/Core/Reference.h"
-
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/OwningPtr.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/Support/DataTypes.h"
-#include "llvm/Support/Format.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/raw_ostream.h"
-#include "llvm/Support/system_error.h"
-
-#include "YamlKeyValues.h"
-
-#include <vector>
-
-namespace lld {
-namespace yaml {
-
-///
-/// 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 File& file)
- : _collisionCount(0), _unnamedCounter(0) {
- // visit all atoms
- for( const 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 Reference *ref : *atom) {
- // create refname for any unnamed reference target
- const 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++);
- _refNames[target] = Buffer.str();
- }
- }
- }
- for( const UndefinedAtom *undefAtom : file.undefined() ) {
- buildDuplicateNameMap(*undefAtom);
- }
- for( const SharedLibraryAtom *shlibAtom : file.sharedLibrary() ) {
- buildDuplicateNameMap(*shlibAtom);
- }
- for( const AbsoluteAtom *absAtom : file.absolute() ) {
- buildDuplicateNameMap(*absAtom);
- }
-
-
- }
-
- void buildDuplicateNameMap(const 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);
- _refNames[&atom] = Buffer.str();
- const Atom* prevAtom = pos->second;
- AtomToRefName::iterator pos2 = _refNames.find(prevAtom);
- if ( pos2 == _refNames.end() ) {
- // only create ref-name for previous if none already created
- Buffer << prevAtom->name() << llvm::format(".%03d", ++_collisionCount);
- _refNames[prevAtom] = Buffer.str();
- }
- }
- else {
- // First time we've seen this name, just add it to map.
- _nameMap[atom.name()] = &atom;
- }
- }
-
- bool hasRefName(const Atom* atom) {
- return _refNames.count(atom);
- }
-
- StringRef refName(const Atom *atom) {
- return _refNames.find(atom)->second;
- }
-
-private:
- typedef llvm::StringMap<const Atom*> NameToAtom;
- typedef llvm::DenseMap<const Atom*, std::string> AtomToRefName;
-
- unsigned int _collisionCount;
- unsigned int _unnamedCounter;
- NameToAtom _nameMap;
- AtomToRefName _refNames;
-};
-
-
-///
-/// Helper class for writeObjectText() to write out atoms in yaml format.
-///
-class AtomWriter {
-public:
- AtomWriter(const File& file, const WriterOptionsYAML &options,
- RefNameBuilder& rnb)
- : _file(file), _options(options), _rnb(rnb), _firstAtom(true) { }
-
-
- void write(raw_ostream &out) {
- // write header
- out << "---\n";
-
- // visit all atoms
- for( const DefinedAtom *atom : _file.defined() ) {
- writeDefinedAtom(*atom, out);
- }
- for( const UndefinedAtom *undefAtom : _file.undefined() ) {
- writeUndefinedAtom(*undefAtom, out);
- }
- for( const SharedLibraryAtom *shlibAtom : _file.sharedLibrary() ) {
- writeSharedLibraryAtom(*shlibAtom, out);
- }
- for( const AbsoluteAtom *absAtom : _file.absolute() ) {
- writeAbsoluteAtom(*absAtom, out);
- }
-
- out << "...\n";
- }
-
-
- void writeDefinedAtom(const DefinedAtom &atom, raw_ostream &out) {
- if ( _firstAtom ) {
- out << "atoms:\n";
- _firstAtom = false;
- }
- else {
- // add blank line between atoms for readability
- out << "\n";
- }
-
- bool hasDash = false;
- if ( !atom.name().empty() ) {
- out << " - "
- << "name:"
- << spacePadding(strlen("name"))
- << atom.name()
- << "\n";
- hasDash = true;
- }
-
- if ( _rnb.hasRefName(&atom) ) {
- out << (hasDash ? " " : " - ")
- << "ref-name:"
- << spacePadding(strlen("ref-name"))
- << _rnb.refName(&atom)
- << "\n";
- hasDash = true;
- }
-
- if ( atom.definition() != KeyValues::definitionDefault ) {
- out << (hasDash ? " " : " - ")
- << "definition:"
- << spacePadding(strlen("definition"))
- << KeyValues::definition(atom.definition())
- << "\n";
- hasDash = true;
- }
-
- if ( atom.scope() != KeyValues::scopeDefault ) {
- out << (hasDash ? " " : " - ")
- << "scope:"
- << spacePadding(strlen("scope"))
- << KeyValues::scope(atom.scope())
- << "\n";
- }
-
- if ( atom.interposable() != KeyValues::interposableDefault ) {
- out << " "
- << "interposable:"
- << spacePadding(strlen("interposable"))
- << KeyValues::interposable(atom.interposable())
- << "\n";
- }
-
- if ( atom.merge() != KeyValues::mergeDefault ) {
- out << " "
- << "merge:"
- << spacePadding(strlen("merge"))
- << KeyValues::merge(atom.merge())
- << "\n";
- }
-
- if ( atom.contentType() != KeyValues::contentTypeDefault ) {
- out << " "
- << "type:"
- << spacePadding(strlen("type"))
- << KeyValues::contentType(atom.contentType())
- << "\n";
- }
-
- if ( atom.deadStrip() != KeyValues::deadStripKindDefault ) {
- out << " "
- << "dead-strip:"
- << spacePadding(strlen("dead-strip"))
- << KeyValues::deadStripKind(atom.deadStrip())
- << "\n";
- }
-
- if ( atom.sectionChoice() != KeyValues::sectionChoiceDefault ) {
- out << " "
- << "section-choice:"
- << spacePadding(strlen("section-choice"))
- << KeyValues::sectionChoice(atom.sectionChoice())
- << "\n";
- assert( ! atom.customSectionName().empty() );
- out << " "
- << "section-name:"
- << spacePadding(strlen("section-name"))
- << atom.customSectionName()
- << "\n";
- }
-
- if ( atom.isThumb() != KeyValues::isThumbDefault ) {
- out << " "
- << "is-thumb:"
- << spacePadding(strlen("is-thumb"))
- << KeyValues::isThumb(atom.isThumb())
- << "\n";
- }
-
- if ( atom.isAlias() != KeyValues::isAliasDefault ) {
- out << " "
- << "is-alias:"
- << spacePadding(strlen("is-alias"))
- << KeyValues::isAlias(atom.isAlias())
- << "\n";
- }
-
- if ( (atom.contentType() != DefinedAtom::typeZeroFill)
- && (atom.size() != 0) ) {
- out << " "
- << "content:"
- << spacePadding(strlen("content"))
- << "[ ";
- ArrayRef<uint8_t> arr = atom.rawContent();
- bool needComma = false;
- for (unsigned int i=0; i < arr.size(); ++i) {
- if ( needComma )
- out << ", ";
- if ( ((i % 12) == 0) && (i != 0) ) {
- out << "\n ";
- }
- out << hexdigit(arr[i] >> 4);
- out << hexdigit(arr[i] & 0x0F);
- needComma = true;
- }
- out << " ]\n";
- }
-
- bool wroteFirstFixup = false;
- for (const Reference *ref : atom) {
- if ( !wroteFirstFixup ) {
- out << " fixups:\n";
- wroteFirstFixup = true;
- }
- out << " - "
- << "offset:"
- << spacePadding(strlen("offset"))
- << ref->offsetInAtom()
- << "\n";
- out << " "
- << "kind:"
- << spacePadding(strlen("kind"))
- << _options.kindToString(ref->kind())
- << "\n";
- const Atom* target = ref->target();
- if (target != nullptr) {
- StringRef refName = target->name();
- if ( _rnb.hasRefName(target) )
- refName = _rnb.refName(target);
- assert(!refName.empty());
- out << " "
- << "target:"
- << spacePadding(strlen("target"))
- << refName
- << "\n";
- }
- if ( ref->addend() != 0 ) {
- out << " "
- << "addend:"
- << spacePadding(strlen("addend"))
- << ref->addend()
- << "\n";
- }
- }
- }
-
-
- void writeUndefinedAtom(const UndefinedAtom &atom, raw_ostream &out) {
- if ( _firstAtom ) {
- out << "atoms:\n";
- _firstAtom = false;
- }
- else {
- // add blank line between atoms for readability
- out << "\n";
- }
-
- out << " - "
- << "name:"
- << spacePadding(strlen("name"))
- << atom.name()
- << "\n";
-
- out << " "
- << "definition:"
- << spacePadding(strlen("definition"))
- << KeyValues::definition(atom.definition())
- << "\n";
-
- if ( atom.canBeNull() != KeyValues::canBeNullDefault ) {
- out << " "
- << "can-be-null:"
- << spacePadding(strlen("can-be-null"))
- << KeyValues::canBeNull(atom.canBeNull())
- << "\n";
- }
- }
-
- void writeSharedLibraryAtom(const SharedLibraryAtom &atom, raw_ostream &out) {
- if ( _firstAtom ) {
- out << "atoms:\n";
- _firstAtom = false;
- }
- else {
- // add blank line between atoms for readability
- out << "\n";
- }
-
- out << " - "
- << "name:"
- << spacePadding(strlen("name"))
- << atom.name()
- << "\n";
-
- out << " "
- << "definition:"
- << spacePadding(strlen("definition"))
- << KeyValues::definition(atom.definition())
- << "\n";
-
- if ( !atom.loadName().empty() ) {
- out << " "
- << "load-name:"
- << spacePadding(strlen("load-name"))
- << atom.loadName()
- << "\n";
- }
-
- if ( atom.canBeNullAtRuntime() ) {
- out << " "
- << "can-be-null:"
- << spacePadding(strlen("can-be-null"))
- << KeyValues::canBeNull(UndefinedAtom::canBeNullAtRuntime)
- << "\n";
- }
- }
-
- void writeAbsoluteAtom(const AbsoluteAtom &atom, raw_ostream &out) {
- if ( _firstAtom ) {
- out << "atoms:\n";
- _firstAtom = false;
- }
- else {
- // add blank line between atoms for readability
- out << "\n";
- }
-
- out << " - "
- << "name:"
- << spacePadding(strlen("name"))
- << atom.name()
- << "\n";
-
- out << " "
- << "definition:"
- << spacePadding(strlen("definition"))
- << KeyValues::definition(atom.definition())
- << "\n";
-
- if ( atom.scope() != KeyValues::scopeDefault ) {
- out << " "
- << "scope:"
- << spacePadding(strlen("scope"))
- << KeyValues::scope(atom.scope())
- << "\n";
- }
-
- out << " "
- << "value:"
- << spacePadding(strlen("value"))
- << "0x";
- out.write_hex(atom.value());
- out << "\n";
- }
-
-
-private:
- // return a string of the correct number of spaces to align value
- const char* spacePadding(size_t keyLen) {
- const char* spaces = " ";
- assert(strlen(spaces) > keyLen);
- return &spaces[keyLen];
- }
-
- char hexdigit(uint8_t nibble) {
- if ( nibble < 0x0A )
- return '0' + nibble;
- else
- return 'A' + nibble - 0x0A;
- }
-
- const File &_file;
- const WriterOptionsYAML &_options;
- RefNameBuilder &_rnb;
- bool _firstAtom;
-};
-
-
-
-
-class Writer : public lld::Writer {
-public:
- Writer(const WriterOptionsYAML &options) : _options(options) {
- }
-
- virtual error_code writeFile(const lld::File &file, StringRef path) {
- // Create stream to path.
- std::string errorInfo;
- llvm::raw_fd_ostream out(path.data(), errorInfo);
- if (!errorInfo.empty())
- return llvm::make_error_code(llvm::errc::no_such_file_or_directory);
-
- // Figure what ref-name labels are needed.
- RefNameBuilder rnb(file);
-
- // Write out all atoms.
- AtomWriter writer(file, _options, rnb);
- writer.write(out);
- return error_code::success();
- }
-
- virtual StubsPass *stubPass() {
- return _options.stubPass();
- }
-
- virtual GOTPass *gotPass() {
- return _options.gotPass();
- }
-
-
-private:
- const WriterOptionsYAML &_options;
-};
-
-
-} // namespace yaml
-
-
-Writer* createWriterYAML(const WriterOptionsYAML &options) {
- return new lld::yaml::Writer(options);
-}
-
-WriterOptionsYAML::WriterOptionsYAML() {
-}
-
-WriterOptionsYAML::~WriterOptionsYAML() {
-}
-
-
-} // namespace lld
Removed: lld/trunk/lib/ReaderWriter/YAML/YamlKeyValues.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/YAML/YamlKeyValues.cpp?rev=171591&view=auto
==============================================================================
--- lld/trunk/lib/ReaderWriter/YAML/YamlKeyValues.cpp (original)
+++ lld/trunk/lib/ReaderWriter/YAML/YamlKeyValues.cpp (removed)
@@ -1,431 +0,0 @@
-//===- lib/ReaderWriter/YAML/YamlKeyValues.cpp ----------------------------===//
-//
-// The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "YamlKeyValues.h"
-
-#include "llvm/Support/ErrorHandling.h"
-#include "lld/Core/File.h"
-
-#include <cstring>
-
-namespace lld {
-namespace yaml {
-
-
-const DefinedAtom::Definition KeyValues::definitionDefault = Atom::definitionRegular;
-const DefinedAtom::Scope KeyValues::scopeDefault = DefinedAtom::scopeTranslationUnit;
-const DefinedAtom::ContentType KeyValues::contentTypeDefault = DefinedAtom::typeData;
-const DefinedAtom::DeadStripKind KeyValues::deadStripKindDefault = DefinedAtom::deadStripNormal;
-const DefinedAtom::SectionChoice KeyValues::sectionChoiceDefault = DefinedAtom::sectionBasedOnContent;
-const DefinedAtom::Interposable KeyValues::interposableDefault = DefinedAtom::interposeNo;
-const DefinedAtom::Merge KeyValues::mergeDefault = DefinedAtom::mergeNo;
-const DefinedAtom::ContentPermissions KeyValues::permissionsDefault = DefinedAtom::permR__;
-const bool KeyValues::isThumbDefault = false;
-const bool KeyValues::isAliasDefault = false;
-const UndefinedAtom::CanBeNull KeyValues::canBeNullDefault = UndefinedAtom::canBeNullNever;
-
-
-
-
-struct DefinitionMapping {
- const char* string;
- Atom::Definition value;
-};
-
-static const DefinitionMapping defMappings[] = {
- { "regular", Atom::definitionRegular },
- { "absolute", Atom::definitionAbsolute },
- { "undefined", Atom::definitionUndefined },
- { "shared-library", Atom::definitionSharedLibrary },
- { nullptr, Atom::definitionRegular }
-};
-
-bool KeyValues::definition(StringRef s, Atom::Definition &out)
-{
- for (const DefinitionMapping* p = defMappings; p->string != nullptr; ++p) {
- if (s == p->string) {
- out = p->value;
- return false;
- }
- }
- return true;
-}
-
-const char* KeyValues::definition(Atom::Definition s) {
- for (const DefinitionMapping* p = defMappings; p->string != nullptr; ++p) {
- if ( p->value == s )
- return p->string;
- }
- llvm::report_fatal_error("bad definition value");
-}
-
-
-
-
-
-struct ScopeMapping {
- const char* string;
- DefinedAtom::Scope value;
-};
-
-static const ScopeMapping scopeMappings[] = {
- { "global", Atom::scopeGlobal },
- { "hidden", Atom::scopeLinkageUnit },
- { "static", Atom::scopeTranslationUnit },
- { nullptr, Atom::scopeGlobal }
-};
-
-bool KeyValues::scope(StringRef s, DefinedAtom::Scope &out)
-{
- for (const ScopeMapping* p = scopeMappings; p->string != nullptr; ++p) {
- if (s == p->string) {
- out = p->value;
- return false;
- }
- }
- return true;
-}
-
-const char* KeyValues::scope(Atom::Scope s) {
- for (const ScopeMapping* p = scopeMappings; p->string != nullptr; ++p) {
- if ( p->value == s )
- return p->string;
- }
- llvm::report_fatal_error("bad scope value");
-}
-
-
-
-
-
-
-
-struct ContentTypeMapping {
- const char* string;
- DefinedAtom::ContentType value;
-};
-
-static const ContentTypeMapping typeMappings[] = {
- { "unknown", DefinedAtom::typeUnknown },
- { "code", DefinedAtom::typeCode },
- { "stub", DefinedAtom::typeStub },
- { "stub-helper", DefinedAtom::typeStubHelper },
- { "resolver", DefinedAtom::typeResolver },
- { "constant", DefinedAtom::typeConstant },
- { "c-string", DefinedAtom::typeCString },
- { "utf16-string", DefinedAtom::typeUTF16String },
- { "CFI", DefinedAtom::typeCFI },
- { "LSDA", DefinedAtom::typeLSDA },
- { "literal-4", DefinedAtom::typeLiteral4 },
- { "literal-8", DefinedAtom::typeLiteral8 },
- { "literal-16", DefinedAtom::typeLiteral16 },
- { "data", DefinedAtom::typeData },
- { "zero-fill", DefinedAtom::typeZeroFill },
- { "cf-string", DefinedAtom::typeCFString },
- { "got", DefinedAtom::typeGOT },
- { "lazy-pointer", DefinedAtom::typeLazyPointer },
- { "initializer-ptr",DefinedAtom::typeInitializerPtr },
- { "terminator-ptr", DefinedAtom::typeTerminatorPtr },
- { "c-string-ptr", DefinedAtom::typeCStringPtr },
- { "objc1-class", DefinedAtom::typeObjC1Class },
- { "objc1-class-ptr",DefinedAtom::typeObjCClassPtr },
- { "objc2-cat-ptr", DefinedAtom::typeObjC2CategoryList },
- { "tlv-thunk", DefinedAtom::typeThunkTLV },
- { "tlv-data", DefinedAtom::typeTLVInitialData },
- { "tlv-zero-fill", DefinedAtom::typeTLVInitialZeroFill },
- { "tlv-init-ptr", DefinedAtom::typeTLVInitializerPtr },
- { nullptr, DefinedAtom::typeUnknown }
-};
-
-bool KeyValues::contentType(StringRef s, DefinedAtom::ContentType &out)
-{
- for (const ContentTypeMapping* p = typeMappings; p->string != nullptr; ++p) {
- if (s == p->string) {
- out = p->value;
- return false;
- }
- }
- return true;
-}
-
-const char* KeyValues::contentType(DefinedAtom::ContentType s) {
- for (const ContentTypeMapping* p = typeMappings; p->string != nullptr; ++p) {
- if ( p->value == s )
- return p->string;
- }
- llvm::report_fatal_error("bad content type value");
-}
-
-
-
-
-
-
-
-struct DeadStripMapping {
- const char* string;
- DefinedAtom::DeadStripKind value;
-};
-
-static const DeadStripMapping dsMappings[] = {
- { "normal", DefinedAtom::deadStripNormal },
- { "never", DefinedAtom::deadStripNever },
- { "always", DefinedAtom::deadStripAlways },
- { nullptr, DefinedAtom::deadStripNormal }
-};
-
-bool KeyValues::deadStripKind(StringRef s, DefinedAtom::DeadStripKind &out)
-{
- for (const DeadStripMapping* p = dsMappings; p->string != nullptr; ++p) {
- if (s == p->string) {
- out = p->value;
- return false;
- }
- }
- return true;
-}
-
-const char* KeyValues::deadStripKind(DefinedAtom::DeadStripKind dsk) {
- for (const DeadStripMapping* p = dsMappings; p->string != nullptr; ++p) {
- if ( p->value == dsk )
- return p->string;
- }
- llvm::report_fatal_error("bad dead strip value");
-}
-
-
-
-
-
-struct InterposableMapping {
- const char* string;
- DefinedAtom::Interposable value;
-};
-
-static const InterposableMapping interMappings[] = {
- { "no", DefinedAtom::interposeNo },
- { "yes", DefinedAtom::interposeYes },
- { "yesAndWeak", DefinedAtom::interposeYesAndRuntimeWeak },
- { nullptr, DefinedAtom::interposeNo }
-};
-
-bool KeyValues::interposable(StringRef s, DefinedAtom::Interposable &out)
-{
- for (const InterposableMapping* p = interMappings; p->string != nullptr; ++p){
- if (s == p->string) {
- out = p->value;
- return false;
- }
- }
- return true;
-}
-
-const char* KeyValues::interposable(DefinedAtom::Interposable in) {
- for (const InterposableMapping* p = interMappings; p->string != nullptr; ++p){
- if ( p->value == in )
- return p->string;
- }
- llvm::report_fatal_error("bad interposable value");
-}
-
-
-
-
-
-
-struct MergeMapping {
- const char* string;
- DefinedAtom::Merge value;
-};
-
-static const MergeMapping mergeMappings[] = {
- { "no", DefinedAtom::mergeNo },
- { "asTentative", DefinedAtom::mergeAsTentative },
- { "asWeak", DefinedAtom::mergeAsWeak },
- { "asAddressedWeak",DefinedAtom::mergeAsWeakAndAddressUsed },
- { nullptr, DefinedAtom::mergeNo }
-};
-
-bool KeyValues::merge(StringRef s, DefinedAtom::Merge& out)
-{
- for (const MergeMapping* p = mergeMappings; p->string != nullptr; ++p) {
- if (s == p->string) {
- out = p->value;
- return false;
- }
- }
- return true;
-}
-
-const char* KeyValues::merge(DefinedAtom::Merge in) {
- for (const MergeMapping* p = mergeMappings; p->string != nullptr; ++p) {
- if ( p->value == in )
- return p->string;
- }
- llvm::report_fatal_error("bad merge value");
-}
-
-
-
-
-
-
-struct SectionChoiceMapping {
- const char* string;
- DefinedAtom::SectionChoice value;
-};
-
-static const SectionChoiceMapping sectMappings[] = {
- { "content", DefinedAtom::sectionBasedOnContent },
- { "custom", DefinedAtom::sectionCustomPreferred },
- { "custom-required", DefinedAtom::sectionCustomRequired },
- { nullptr, DefinedAtom::sectionBasedOnContent }
-};
-
-bool KeyValues::sectionChoice(StringRef s, DefinedAtom::SectionChoice &out)
-{
- for (const SectionChoiceMapping* p = sectMappings; p->string != nullptr; ++p){
- if (s == p->string) {
- out = p->value;
- return false;
- }
- }
- return true;
-}
-
-const char* KeyValues::sectionChoice(DefinedAtom::SectionChoice s) {
- for (const SectionChoiceMapping* p = sectMappings; p->string != nullptr; ++p){
- if ( p->value == s )
- return p->string;
- }
- llvm::report_fatal_error("bad dead strip value");
-}
-
-
-
-
-
-
-
-struct PermissionsMapping {
- const char* string;
- DefinedAtom::ContentPermissions value;
-};
-
-static const PermissionsMapping permMappings[] = {
- { "---", DefinedAtom::perm___ },
- { "r--", DefinedAtom::permR__ },
- { "r-x", DefinedAtom::permR_X },
- { "rw-", DefinedAtom::permRW_ },
- { "rw-l", DefinedAtom::permRW_L },
- { nullptr, DefinedAtom::perm___ }
-};
-
-bool KeyValues::permissions(StringRef s, DefinedAtom::ContentPermissions &out)
-{
- for (const PermissionsMapping* p = permMappings; p->string != nullptr; ++p) {
- if (s == p->string) {
- out = p->value;
- return false;
- }
- }
- return true;
-}
-
-const char* KeyValues::permissions(DefinedAtom::ContentPermissions s) {
- for (const PermissionsMapping* p = permMappings; p->string != nullptr; ++p) {
- if ( p->value == s )
- return p->string;
- }
- llvm::report_fatal_error("bad permissions value");
-}
-
-
-bool KeyValues::isThumb(StringRef s, bool &out)
-{
- if ( s.equals("true") ) {
- out = true;
- return false;
- }
-
- if ( s.equals("false") ) {
- out = false;
- return false;
- }
-
- return true;
-}
-
-const char* KeyValues::isThumb(bool b) {
- return b ? "true" : "false";
-}
-
-
-bool KeyValues::isAlias(StringRef s, bool &out)
-{
- if ( s.equals("true") ) {
- out = true;
- return false;
- }
-
- if ( s.equals("false") ) {
- out = false;
- return false;
- }
-
- return true;
-}
-
-const char* KeyValues::isAlias(bool b) {
- return b ? "true" : "false";
-}
-
-
-
-
-struct CanBeNullMapping {
- const char* string;
- UndefinedAtom::CanBeNull value;
-};
-
-static const CanBeNullMapping cbnMappings[] = {
- { "never", UndefinedAtom::canBeNullNever },
- { "at-runtime", UndefinedAtom::canBeNullAtRuntime },
- { "at-buildtime", UndefinedAtom::canBeNullAtBuildtime },
- { nullptr, UndefinedAtom::canBeNullNever }
-};
-
-
-bool KeyValues::canBeNull(StringRef s, UndefinedAtom::CanBeNull &out)
-{
- for (const CanBeNullMapping* p = cbnMappings; p->string != nullptr; ++p) {
- if (s == p->string) {
- out = p->value;
- return false;
- }
- }
- return true;
-}
-
-const char* KeyValues::canBeNull(UndefinedAtom::CanBeNull c) {
- for (const CanBeNullMapping* p = cbnMappings; p->string != nullptr; ++p) {
- if ( p->value == c )
- return p->string;
- }
- llvm::report_fatal_error("bad can-be-null value");
-}
-
-
-
-
-
-
-
-} // namespace yaml
-} // namespace lld
Removed: lld/trunk/lib/ReaderWriter/YAML/YamlKeyValues.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/YAML/YamlKeyValues.h?rev=171591&view=auto
==============================================================================
--- lld/trunk/lib/ReaderWriter/YAML/YamlKeyValues.h (original)
+++ lld/trunk/lib/ReaderWriter/YAML/YamlKeyValues.h (removed)
@@ -1,84 +0,0 @@
-//===- lib/ReaderWriter/YAML/YamlKeyValues.h ------------------------------===//
-//
-// The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_CORE_YAML_KEY_VALUES_H_
-#define LLD_CORE_YAML_KEY_VALUES_H_
-
-#include "lld/Core/Atom.h"
-#include "lld/Core/DefinedAtom.h"
-#include "lld/Core/UndefinedAtom.h"
-#include "lld/Core/File.h"
-
-namespace lld {
-namespace yaml {
-
-class KeyValues {
-public:
-
- static const char* const definitionKeyword;
- static const Atom::Definition definitionDefault;
- static bool definition(StringRef, Atom::Definition&);
- static const char* definition(Atom::Definition);
-
- static const char* const scopeKeyword;
- static const DefinedAtom::Scope scopeDefault;
- static bool scope(StringRef, DefinedAtom::Scope&);
- static const char* scope(Atom::Scope);
-
- static const char* const contentTypeKeyword;
- static const DefinedAtom::ContentType contentTypeDefault;
- static bool contentType(StringRef, DefinedAtom::ContentType&);
- static const char* contentType(DefinedAtom::ContentType);
-
- static const char* const deadStripKindKeyword;
- static const DefinedAtom::DeadStripKind deadStripKindDefault;
- static bool deadStripKind(StringRef, DefinedAtom::DeadStripKind&);
- static const char* deadStripKind(DefinedAtom::DeadStripKind);
-
- static const char* const sectionChoiceKeyword;
- static const DefinedAtom::SectionChoice sectionChoiceDefault;
- static bool sectionChoice(StringRef, DefinedAtom::SectionChoice&);
- static const char* sectionChoice(DefinedAtom::SectionChoice);
-
- static const char* const interposableKeyword;
- static const DefinedAtom::Interposable interposableDefault;
- static bool interposable(StringRef, DefinedAtom::Interposable&);
- static const char* interposable(DefinedAtom::Interposable);
-
- static const char* const mergeKeyword;
- static const DefinedAtom::Merge mergeDefault;
- static bool merge(StringRef, DefinedAtom::Merge&);
- static const char* merge(DefinedAtom::Merge);
-
- static const char* const permissionsKeyword;
- static const DefinedAtom::ContentPermissions permissionsDefault;
- static bool permissions(StringRef, DefinedAtom::ContentPermissions&);
- static const char* permissions(DefinedAtom::ContentPermissions);
-
- static const char* const isThumbKeyword;
- static const bool isThumbDefault;
- static bool isThumb(StringRef, bool&);
- static const char* isThumb(bool);
-
- static const char* const isAliasKeyword;
- static const bool isAliasDefault;
- static bool isAlias(StringRef, bool&);
- static const char* isAlias(bool);
-
- static const char* const canBeNullKeyword;
- static const UndefinedAtom::CanBeNull canBeNullDefault;
- static bool canBeNull(StringRef, UndefinedAtom::CanBeNull&);
- static const char* canBeNull(UndefinedAtom::CanBeNull);
-
-};
-
-} // namespace yaml
-} // namespace lld
-
-#endif // LLD_CORE_YAML_KEY_VALUES_H_
Modified: lld/trunk/test/absolute-basic.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/absolute-basic.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/absolute-basic.objtxt (original)
+++ lld/trunk/test/absolute-basic.objtxt Fri Jan 4 20:22:35 2013
@@ -5,21 +5,19 @@
#
---
-atoms:
+absolute-atoms:
- name: putchar
- definition: absolute
value: 0xFFFF0040
- name: reset
- definition: absolute
value: 0xFFFF0080
...
+
+# CHECK: absolute-atoms:
# CHECK: name: putchar
-# CHECK: definition: absolute
-# CHECK: value: 0xffff0040
+# CHECK: value: 0x00000000FFFF0040
# CHECK: name: reset
-# CHECK: definition: absolute
-# CHECK: value: 0xffff0080
+# CHECK: value: 0x00000000FFFF0080
# CHECK: ...
Modified: lld/trunk/test/absolute-local.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/absolute-local.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/absolute-local.objtxt (original)
+++ lld/trunk/test/absolute-local.objtxt Fri Jan 4 20:22:35 2013
@@ -4,23 +4,22 @@
# Test that absolute symbols with local scope do not cause name conflict
#
---
-atoms:
+absolute-atoms:
- name: putchar
- definition: absolute
+ ref-name: pc1
value: 0xFFFF0040
scope: static
- name: putchar
- definition: absolute
+ ref-name: pc2
value: 0xFFFF0040
scope: static
...
-# CHECK: ---
+# CHECK: ---
+# CHECK: absolute-atoms:
# CHECK: - name: putchar
-# CHECK: definition: absolute
-# CHECK: value: 0xffff0040
+# CHECK: value: 0x00000000FFFF0040
# CHECK: - name: putchar
-# CHECK: definition: absolute
-# CHECK: value: 0xffff0040
-# CHECK: ...
+# CHECK: value: 0x00000000FFFF0040
+# CHECK: ...
Modified: lld/trunk/test/archive-basic.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/archive-basic.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/archive-basic.objtxt (original)
+++ lld/trunk/test/archive-basic.objtxt Fri Jan 4 20:22:35 2013
@@ -6,37 +6,40 @@
#
---
-atoms:
+defined-atoms:
- name: foo
type: code
+undefined-atoms:
- name: bar
- definition: undefined
---
-archive:
- - name: bar.o
- atoms:
- - name: bar
- scope: global
- type: code
-
- - name: bar2
- type: code
-
- - name: baz.o
- atoms:
- - name: baz
- scope: global
- type: code
+kind: archive
+members:
+ - name: bar.o
+ content:
+ defined-atoms:
+ - name: bar
+ scope: global
+ type: code
+
+ - name: bar2
+ type: code
+
+ - name: baz.o
+ content:
+ defined-atoms:
+ - name: baz
+ scope: global
+ type: code
- - name: baz2
- type: code
+ - name: baz2
+ type: code
...
# CHECK: name: foo
+# CHECK-NOT: undefined-atoms:
# CHECK: name: bar
-# CHECK-NOT: definition: undefined
# CHECK: name: bar2
# CHECK-NOT: name: baz
# CHECK: ...
Modified: lld/trunk/test/archive-chain.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/archive-chain.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/archive-chain.objtxt (original)
+++ lld/trunk/test/archive-chain.objtxt Fri Jan 4 20:22:35 2013
@@ -5,55 +5,61 @@
#
---
-atoms:
+defined-atoms:
- name: foo
type: code
+undefined-atoms:
- name: bar1
- definition: undefined
---
-archive:
- - name: bar1.o
- - atoms:
- - name: bar1
- scope: global
- type: code
-
- - name: bar1b
- type: code
-
- - name: baz1
- definition: undefined
-
- - name: bar2.o
- - atoms:
- - name: bar2
- scope: global
- type: code
+kind: archive
+members:
+ - name: bar1.o
+ content:
+ defined-atoms:
+ - name: bar1
+ scope: global
+ type: code
+
+ - name: bar1b
+ type: code
+
+ undefined-atoms:
+ - name: baz1
+
+ - name: bar2.o
+ content:
+ defined-atoms:
+ - name: bar2
+ scope: global
+ type: code
- - name: bar2b
- type: code
+ - name: bar2b
+ type: code
---
-archive:
- - name: baz1.o
- - atoms:
- - name: baz1
- scope: global
- type: code
-
- - name: baz1b
- type: code
-
- - name: baz2.o
- - atoms:
- - name: baz2
- scope: global
- type: code
+kind: archive
+members:
+ - name: baz1.o
+ content:
+ defined-atoms:
+ - name: baz1
+ scope: global
+ type: code
+
+ - name: baz1b
+ type: code
+
+ - name: baz2.o
+ content:
+ defined-atoms:
+ - name: baz2
+ scope: global
+ type: code
- - name: baz2b
- type: code
+ - name: baz2b
+ type: code
...
# CHECK: name: foo
Modified: lld/trunk/test/archive-tentdef-search.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/archive-tentdef-search.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/archive-tentdef-search.objtxt (original)
+++ lld/trunk/test/archive-tentdef-search.objtxt Fri Jan 4 20:22:35 2013
@@ -8,34 +8,36 @@
#
---
-atoms:
+defined-atoms:
- name: foo
type: code
- name: bar
scope: global
type: zero-fill
- merge: asTentative
+ merge: as-tentative
---
-archive:
- - name: bar.o
- - atoms:
- - name: bar
- scope: global
- type: data
+kind: archive
+members:
+ - name: bar.o
+ content:
+ defined-atoms:
+ - name: bar
+ scope: global
+ type: data
- - name: bar2
- type: data
+ - name: bar2
+ type: data
...
# CHK1: name: foo
# CHK1: name: bar
-# CHK1: merge: asTentative
+# CHK1: merge: as-tentative
# CHK1: ...
# CHK2: name: foo
# CHK2: name: bar
-# CHK2-NOT: merge: asTentative
+# CHK2-NOT: merge: as-tentative
# CHK2: name: bar2
# CHK2: ...
Modified: lld/trunk/test/auto-hide-coalesce.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/auto-hide-coalesce.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/auto-hide-coalesce.objtxt (original)
+++ lld/trunk/test/auto-hide-coalesce.objtxt Fri Jan 4 20:22:35 2013
@@ -5,64 +5,56 @@
#
---
-atoms:
+defined-atoms:
- name: _inlineFunc1
scope: global
- definition: regular
type: code
- merge: asWeak
+ merge: as-weak
- name: _inlineFunc2
scope: global
- definition: regular
type: code
- merge: asWeak
+ merge: as-weak
- name: _inlineFunc3
scope: global
- definition: regular
type: code
- merge: asAddressedWeak
+ merge: as-addressed-weak
- name: _inlineFunc4
scope: global
- definition: regular
type: code
- merge: asAddressedWeak
+ merge: as-addressed-weak
---
-atoms:
+defined-atoms:
- name: _inlineFunc1
scope: global
- definition: regular
type: code
- merge: asWeak
+ merge: as-weak
- name: _inlineFunc2
scope: global
- definition: regular
type: code
- merge: asAddressedWeak
+ merge: as-addressed-weak
- name: _inlineFunc3
scope: global
- definition: regular
type: code
- merge: asWeak
+ merge: as-weak
- name: _inlineFunc4
scope: global
- definition: regular
type: code
- merge: asAddressedWeak
+ merge: as-addressed-weak
...
# CHECK: name: _inlineFunc1
-# CHECK: merge: asWeak
+# CHECK: merge: as-weak
# CHECK: name: _inlineFunc3
-# CHECK: merge: asAddressedWeak
+# CHECK: merge: as-addressed-weak
# CHECK: name: _inlineFunc4
-# CHECK: merge: asAddressedWeak
+# CHECK: merge: as-addressed-weak
# CHECK: name: _inlineFunc2
-# CHECK: merge: asAddressedWeak
+# CHECK: merge: as-addressed-weak
# CHECK: ...
Modified: lld/trunk/test/cstring-coalesce.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/cstring-coalesce.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/cstring-coalesce.objtxt (original)
+++ lld/trunk/test/cstring-coalesce.objtxt Fri Jan 4 20:22:35 2013
@@ -5,7 +5,7 @@
#
---
-atoms:
+defined-atoms:
- ref-name: L0
scope: hidden
type: c-string
@@ -16,13 +16,13 @@
type: c-string
content: [ 74, 68, 65, 72, 65, 00 ]
---
-atoms:
+defined-atoms:
- ref-name: L2
scope: hidden
type: c-string
content: [ 68, 65, 6c, 6c, 6f, 00 ]
---
-atoms:
+defined-atoms:
- ref-name: L2
scope: hidden
type: c-string
Modified: lld/trunk/test/custom-section.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/custom-section.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/custom-section.objtxt (original)
+++ lld/trunk/test/custom-section.objtxt Fri Jan 4 20:22:35 2013
@@ -5,7 +5,7 @@
#
---
-atoms:
+defined-atoms:
- name: _foo1
scope: global
section-choice: content
Modified: lld/trunk/test/darwin/hello-world.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/darwin/hello-world.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/darwin/hello-world.objtxt (original)
+++ lld/trunk/test/darwin/hello-world.objtxt Fri Jan 4 20:22:35 2013
@@ -5,12 +5,13 @@
#
---
-atoms:
+defined-atoms:
- name: _main
type: code
scope: global
- content: [ 55, 48, 89, E5, 48, 8D, 3D, 00, 00, 00, 00,
- E8, 00, 00, 00, 00, 31, C0, 5D, C3 ]
+ content: [ 55, 48, 89, E5, 48, 8D, 3D, 00,
+ 00, 00, 00, E8, 00, 00, 00, 00,
+ 31, C0, 5D, C3 ]
fixups:
- offset: 7
kind: pcrel32
@@ -24,8 +25,8 @@
type: c-string
content: [ 68, 65, 6C, 6C, 6F, 0A, 00 ]
+shared-library-atoms:
- name: _printf
- definition: shared-library
load-name: /usr/lib/libSystem.B.dylib
...
Modified: lld/trunk/test/dead-strip-attributes.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/dead-strip-attributes.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/dead-strip-attributes.objtxt (original)
+++ lld/trunk/test/dead-strip-attributes.objtxt Fri Jan 4 20:22:35 2013
@@ -5,15 +5,15 @@
#
---
-atoms:
+defined-atoms:
- name: _foo1
dead-strip: normal
---
-atoms:
+defined-atoms:
- name: _foo2
dead-strip: never
---
-atoms:
+defined-atoms:
- name: _foo3
dead-strip: always
...
Modified: lld/trunk/test/dead-strip-basic.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/dead-strip-basic.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/dead-strip-basic.objtxt (original)
+++ lld/trunk/test/dead-strip-basic.objtxt Fri Jan 4 20:22:35 2013
@@ -7,7 +7,7 @@
#
---
-atoms:
+defined-atoms:
- name: entry
dead-strip: never
fixups:
@@ -21,13 +21,12 @@
- name: mydead1
scope: global
+undefined-atoms:
- name: bar
- definition: undefined
- name: baz
- definition: undefined
---
-atoms:
+defined-atoms:
- name: mydead2
scope: global
type: data
@@ -36,7 +35,7 @@
scope: global
type: data
---
-atoms:
+defined-atoms:
- name: baz
scope: global
type: code
Modified: lld/trunk/test/dead-strip-globals.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/dead-strip-globals.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/dead-strip-globals.objtxt (original)
+++ lld/trunk/test/dead-strip-globals.objtxt Fri Jan 4 20:22:35 2013
@@ -6,7 +6,7 @@
#
---
-atoms:
+defined-atoms:
- name: entry
dead-strip: never
fixups:
@@ -20,13 +20,11 @@
- name: myglobal1
scope: global
+undefined-atoms:
- name: bar
- definition: undefined
-
- name: baz
- definition: undefined
---
-atoms:
+defined-atoms:
- name: myglobal2
scope: global
type: data
@@ -35,7 +33,7 @@
scope: hidden
type: data
---
-atoms:
+defined-atoms:
- name: baz
scope: hidden
type: code
Modified: lld/trunk/test/elf/abs.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/elf/abs.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/elf/abs.objtxt (original)
+++ lld/trunk/test/elf/abs.objtxt Fri Jan 4 20:22:35 2013
@@ -11,11 +11,9 @@
#
RUN: lld-core -reader ELF %p/Inputs/abs-test.i386 | FileCheck -check-prefix=YAML %s
+YAML: absolute-atoms:
YAML: - name: absLocalSymbol
-YAML: definition: absolute
-YAML: value: 0xc0000
-
+YAML: value: {{0x[0]+C0000}}
YAML: - name: absGlobalSymbol
-YAML: definition: absolute
YAML: scope: global
-YAML: value: 0xd0000
+YAML: value: {{0x[0]+D0000}}
Modified: lld/trunk/test/elf/archive-elf-forceload.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/elf/archive-elf-forceload.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/elf/archive-elf-forceload.objtxt (original)
+++ lld/trunk/test/elf/archive-elf-forceload.objtxt Fri Jan 4 20:22:35 2013
@@ -25,6 +25,7 @@
RUN: lld-core -reader ELF %p/Inputs/mainobj.x86_64 %p/Inputs/libfnarchive.x86_64 -force-load | FileCheck -check-prefix FORCELOAD %s
+FORCELOAD: defined-atoms:
FORCELOAD: - name: fn1
FORCELOAD: scope: global
FORCELOAD: type: code
@@ -37,12 +38,10 @@
FORCELOAD: section-choice: custom-required
FORCELOAD: section-name: .text
FORCELOAD: content: [ 55, 48, 89, E5, B8, 00, 00, 00, 00, 5D, C3 ]
+FORCELOAD: absolute-atoms:
FORCELOAD: - name: main.c
-FORCELOAD: definition: absolute
FORCELOAD: value: 0x0
FORCELOAD: - name: fn1.c
-FORCELOAD: definition: absolute
FORCELOAD: value: 0x0
FORCELOAD: - name: fn.c
-FORCELOAD: definition: absolute
FORCELOAD: value: 0x0
Modified: lld/trunk/test/elf/archive-elf.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/elf/archive-elf.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/elf/archive-elf.objtxt (original)
+++ lld/trunk/test/elf/archive-elf.objtxt Fri Jan 4 20:22:35 2013
@@ -25,15 +25,12 @@
RUN: lld-core -reader ELF %p/Inputs/mainobj.x86_64 %p/Inputs/libfnarchive.x86_64 | FileCheck -check-prefix NOFORCELOAD %s
+NOFORCELOAD: defined-atoms:
NOFORCELOAD: - name: fn
NOFORCELOAD: scope: global
-NOFORCELOAD: type: code
-NOFORCELOAD: section-choice: custom-required
-NOFORCELOAD: section-name: .text
NOFORCELOAD: content: [ 55, 48, 89, E5, B8, 00, 00, 00, 00, 5D, C3 ]
+NOFORCELOAD: absolute-atoms:
NOFORCELOAD: - name: main.c
-NOFORCELOAD: definition: absolute
NOFORCELOAD: value: 0x0
NOFORCELOAD: - name: fn.c
-NOFORCELOAD: definition: absolute
NOFORCELOAD: value: 0x0
Modified: lld/trunk/test/elf/branch.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/elf/branch.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/elf/branch.objtxt (original)
+++ lld/trunk/test/elf/branch.objtxt Fri Jan 4 20:22:35 2013
@@ -4,24 +4,24 @@
hexagon-yaml: - name: back
hexagon-yaml: scope: global
-hexagon-yaml: type: code
-hexagon-yaml: section-choice: custom-required
-hexagon-yaml: section-name: .text
hexagon-yaml: content: [ 00, C0, 00, 7F, 00, C0, 00, 5A, 00, 00, 00, 00,
hexagon-yaml: 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00 ]
+hexagon-yaml: section-choice: custom-required
+hexagon-yaml: section-name: .text
hexagon-yaml: fixups:
-hexagon-yaml: - offset: 4
+hexagon-yaml: - kind:
+hexagon-yaml: offset: 4
hexagon-yaml: target: target
hexagon-yaml: - name: target
hexagon-yaml: scope: global
-hexagon-yaml: type: code
+hexagon-yaml: content: [ 00, C0, 00, 5A ]
hexagon-yaml: section-choice: custom-required
hexagon-yaml: section-name: .text
-hexagon-yaml: content: [ 00, C0, 00, 5A ]
hexagon-yaml: fixups:
-hexagon-yaml: - offset: 0
+hexagon-yaml: - kind:
+hexagon-yaml: offset: 0
hexagon-yaml: target: back
Modified: lld/trunk/test/elf/check.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/elf/check.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/elf/check.objtxt (original)
+++ lld/trunk/test/elf/check.objtxt Fri Jan 4 20:22:35 2013
@@ -1,144 +1,106 @@
RUN: lld-core -reader ELF %p/Inputs/object-test.elf-i386 | FileCheck %s -check-prefix ELF-i386
RUN: lld-core -arch hexagon -reader ELF %p/Inputs/object-test.elf-hexagon | FileCheck %s -check-prefix ELF-hexagon
-ELF-i386:atoms:
+ELF-i386:defined-atoms:
ELF-i386: - name: global_func
ELF-i386: scope: global
-ELF-i386: type: code
-ELF-i386: section-choice: custom-required
-ELF-i386: section-name: .text
ELF-i386: content: [ 55, 89, E5, 83, EC, 18, C7, 04, 24, 00, 00, 00,
ELF-i386: 00, E8, FC, FF, FF, FF, C9, C3 ]
ELF-i386: - name: static_func
-ELF-i386: type: code
-ELF-i386: section-choice: custom-required
-ELF-i386: section-name: .text
ELF-i386: content: [ 55, 89, E5, 83, EC, 18, C7, 04, 24, 07, 00, 00,
ELF-i386: 00, E8, FC, FF, FF, FF, C9, C3 ]
ELF-i386: - name: weak_func
ELF-i386: scope: global
-ELF-i386: merge: asWeak
-ELF-i386: type: code
-ELF-i386: section-choice: custom-required
-ELF-i386: section-name: .text
ELF-i386: content: [ 55, 89, E5, 83, EC, 18, C7, 04, 24, 0E, 00, 00,
ELF-i386: 00, E8, FC, FF, FF, FF, C9, C3 ]
+ELF-i386: merge: as-weak
ELF-i386: - name: hidden_func
ELF-i386: scope: hidden
-ELF-i386: type: code
-ELF-i386: section-choice: custom-required
-ELF-i386: section-name: .text
ELF-i386: content: [ 55, 89, E5, 83, EC, 18, C7, 04, 24, 13, 00, 00,
ELF-i386: 00, E8, FC, FF, FF, FF, C9, C3 ]
ELF-i386: - name: no_dead_strip
ELF-i386: scope: global
-ELF-i386: type: code
-ELF-i386: section-choice: custom-required
-ELF-i386: section-name: .text
ELF-i386: content: [ 55, 89, E5, 5D, C3 ]
ELF-i386: - name: no_special_section_func
ELF-i386: scope: global
-ELF-i386: type: code
-ELF-i386: section-choice: custom-required
-ELF-i386: section-name: .text
ELF-i386: content: [ 55, 89, E5, 5D, C3 ]
ELF-i386: - name: special_section_func
ELF-i386: scope: global
-ELF-i386: type: code
+ELF-i386: content: [ 55, 89, E5, 5D, C3 ]
ELF-i386: section-choice: custom-required
ELF-i386: section-name: special_section
-ELF-i386: content: [ 55, 89, E5, 5D, C3 ]
ELF-i386: - name: tentative
ELF-i386: scope: global
-ELF-i386: merge: asTentative
ELF-i386: type: zero-fill
+ELF-i386: merge: as-tentative
ELF-i386: - name: common_symbol
ELF-i386: scope: global
-ELF-i386: merge: asTentative
ELF-i386: type: zero-fill
+ELF-i386: merge: as-tentative
+ELF-i386:undefined-atoms:
ELF-i386: - name: puts
-ELF-i386: definition: undefined
+ELF-i386:absolute-atoms:
ELF-i386: - name: sample.c
-ELF-i386: definition: absolute
ELF-i386: value: 0x0
ELF-hexagon:atoms:
ELF-hexagon: - name: global_func
ELF-hexagon: scope: global
-ELF-hexagon: type: code
-ELF-hexagon: section-choice: custom-required
-ELF-hexagon: section-name: .text
ELF-hexagon: content: [ 00, C0, 9D, A0, 00, 40, 00, 00, 00, C0, 00, 78,
ELF-hexagon: 00, C0, 00, 5A, 1E, C0, 1E, 96 ]
ELF-hexagon: - name: static_func
-ELF-hexagon: type: code
-ELF-hexagon: section-choice: custom-required
-ELF-hexagon: section-name: .text
ELF-hexagon: content: [ 00, C0, 9D, A0, 00, 40, 00, 00, 00, C0, 00, 78,
ELF-hexagon: 00, C0, 00, 5A, 1E, C0, 1E, 96 ]
ELF-hexagon: - name: weak_func
ELF-hexagon: scope: global
-ELF-hexagon: merge: asWeak
-ELF-hexagon: type: code
-ELF-hexagon: section-choice: custom-required
-ELF-hexagon: section-name: .text
ELF-hexagon: content: [ 00, C0, 9D, A0, 00, 40, 00, 00, 00, C0, 00, 78,
ELF-hexagon: 00, C0, 00, 5A, 1E, C0, 1E, 96 ]
+ELF-hexagon: merge: as-weak
ELF-hexagon: - name: hidden_func
ELF-hexagon: scope: hidden
-ELF-hexagon: type: code
-ELF-hexagon: section-choice: custom-required
-ELF-hexagon: section-name: .text
ELF-hexagon: content: [ 00, C0, 9D, A0, 00, 40, 00, 00, 00, C0, 00, 78,
ELF-hexagon: 00, C0, 00, 5A, 1E, C0, 1E, 96 ]
ELF-hexagon: - name: no_dead_strip
ELF-hexagon: scope: global
-ELF-hexagon: type: code
-ELF-hexagon: section-choice: custom-required
-ELF-hexagon: section-name: .text
ELF-hexagon: content: [ 00, C0, 9D, A0, 1E, C0, 1E, 96 ]
ELF-hexagon: - name: no_special_section_func
ELF-hexagon: scope: global
-ELF-hexagon: type: code
-ELF-hexagon: section-choice: custom-required
-ELF-hexagon: section-name: .text
ELF-hexagon: content: [ 00, C0, 9D, A0, 1E, C0, 1E, 96 ]
ELF-hexagon: - name: special_section_func
ELF-hexagon: scope: global
-ELF-hexagon: type: code
+ELF-hexagon: content: [ 00, C0, 9D, A0, 1E, C0, 1E, 96 ]
ELF-hexagon: section-choice: custom-required
ELF-hexagon: section-name: special_section
-ELF-hexagon: content: [ 00, C0, 9D, A0, 1E, C0, 1E, 96 ]
ELF-hexagon: - name: tentative
ELF-hexagon: scope: global
-ELF-hexagon: merge: asTentative
ELF-hexagon: type: zero-fill
+ELF-hexagon: merge: as-tentative
ELF-hexagon: - name: common_symbol
ELF-hexagon: scope: global
-ELF-hexagon: merge: asTentative
ELF-hexagon: type: zero-fill
+ELF-hexagon: merge: as-tentative
+ELF-hexagon: undefined-atoms:
ELF-hexagon: - name: puts
-ELF-hexagon: definition: undefined
+ELF-hexagon: absolute-atoms:
ELF-hexagon: - name: sample.c
-ELF-hexagon: definition: absolute
ELF-hexagon: value: 0x0
Modified: lld/trunk/test/elf/reloc.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/elf/reloc.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/elf/reloc.objtxt (original)
+++ lld/trunk/test/elf/reloc.objtxt Fri Jan 4 20:22:35 2013
@@ -1,9 +1,8 @@
RUN: lld-core -reader ELF %p/Inputs/reloc-test.elf-i386 | FileCheck %s -check-prefix ELF-i386
ELF-i386:---
-ELF-i386:atoms:
+ELF-i386:defined-atoms:
ELF-i386: - name: .text
-ELF-i386: type: code
ELF-i386: section-choice: custom-required
ELF-i386: section-name: .text
@@ -18,61 +17,57 @@
ELF-i386: - name: .rodata.str1.1
ELF-i386: type: constant
+ELF-i386: content: [ 68, 65, 6C, 6C, 6F, 20, 77, 6F, 72, 6C, 64, 00 ]
ELF-i386: section-choice: custom-required
ELF-i386: section-name: .rodata.str1.1
-ELF-i386: content: [ 68, 65, 6C, 6C, 6F, 20, 77, 6F, 72, 6C, 64, 00 ]
ELF-i386: - name: .text.startup
-ELF-i386: type: code
ELF-i386: section-choice: custom-required
ELF-i386: section-name: .text.startup
ELF-i386: - name: main
ELF-i386: scope: global
-ELF-i386: type: code
-ELF-i386: section-choice: custom-required
-ELF-i386: section-name: .text.startup
ELF-i386: content: [ 55, 89, E5, 83, E4, F0, 83, EC, 10, C7, 04, 24,
ELF-i386: 00, 00, 00, 00, E8, FC, FF, FF, FF, 31, C0, C9,
ELF-i386: C3 ]
+ELF-i386: section-choice: custom-required
+ELF-i386: section-name: .text.startup
ELF-i386: fixups:
-ELF-i386: - offset: 12
-ELF-i386: kind: ???
+ELF-i386: - kind: ???
+ELF-i386: offset: 12
ELF-i386: target: .rodata.str1.1
-ELF-i386: - offset: 17
-ELF-i386: kind: call32
+ELF-i386: - kind: call32
+ELF-i386: offset: 17
ELF-i386: target: puts
ELF-i386: - name: .comment
ELF-i386: type: constant
-ELF-i386: section-choice: custom-required
-ELF-i386: section-name: .comment
ELF-i386: content: [ 00, 47, 43, 43, 3A, 20, 28, 47, 4E, 55, 29, 20,
ELF-i386: 34, 2E, 37, 2E, 30, 00 ]
+ELF-i386: section-choice: custom-required
+ELF-i386: section-name: .comment
ELF-i386: - name: .note.GNU-stack
-ELF-i386: type: code
ELF-i386: section-choice: custom-required
ELF-i386: section-name: .note.GNU-stack
ELF-i386: - name: .eh_frame
-ELF-i386: type: code
-ELF-i386: section-choice: custom-required
-ELF-i386: section-name: .eh_frame
ELF-i386: content: [ 14, 00, 00, 00, 00, 00, 00, 00, 01, 7A, 52, 00,
ELF-i386: 01, 7C, 08, 01, 1B, 0C, 04, 04, 88, 01, 00, 00,
ELF-i386: 1C, 00, 00, 00, 1C, 00, 00, 00, 00, 00, 00, 00,
ELF-i386: 19, 00, 00, 00, 00, 41, 0E, 08, 85, 02, 42, 0D,
ELF-i386: 05, 55, C5, 0C, 04, 04, 00, 00 ]
+ELF-i386: section-choice: custom-required
+ELF-i386: section-name: .eh_frame
ELF-i386: fixups:
-ELF-i386: - offset: 32
-ELF-i386: kind: call32
+ELF-i386: - kind: call32
+ELF-i386: offset: 32
ELF-i386: target: .text.startup
+ELF-i386:undefined-atoms:
ELF-i386: - name: puts
-ELF-i386: definition: undefined
+ELF-i386:absolute-atoms:
ELF-i386: - name: test.c
-ELF-i386: definition: absolute
ELF-i386: value: 0x0
ELF-i386:...
Modified: lld/trunk/test/elf/x86.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/elf/x86.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/elf/x86.objtxt (original)
+++ lld/trunk/test/elf/x86.objtxt Fri Jan 4 20:22:35 2013
@@ -22,21 +22,17 @@
x86-yaml: - name: back
x86-yaml: scope: global
-x86-yaml: type: code
-x86-yaml: section-name: .text
x86-yaml: content: [ E8, FC, FF, FF, FF ]
x86-yaml: fixups:
-x86-yaml: - offset: 1
-x86-yaml: kind: call32
+x86-yaml: - kind: call32
+x86-yaml: offset: 1
x86-yaml: target: target
x86-yaml: - name: target
x86-yaml: scope: global
-x86-yaml: type: code
-x86-yaml: section-name: .text
x86-yaml: content: [ E8, FC, FF, FF, FF ]
x86-yaml: fixups:
-x86-yaml: - offset: 1
-x86-yaml: kind: call32
+x86-yaml: - kind: call32
+x86-yaml: offset: 1
x86-yaml: target: back
Modified: lld/trunk/test/error-atom-attribute.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/error-atom-attribute.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/error-atom-attribute.objtxt (original)
+++ lld/trunk/test/error-atom-attribute.objtxt Fri Jan 4 20:22:35 2013
@@ -6,7 +6,7 @@
#
---
-atoms:
+defined-atoms:
- name: entry
scope: hidden
foobar: true
@@ -15,5 +15,5 @@
...
-# CHECK: error: Unknown atom attribute
+# CHECK: error: unknown key 'foobar'
# CHECK: foobar
Modified: lld/trunk/test/error-atom-content-byte-value.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/error-atom-content-byte-value.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/error-atom-content-byte-value.objtxt (original)
+++ lld/trunk/test/error-atom-content-byte-value.objtxt Fri Jan 4 20:22:35 2013
@@ -6,7 +6,7 @@
#
---
-atoms:
+defined-atoms:
- name: entry
scope: hidden
content: [ A5, 00, 4G, 1F ]
@@ -14,5 +14,5 @@
...
-# CHECK: error: Invalid content hex byte
+# CHECK: error: invalid two-digit-hex number
# CHECK: 4G
Modified: lld/trunk/test/error-atom-content-bytes.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/error-atom-content-bytes.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/error-atom-content-bytes.objtxt (original)
+++ lld/trunk/test/error-atom-content-bytes.objtxt Fri Jan 4 20:22:35 2013
@@ -6,7 +6,7 @@
#
---
-atoms:
+defined-atoms:
- name: entry
scope: hidden
content: [ A5, 1234, 00, 4F ]
@@ -14,6 +14,6 @@
...
-# CHECK: error: Content hex byte out of range
+# CHECK: error: out of range two-digit-hex number
# CHECK: 1234
Modified: lld/trunk/test/error-atom-type.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/error-atom-type.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/error-atom-type.objtxt (original)
+++ lld/trunk/test/error-atom-type.objtxt Fri Jan 4 20:22:35 2013
@@ -6,7 +6,7 @@
#
---
-atoms:
+defined-atoms:
- name: entry
scope: hidden
type: superluminal
@@ -15,5 +15,5 @@
...
-# CHECK: error: Invalid value for 'type:'
+# CHECK: error: unknown enumerated scalar
# CHECK: superluminal
Modified: lld/trunk/test/error-atom-undefined-wrong-attribue.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/error-atom-undefined-wrong-attribue.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/error-atom-undefined-wrong-attribue.objtxt (original)
+++ lld/trunk/test/error-atom-undefined-wrong-attribue.objtxt Fri Jan 4 20:22:35 2013
@@ -6,13 +6,12 @@
#
---
-atoms:
+undefined-atoms:
- name: foo
type: code
- definition: undefined
...
-# CHECK: error: Undefined atom 'foo' has attributes only allowed on defined atoms
+# CHECK: error: unknown key 'type'
Modified: lld/trunk/test/error-file-attribute.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/error-file-attribute.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/error-file-attribute.objtxt (original)
+++ lld/trunk/test/error-file-attribute.objtxt Fri Jan 4 20:22:35 2013
@@ -7,12 +7,11 @@
---
aardvark: true
-atoms:
+defined-atoms:
- name: entry
scope: hidden
...
-# CHECK: error: Unknown file attribute
-# CHECK: aardvark
+# CHECK: error: unknown key 'aardvark'
Modified: lld/trunk/test/error-fixup-attribute.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/error-fixup-attribute.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/error-fixup-attribute.objtxt (original)
+++ lld/trunk/test/error-fixup-attribute.objtxt Fri Jan 4 20:22:35 2013
@@ -6,7 +6,7 @@
#
---
-atoms:
+defined-atoms:
- name: entry
scope: hidden
fixups:
@@ -18,5 +18,4 @@
...
-# CHECK: error: Unknown fixup attribute
-# CHECK: weasel
+# CHECK: error: unknown key 'weasel'
Modified: lld/trunk/test/error-fixup-target.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/error-fixup-target.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/error-fixup-target.objtxt (original)
+++ lld/trunk/test/error-fixup-target.objtxt Fri Jan 4 20:22:35 2013
@@ -6,7 +6,7 @@
#
---
-atoms:
+defined-atoms:
- name: entry
scope: hidden
fixups:
@@ -17,11 +17,10 @@
kind: 3
target: baz
+undefined-atoms:
- name: bar
- definition: undefined
...
-# CHECK: error: Fixup has target 'baz' which does not exist
-# CHECK: baz
+# CHECK: error: no such atom name: baz
Modified: lld/trunk/test/fixups-addend.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/fixups-addend.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/fixups-addend.objtxt (original)
+++ lld/trunk/test/fixups-addend.objtxt Fri Jan 4 20:22:35 2013
@@ -5,7 +5,7 @@
#
---
-atoms:
+defined-atoms:
- name: foo
type: code
content: [ 48, 8D, 3D, 00, 00, 00, 00,
@@ -34,8 +34,8 @@
target: bar
addend: -50
+undefined-atoms:
- name: bar
- definition: undefined
...
Modified: lld/trunk/test/fixups-dup-named.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/fixups-dup-named.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/fixups-dup-named.objtxt (original)
+++ lld/trunk/test/fixups-dup-named.objtxt Fri Jan 4 20:22:35 2013
@@ -5,7 +5,7 @@
#
---
-atoms:
+defined-atoms:
- name: foo
type: code
content: [ E8, 00, 00, 00, 00, E8, 00, 00, 00, 00 ]
Modified: lld/trunk/test/fixups-named.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/fixups-named.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/fixups-named.objtxt (original)
+++ lld/trunk/test/fixups-named.objtxt Fri Jan 4 20:22:35 2013
@@ -5,10 +5,11 @@
#
---
-atoms:
+defined-atoms:
- name: foo
type: code
- content: [ E8, 00, 00, 00, 00, E8, 00, 00, 00, 00 ]
+ content: [ E8, 00, 00, 00, 00,
+ E8, 00, 00, 00, 00 ]
fixups:
- offset: 1
kind: 3
@@ -21,8 +22,8 @@
scope: static
type: code
+undefined-atoms:
- name: bar
- definition: undefined
...
Modified: lld/trunk/test/fixups-unnamed.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/fixups-unnamed.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/fixups-unnamed.objtxt (original)
+++ lld/trunk/test/fixups-unnamed.objtxt Fri Jan 4 20:22:35 2013
@@ -5,7 +5,7 @@
#
---
-atoms:
+defined-atoms:
- name: foo
type: code
content: [ 48, 8D, 3D, 00, 00, 00, 00,
Modified: lld/trunk/test/inline-coalesce.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/inline-coalesce.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/inline-coalesce.objtxt (original)
+++ lld/trunk/test/inline-coalesce.objtxt Fri Jan 4 20:22:35 2013
@@ -5,30 +5,27 @@
#
---
-atoms:
+defined-atoms:
- name: _inlineFunc
scope: global
- definition: regular
type: code
- merge: asWeak
+ merge: as-weak
---
-atoms:
+defined-atoms:
- name: _inlineFunc
scope: global
- definition: regular
type: code
- merge: asWeak
+ merge: as-weak
---
-atoms:
+defined-atoms:
- name: _inlineFunc
scope: global
- definition: regular
type: code
- merge: asWeak
+ merge: as-weak
...
# CHECK: name: _inlineFunc
-# CHECK: merge: asWeak
+# CHECK: merge: as-weak
# CHECK-NOT: name: _inlineFunc
# CHECK: ...
Modified: lld/trunk/test/multiple-def-error.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/multiple-def-error.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/multiple-def-error.objtxt (original)
+++ lld/trunk/test/multiple-def-error.objtxt Fri Jan 4 20:22:35 2013
@@ -7,15 +7,13 @@
# CHECK: duplicate symbol
---
-atoms:
+defined-atoms:
- name: _foo
- definition: regular
scope: global
type: data
---
-atoms:
+defined-atoms:
- name: _foo
- definition: regular
scope: global
type: data
...
Modified: lld/trunk/test/pass-got-basic.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/pass-got-basic.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/pass-got-basic.objtxt (original)
+++ lld/trunk/test/pass-got-basic.objtxt Fri Jan 4 20:22:35 2013
@@ -5,7 +5,7 @@
#
---
-atoms:
+defined-atoms:
- name: foo
type: code
content: [ 48, 8B, 0D, 00, 00, 00, 00,
@@ -43,32 +43,33 @@
scope: global
interposable: yes
+shared-library-atoms:
- name: malloc
- definition: shared-library
load-name: libc.so
...
+# CHECK: defined-atoms:
# CHECK: name: foo
# CHECK: fixups:
-# CHECK: offset: 3
-# CHECK: kind: pcrel32
-# CHECK: target: L
-# CHECK: offset: 10
-# CHECK: kind: lea32wasGot
-# CHECK: target: myPrivate
-# CHECK: offset: 17
-# CHECK: kind: pcrel32
-# CHECK: target: L
-# CHECK: offset: 24
-# CHECK: kind: pcrel32
-# CHECK: target: L
-# CHECK: offset: 32
-# CHECK: kind: pcrel32
-# CHECK: target: L
-# CHECK: offset: 40
-# CHECK: kind: pcrel32
-# CHECK: target: L
+# CHECK: kind: pcrel32
+# CHECK: offset: 3
+# CHECK: target: L
+# CHECK: kind: lea32wasGot
+# CHECK: offset: 10
+# CHECK: target: myPrivate
+# CHECK: kind: pcrel32
+# CHECK: offset: 17
+# CHECK: target: L
+# CHECK: kind: pcrel32
+# CHECK: offset: 24
+# CHECK: target: L
+# CHECK: kind: pcrel32
+# CHECK: offset: 32
+# CHECK: target: L
+# CHECK: kind: pcrel32
+# CHECK: offset: 40
+# CHECK: target: L
# CHECK: name: myPrivate
# CHECK: name: myInterposable
# CHECK: interposable: yes
@@ -76,6 +77,6 @@
# CHECK: type: got
# CHECK: type: got
# CHECK: type: got
+# CHECK: shared-library-atoms:
# CHECK: name: malloc
-# CHECK: definition: shared-library
# CHECK: ...
Modified: lld/trunk/test/pass-stubs-basic.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/pass-stubs-basic.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/pass-stubs-basic.objtxt (original)
+++ lld/trunk/test/pass-stubs-basic.objtxt Fri Jan 4 20:22:35 2013
@@ -5,7 +5,7 @@
#
---
-atoms:
+defined-atoms:
- name: foo
type: code
content: [ E8, 00, 00, 00, 00, E8, 00, 00, 00,
@@ -21,12 +21,11 @@
kind: gotLoad32
target: malloc
+shared-library-atoms:
- name: malloc
- definition: shared-library
load-name: libc.so
- name: free
- definition: shared-library
load-name: libc.so
...
@@ -44,7 +43,5 @@
# CHECK: name: L
# CHECK: type: stub
# CHECK: name: malloc
-# CHECK: definition: shared-library
# CHECK: name: free
-# CHECK: definition: shared-library
# CHECK: ...
Modified: lld/trunk/test/shared-library-basic.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/shared-library-basic.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/shared-library-basic.objtxt (original)
+++ lld/trunk/test/shared-library-basic.objtxt Fri Jan 4 20:22:35 2013
@@ -5,30 +5,25 @@
#
---
-atoms:
+shared-library-atoms:
- name: malloc
- definition: shared-library
load-name: libc.so
- name: free
- definition: shared-library
load-name: libc.so
- name: fast_malloc
- definition: shared-library
load-name: libc.so
can-be-null: at-runtime
...
+# CHECK: shared-library-atoms:
# CHECK: name: malloc
-# CHECK: definition: shared-library
# CHECK: load-name: libc.so
# CHECK: name: free
-# CHECK: definition: shared-library
# CHECK: load-name: libc.so
# CHECK: name: fast_malloc
-# CHECK: definition: shared-library
# CHECK: load-name: libc.so
# CHECK: can-be-null: at-runtime
# CHECK: ...
Modified: lld/trunk/test/shared-library-coalesce.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/shared-library-coalesce.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/shared-library-coalesce.objtxt (original)
+++ lld/trunk/test/shared-library-coalesce.objtxt Fri Jan 4 20:22:35 2013
@@ -5,106 +5,80 @@
#
---
-atoms:
+shared-library-atoms:
- name: foo1
- definition: shared-library
load-name: libc.so
- name: foo2
- definition: shared-library
load-name: libc.so
- name: bar1
- definition: shared-library
load-name: libc.so
can-be-null: at-runtime
- name: bar2
- definition: shared-library
load-name: libc.so
can-be-null: at-runtime
- name: mismatchNull1
- definition: shared-library
load-name: libc.so
can-be-null: at-runtime
- name: mismatchNull2
- definition: shared-library
load-name: libc.so
- name: mismatchload1
- definition: shared-library
load-name: liba.so
- name: mismatchload2
- definition: shared-library
load-name: libb.so
---
-atoms:
+shared-library-atoms:
- name: foo2
- definition: shared-library
load-name: libc.so
- name: foo3
- definition: shared-library
load-name: libc.so
- name: bar2
- definition: shared-library
load-name: libc.so
can-be-null: at-runtime
- name: bar3
- definition: shared-library
load-name: libc.so
can-be-null: at-runtime
- name: mismatchNull1
- definition: shared-library
load-name: libc.so
- name: mismatchNull2
- definition: shared-library
load-name: libc.so
can-be-null: at-runtime
- name: mismatchload1
- definition: shared-library
load-name: libb.so
- name: mismatchload2
- definition: shared-library
load-name: liba.so
...
# CHECK: name: foo1
-# CHECK: definition: shared-library
# CHECK: name: foo2
-# CHECK: definition: shared-library
# CHECK: name: bar1
-# CHECK: definition: shared-library
# CHECK: can-be-null: at-runtime
# CHECK: name: bar2
-# CHECK: definition: shared-library
# CHECK: can-be-null: at-runtime
# CHECK: name: mismatchNull1
-# CHECK: definition: shared-library
# CHECK: can-be-null: at-runtime
# CHECK: name: mismatchNull2
-# CHECK: definition: shared-library
# CHECK-NOT: can-be-null: at-runtime
# CHECK: name: mismatchload1
-# CHECK: definition: shared-library
# CHECK: load-name: liba.so
# CHECK: name: mismatchload2
-# CHECK: definition: shared-library
# CHECK: load-name: libb.so
# CHECK: name: foo3
-# CHECK: definition: shared-library
# CHECK: name: bar3
-# CHECK: definition: shared-library
# CHECK: can-be-null: at-runtime
# CHECK: ...
Modified: lld/trunk/test/tent-merge.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/tent-merge.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/tent-merge.objtxt (original)
+++ lld/trunk/test/tent-merge.objtxt Fri Jan 4 20:22:35 2013
@@ -6,17 +6,15 @@
#
---
-atoms:
+defined-atoms:
- name: _foo
- definition: regular
- merge: asTentative
+ merge: as-tentative
scope: global
type: zero-fill
size: 4
---
-atoms:
+defined-atoms:
- name: _foo
- definition: regular
scope: global
type: data
content: [ 00, 00, 00, 00 ]
@@ -24,4 +22,4 @@
# CHECK: name: _foo
-# CHECK-NOT: merge: asTentative
+# CHECK-NOT: merge: as-tentative
Modified: lld/trunk/test/undef-coalesce-error.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/undef-coalesce-error.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/undef-coalesce-error.objtxt (original)
+++ lld/trunk/test/undef-coalesce-error.objtxt Fri Jan 4 20:22:35 2013
@@ -8,44 +8,40 @@
#
---
-atoms:
+defined-atoms:
- name: foo
type: code
+undefined-atoms:
- name: malloc
- definition: undefined
-
- name: free
- definition: undefined
---
-atoms:
+defined-atoms:
- name: bar
type: code
+undefined-atoms:
- name: malloc
- definition: undefined
-
- name: myfunc
- definition: undefined
---
-atoms:
+defined-atoms:
- name: myfunc
scope: global
type: code
+undefined-atoms:
- name: free
- definition: undefined
...
# CHECKERR: free
# CHECKERR: malloc
# CHECKERR: symbol(s) not found
+# CHECK: defined-atoms:
# CHECK: name: foo
# CHECK: name: bar
# CHECK: name: myfunc
+# CHECK: undefined-atoms:
# CHECK: name: malloc
-# CHECK: definition: undefined
# CHECK: name: free
-# CHECK: definition: undefined
# CHECK: ...
Modified: lld/trunk/test/undef-coalesce.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/undef-coalesce.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/undef-coalesce.objtxt (original)
+++ lld/trunk/test/undef-coalesce.objtxt Fri Jan 4 20:22:35 2013
@@ -6,41 +6,37 @@
#
---
-atoms:
+defined-atoms:
- name: foo
type: code
+undefined-atoms:
- name: malloc
- definition: undefined
-
- name: free
- definition: undefined
---
-atoms:
+defined-atoms:
- name: bar
type: code
+undefined-atoms:
- name: malloc
- definition: undefined
-
- name: myfunc
- definition: undefined
---
-atoms:
+defined-atoms:
- name: myfunc
scope: global
type: code
+undefined-atoms:
- name: free
- definition: undefined
...
+# CHECK: defined-atoms:
# CHECK: name: foo
# CHECK: name: bar
# CHECK: name: myfunc
# CHECK: scope: global
+# CHECK: undefined-atoms:
# CHECK: name: malloc
-# CHECK: definition: undefined
# CHECK: name: free
-# CHECK: definition: undefined
# CHECK: ...
Modified: lld/trunk/test/undef-weak-coalesce.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/undef-weak-coalesce.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/undef-weak-coalesce.objtxt (original)
+++ lld/trunk/test/undef-weak-coalesce.objtxt Fri Jan 4 20:22:35 2013
@@ -5,101 +5,77 @@
#
---
-atoms:
+undefined-atoms:
- name: regular_func
- definition: undefined
can-be-null: never
- name: weak_import_func
- definition: undefined
can-be-null: at-runtime
- name: weak_func
- definition: undefined
can-be-null: at-buildtime
- name: bar1
- definition: undefined
can-be-null: never
- name: bar2
- definition: undefined
can-be-null: at-runtime
- name: bar3
- definition: undefined
can-be-null: at-buildtime
- name: bar4
- definition: undefined
can-be-null: never
- name: bar5
- definition: undefined
can-be-null: at-runtime
- name: bar6
- definition: undefined
can-be-null: at-buildtime
- name: bar7
- definition: undefined
can-be-null: never
- name: bar8
- definition: undefined
can-be-null: at-runtime
- name: bar9
- definition: undefined
can-be-null: at-buildtime
---
-atoms:
+undefined-atoms:
- name: bar1
- definition: undefined
can-be-null: never
- name: bar2
- definition: undefined
can-be-null: at-runtime
- name: bar3
- definition: undefined
can-be-null: at-buildtime
- name: bar4
- definition: undefined
can-be-null: at-runtime
- name: bar5
- definition: undefined
can-be-null: at-buildtime
- name: bar6
- definition: undefined
can-be-null: never
- name: bar7
- definition: undefined
can-be-null: at-buildtime
- name: bar8
- definition: undefined
can-be-null: never
- name: bar9
- definition: undefined
can-be-null: at-runtime
...
# CHECK: name: regular_func
-# CHECK: definition: undefined
# CHECK: name: weak_import_func
-# CHECK: definition: undefined
# CHECK: can-be-null: at-runtime
# CHECK: name: weak_func
-# CHECK: definition: undefined
# CHECK: can-be-null: at-buildtime
# CHECK: name: bar1
# CHECK: name: bar2
Modified: lld/trunk/test/weak-coalesce.objtxt
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/weak-coalesce.objtxt?rev=171592&r1=171591&r2=171592&view=diff
==============================================================================
--- lld/trunk/test/weak-coalesce.objtxt (original)
+++ lld/trunk/test/weak-coalesce.objtxt Fri Jan 4 20:22:35 2013
@@ -5,29 +5,26 @@
#
---
-atoms:
+defined-atoms:
- name: _foo
- definition: regular
- merge: asWeak
+ merge: as-weak
scope: global
type: data
---
-atoms:
+defined-atoms:
- name: _foo
- definition: regular
scope: global
type: data
---
-atoms:
+defined-atoms:
- name: _foo
- definition: regular
- merge: asWeak
+ merge: as-weak
scope: global
type: data
...
# CHECK: name: _foo
-# CHECK-NOT: merge: asWeak
+# CHECK-NOT: merge: as-weak
# CHECK-NOT: name: _foo
# CHECK: ...
More information about the llvm-commits
mailing list