[llvm-commits] [lld] r155847 - in /lld/trunk: include/lld/Core/YamlReader.h lib/Core/YamlKeyValues.cpp lib/Core/YamlKeyValues.h lib/Core/YamlReader.cpp test/archive-basic.objtxt test/archive-chain.objtxt test/archive-tentdef-search.objtxt tools/lld-core/lld-core.cpp
Nick Kledzik
kledzik at apple.com
Mon Apr 30 16:39:27 PDT 2012
On MacOSX, I now get a error linking lld. The issue is that llvm builds with the default (gnu) C++ library, whereas lld uses the (clang) C++ library. The CMakefiles for lld automatically use -stdlib=libc++ whereas llvm does not.
I can get llvm to build with clang via -DCMAKE_C_COMPILER, but how do I get llvm to compile use libc++?
-Nick
On Apr 30, 2012, at 2:20 PM, Michael J. Spencer wrote:
> Author: mspencer
> Date: Mon Apr 30 16:20:13 2012
> New Revision: 155847
>
> URL: http://llvm.org/viewvc/llvm-project?rev=155847&view=rev
> Log:
> Convert the YAMLReader to use LLVM/Support/YAMLParser.
>
> Modified:
> lld/trunk/include/lld/Core/YamlReader.h
> lld/trunk/lib/Core/YamlKeyValues.cpp
> lld/trunk/lib/Core/YamlKeyValues.h
> lld/trunk/lib/Core/YamlReader.cpp
> lld/trunk/test/archive-basic.objtxt
> lld/trunk/test/archive-chain.objtxt
> lld/trunk/test/archive-tentdef-search.objtxt
> lld/trunk/tools/lld-core/lld-core.cpp
>
> Modified: lld/trunk/include/lld/Core/YamlReader.h
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/include/lld/Core/YamlReader.h?rev=155847&r1=155846&r2=155847&view=diff
> ==============================================================================
> --- lld/trunk/include/lld/Core/YamlReader.h (original)
> +++ lld/trunk/include/lld/Core/YamlReader.h Mon Apr 30 16:20:13 2012
> @@ -14,6 +14,7 @@
>
> #include "llvm/Support/system_error.h"
>
> +#include <memory>
> #include <vector>
>
> namespace llvm {
> @@ -33,14 +34,15 @@
> /// the specified vector<File*>.
> error_code parseObjectTextFileOrSTDIN( StringRef path
> , Platform&
> - , std::vector<const File *>&);
> + , std::vector<
> + std::unique_ptr<const File>>&);
>
>
> /// parseObjectText - Parse the specified YAML formatted MemoryBuffer
> /// into lld::File object(s) and append each to the specified vector<File*>.
> error_code parseObjectText( llvm::MemoryBuffer *mb
> , Platform&
> - , std::vector<const File *>&);
> + , std::vector<std::unique_ptr<const File>>&);
>
> } // namespace yaml
> } // namespace lld
>
> Modified: lld/trunk/lib/Core/YamlKeyValues.cpp
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/Core/YamlKeyValues.cpp?rev=155847&r1=155846&r2=155847&view=diff
> ==============================================================================
> --- lld/trunk/lib/Core/YamlKeyValues.cpp (original)
> +++ lld/trunk/lib/Core/YamlKeyValues.cpp Mon Apr 30 16:20:13 2012
> @@ -73,9 +73,9 @@
> { nullptr, File::kindObject }
> };
>
> - File::Kind KeyValues::fileKind(const char* str) {
> + File::Kind KeyValues::fileKind(StringRef str) {
> for (const FileKindMapping* p = fileKindMappings; p->string != nullptr; ++p) {
> - if ( strcmp(p->string, str) == 0 )
> + if (str == p->string)
> return p->value;
> }
> llvm::report_fatal_error("bad file kind value");
> @@ -103,10 +103,10 @@
> { nullptr, Atom::definitionRegular }
> };
>
> -Atom::Definition KeyValues::definition(const char* s)
> +Atom::Definition KeyValues::definition(StringRef s)
> {
> for (const DefinitionMapping* p = defMappings; p->string != nullptr; ++p) {
> - if ( strcmp(p->string, s) == 0 )
> + if (s == p->string)
> return p->value;
> }
> llvm::report_fatal_error("bad definition value");
> @@ -136,10 +136,10 @@
> { nullptr, DefinedAtom::scopeGlobal }
> };
>
> -DefinedAtom::Scope KeyValues::scope(const char* s)
> +DefinedAtom::Scope KeyValues::scope(StringRef s)
> {
> for (const ScopeMapping* p = scopeMappings; p->string != nullptr; ++p) {
> - if ( strcmp(p->string, s) == 0 )
> + if (s == p->string)
> return p->value;
> }
> llvm::report_fatal_error("bad scope value");
> @@ -197,10 +197,10 @@
> { nullptr, DefinedAtom::typeUnknown }
> };
>
> -DefinedAtom::ContentType KeyValues::contentType(const char* s)
> +DefinedAtom::ContentType KeyValues::contentType(StringRef s)
> {
> for (const ContentTypeMapping* p = typeMappings; p->string != nullptr; ++p) {
> - if ( strcmp(p->string, s) == 0 )
> + if (s == p->string)
> return p->value;
> }
> llvm::report_fatal_error("bad content type value");
> @@ -232,11 +232,11 @@
> { nullptr, DefinedAtom::deadStripNormal }
> };
>
> -DefinedAtom::DeadStripKind KeyValues::deadStripKind(const char* s)
> +DefinedAtom::DeadStripKind KeyValues::deadStripKind(StringRef s)
> {
> for (const DeadStripMapping* p = deadStripMappings; p->string != nullptr; ++p)
> {
> - if ( strcmp(p->string, s) == 0 )
> + if (s == p->string)
> return p->value;
> }
> llvm::report_fatal_error("bad dead strip value");
> @@ -267,10 +267,10 @@
> { nullptr, DefinedAtom::interposeNo }
> };
>
> -DefinedAtom::Interposable KeyValues::interposable(const char* s)
> +DefinedAtom::Interposable KeyValues::interposable(StringRef s)
> {
> for (const InterposableMapping* p = interMappings; p->string != nullptr; ++p){
> - if ( strcmp(p->string, s) == 0 )
> + if (s == p->string)
> return p->value;
> }
> llvm::report_fatal_error("bad interposable value");
> @@ -302,10 +302,10 @@
> { nullptr, DefinedAtom::mergeNo }
> };
>
> -DefinedAtom::Merge KeyValues::merge(const char* s)
> +DefinedAtom::Merge KeyValues::merge(StringRef s)
> {
> for (const MergeMapping* p = mergeMappings; p->string != nullptr; ++p) {
> - if ( strcmp(p->string, s) == 0 )
> + if (s == p->string)
> return p->value;
> }
> llvm::report_fatal_error("bad merge value");
> @@ -336,10 +336,10 @@
> { nullptr, DefinedAtom::sectionBasedOnContent }
> };
>
> -DefinedAtom::SectionChoice KeyValues::sectionChoice(const char* s)
> +DefinedAtom::SectionChoice KeyValues::sectionChoice(StringRef s)
> {
> for (const SectionChoiceMapping* p = sectMappings; p->string != nullptr; ++p){
> - if ( strcmp(p->string, s) == 0 )
> + if (s == p->string)
> return p->value;
> }
> llvm::report_fatal_error("bad dead strip value");
> @@ -373,10 +373,10 @@
> { nullptr, DefinedAtom::perm___ }
> };
>
> -DefinedAtom::ContentPermissions KeyValues::permissions(const char* s)
> +DefinedAtom::ContentPermissions KeyValues::permissions(StringRef s)
> {
> for (const PermissionsMapping* p = permMappings; p->string != nullptr; ++p) {
> - if ( strcmp(p->string, s) == 0 )
> + if (s == p->string)
> return p->value;
> }
> llvm::report_fatal_error("bad permissions value");
> @@ -390,37 +390,10 @@
> llvm::report_fatal_error("bad permissions value");
> }
>
> -
> -
> -
> -
> -
> -
> -bool KeyValues::isThumb(const char* s)
> -{
> - if ( strcmp(s, "true") == 0 )
> - return true;
> - else if ( strcmp(s, "false") == 0 )
> - return false;
> - llvm::report_fatal_error("bad is-thumb value");
> -}
> -
> const char* KeyValues::isThumb(bool b) {
> return b ? "true" : "false";
> }
>
> -
> -
> -
> -bool KeyValues::isAlias(const char* s)
> -{
> - if ( strcmp(s, "true") == 0 )
> - return true;
> - else if ( strcmp(s, "false") == 0 )
> - return false;
> - llvm::report_fatal_error("bad is-alias value");
> -}
> -
> const char* KeyValues::isAlias(bool b) {
> return b ? "true" : "false";
> }
> @@ -441,10 +414,10 @@
> };
>
>
> -UndefinedAtom::CanBeNull KeyValues::canBeNull(const char* s)
> +UndefinedAtom::CanBeNull KeyValues::canBeNull(StringRef s)
> {
> for (const CanBeNullMapping* p = cbnMappings; p->string != nullptr; ++p) {
> - if ( strcmp(p->string, s) == 0 )
> + if (s == p->string)
> return p->value;
> }
> llvm::report_fatal_error("bad can-be-null value");
>
> Modified: lld/trunk/lib/Core/YamlKeyValues.h
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/Core/YamlKeyValues.h?rev=155847&r1=155846&r2=155847&view=diff
> ==============================================================================
> --- lld/trunk/lib/Core/YamlKeyValues.h (original)
> +++ lld/trunk/lib/Core/YamlKeyValues.h Mon Apr 30 16:20:13 2012
> @@ -15,7 +15,6 @@
> #include "lld/Core/UndefinedAtom.h"
> #include "lld/Core/File.h"
>
> -
> namespace lld {
> namespace yaml {
>
> @@ -34,62 +33,60 @@
>
> static const char* const fileKindKeyword;
> static const File::Kind fileKindDefault;
> - static File::Kind fileKind(const char*);
> + static File::Kind fileKind(StringRef);
> static const char* fileKind(File::Kind);
>
> static const char* const definitionKeyword;
> static const Atom::Definition definitionDefault;
> - static Atom::Definition definition(const char*);
> + static Atom::Definition definition(StringRef);
> static const char* definition(Atom::Definition);
>
> static const char* const scopeKeyword;
> static const DefinedAtom::Scope scopeDefault;
> - static DefinedAtom::Scope scope(const char*);
> + static DefinedAtom::Scope scope(StringRef);
> static const char* scope(DefinedAtom::Scope);
>
> static const char* const contentTypeKeyword;
> static const DefinedAtom::ContentType contentTypeDefault;
> - static DefinedAtom::ContentType contentType(const char*);
> + static DefinedAtom::ContentType contentType(StringRef);
> static const char* contentType(DefinedAtom::ContentType);
>
> static const char* const deadStripKindKeyword;
> static const DefinedAtom::DeadStripKind deadStripKindDefault;
> - static DefinedAtom::DeadStripKind deadStripKind(const char*);
> + static DefinedAtom::DeadStripKind deadStripKind(StringRef);
> static const char* deadStripKind(DefinedAtom::DeadStripKind);
>
> static const char* const sectionChoiceKeyword;
> static const DefinedAtom::SectionChoice sectionChoiceDefault;
> - static DefinedAtom::SectionChoice sectionChoice(const char*);
> + static DefinedAtom::SectionChoice sectionChoice(StringRef);
> static const char* sectionChoice(DefinedAtom::SectionChoice);
>
> static const char* const interposableKeyword;
> static const DefinedAtom::Interposable interposableDefault;
> - static DefinedAtom::Interposable interposable(const char*);
> + static DefinedAtom::Interposable interposable(StringRef);
> static const char* interposable(DefinedAtom::Interposable);
>
> static const char* const mergeKeyword;
> static const DefinedAtom::Merge mergeDefault;
> - static DefinedAtom::Merge merge(const char*);
> + static DefinedAtom::Merge merge(StringRef);
> static const char* merge(DefinedAtom::Merge);
>
> static const char* const permissionsKeyword;
> static const DefinedAtom::ContentPermissions permissionsDefault;
> - static DefinedAtom::ContentPermissions permissions(const char*);
> + static DefinedAtom::ContentPermissions permissions(StringRef);
> static const char* permissions(DefinedAtom::ContentPermissions);
>
> static const char* const isThumbKeyword;
> static const bool isThumbDefault;
> - static bool isThumb(const char*);
> static const char* isThumb(bool);
>
> static const char* const isAliasKeyword;
> static const bool isAliasDefault;
> - static bool isAlias(const char*);
> static const char* isAlias(bool);
>
> static const char* const canBeNullKeyword;
> static const UndefinedAtom::CanBeNull canBeNullDefault;
> - static UndefinedAtom::CanBeNull canBeNull(const char*);
> + static UndefinedAtom::CanBeNull canBeNull(StringRef);
> static const char* canBeNull(UndefinedAtom::CanBeNull);
>
>
> @@ -104,4 +101,3 @@
> } // namespace lld
>
> #endif // LLD_CORE_YAML_KEY_VALUES_H_
> -
>
> Modified: lld/trunk/lib/Core/YamlReader.cpp
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/Core/YamlReader.cpp?rev=155847&r1=155846&r2=155847&view=diff
> ==============================================================================
> --- lld/trunk/lib/Core/YamlReader.cpp (original)
> +++ lld/trunk/lib/Core/YamlReader.cpp Mon Apr 30 16:20:13 2012
> @@ -24,244 +24,54 @@
> #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/ErrorHandling.h"
> #include "llvm/Support/MemoryBuffer.h"
> +#include "llvm/Support/SourceMgr.h"
> #include "llvm/Support/system_error.h"
> +#include "llvm/Support/YAMLParser.h"
>
> #include <cstring>
> -#include <vector>
> #include <set>
> +#include <type_traits>
> +#include <vector>
>
> +using namespace lld;
>
> +static bool getAs(const llvm::yaml::ScalarNode *SN, bool &Result) {
> + SmallString<4> Storage;
> + StringRef Value = SN->getValue(Storage);
> + if (Value == "true")
> + Result = true;
> + else if (Value == "false")
> + Result = false;
> + else
> + return false;
> + return true;
> +}
> +
> +template<class T>
> +typename std::enable_if<std::numeric_limits<T>::is_integer, bool>::type
> +getAs(const llvm::yaml::ScalarNode *SN, T &Result) {
> + SmallString<4> Storage;
> + StringRef Value = SN->getValue(Storage);
> + if (Value.getAsInteger(0, Result))
> + return false;
> + return true;
> +}
>
> namespace lld {
> namespace yaml {
>
> -namespace {
> -
> -class YAML {
> -public:
> - struct Entry {
> - Entry(const char *k, const char *v, std::vector<uint8_t>* vs,
> - int d, bool bd, bool bs)
> - : key(strdup(k))
> - , value(v ? strdup(v) : nullptr)
> - , valueSequenceBytes(vs)
> - , depth(d)
> - , beginSequence(bs)
> - , beginDocument(bd) {}
> -
> - const char * key;
> - const char * value;
> - std::vector<uint8_t>* valueSequenceBytes;
> - int depth;
> - bool beginSequence;
> - bool beginDocument;
> - };
> -
> - static void parse(llvm::MemoryBuffer *mb, std::vector<const Entry *>&);
> -
> -private:
> - enum State {
> - start,
> - inHeaderComment,
> - inTripleDash,
> - inTriplePeriod,
> - inDocument,
> - inKey,
> - inSpaceBeforeValue,
> - inValue,
> - inValueSequence,
> - inValueSequenceEnd
> - };
> -};
> -
> -
> -void YAML::parse(llvm::MemoryBuffer *mb, std::vector<const Entry *> &entries) {
> - State state = start;
> - char key[64];
> - char value[64];
> - char *p = nullptr;
> - unsigned int lineNumber = 1;
> - int depth = 0;
> - bool nextKeyIsStartOfDocument = false;
> - bool nextKeyIsStartOfSequence = false;
> - std::vector<uint8_t>* sequenceBytes = nullptr;
> - unsigned contentByte = 0;
> - for (const char *s = mb->getBufferStart(); s < mb->getBufferEnd(); ++s) {
> - char c = *s;
> - if (c == '\n')
> - ++lineNumber;
> - switch (state) {
> - case start:
> - if (c == '#')
> - state = inHeaderComment;
> - else if (c == '-') {
> - p = &key[0];
> - *p++ = c;
> - state = inTripleDash;
> - }
> - break;
> - case inHeaderComment:
> - if (c == '\n') {
> - state = start;
> - }
> - break;
> - case inTripleDash:
> - if (c == '-') {
> - *p++ = c;
> - } else if (c == '\n') {
> - *p = '\0';
> - if (strcmp(key, "---") != 0)
> - return;
> - depth = 0;
> - state = inDocument;
> - nextKeyIsStartOfDocument = true;
> - } else {
> - return;
> - }
> - break;
> - case inTriplePeriod:
> - if (c == '.') {
> - *p++ = c;
> - } else if (c == '\n') {
> - *p = '\0';
> - if (strcmp(key, "...") != 0)
> - return;
> - depth = 0;
> - state = inHeaderComment;
> - } else {
> - return;
> - }
> - break;
> - case inDocument:
> - if (isalnum(c)) {
> - state = inKey;
> - p = &key[0];
> - *p++ = c;
> - } else if (c == '-') {
> - if (depth == 0) {
> - p = &key[0];
> - *p++ = c;
> - state = inTripleDash;
> - } else {
> - nextKeyIsStartOfSequence = true;
> - ++depth;
> - }
> - } else if (c == ' ') {
> - ++depth;
> - } else if (c == '.') {
> - p = &key[0];
> - *p++ = c;
> - state = inTriplePeriod;
> - } else if (c == '\n') {
> - // ignore empty lines
> - depth = 0;
> - } else if (c == '\t') {
> - llvm::report_fatal_error("TAB character found in yaml file");
> - } else {
> - return;
> - }
> - break;
> - case inKey:
> - if (isalnum(c) || (c == '-')) {
> - *p++ = c;
> - } else if (c == ':') {
> - *p = '\0';
> - state = inSpaceBeforeValue;
> - } else if (c == '\n') {
> - *p = '\0';
> - if (strcmp(key, "---") == 0)
> - state = inDocument;
> - else
> - return;
> - } else {
> - return;
> - }
> - break;
> - case inSpaceBeforeValue:
> - if (isalnum(c) || (c == '-') || (c == '_') || (c == '/')) {
> - p = &value[0];
> - *p++ = c;
> - state = inValue;
> - } else if (c == '\n') {
> - entries.push_back(new Entry(key, "", nullptr, depth,
> - nextKeyIsStartOfDocument,
> - nextKeyIsStartOfSequence));
> - nextKeyIsStartOfSequence = false;
> - nextKeyIsStartOfDocument = false;
> - state = inDocument;
> - depth = 0;
> - } else if (c == '[') {
> - contentByte = 0;
> - sequenceBytes = new std::vector<uint8_t>();
> - state = inValueSequence;
> - } else if (c == ' ') {
> - // eat space
> - } else if (c == '\t') {
> - llvm::report_fatal_error("TAB character found in yaml file");
> - } else {
> - return;
> - }
> - break;
> - case inValue:
> - if (c == '\n') {
> - *p = '\0';
> - entries.push_back(new Entry(key, value, nullptr, depth,
> - nextKeyIsStartOfDocument,
> - nextKeyIsStartOfSequence));
> - nextKeyIsStartOfSequence = false;
> - nextKeyIsStartOfDocument = false;
> - state = inDocument;
> - depth = 0;
> - }
> - else {
> - *p++ = c;
> - }
> - break;
> - case inValueSequence:
> - if (c == ']') {
> - sequenceBytes->push_back(contentByte);
> - state = inValueSequenceEnd;
> - }
> - else if ( (c == ' ') || (c == '\n') ) {
> - // eat white space
> - }
> - else if (c == ',') {
> - sequenceBytes->push_back(contentByte);
> - }
> - else if ( isdigit(c) ) {
> - contentByte = (contentByte << 4) | (c-'0');
> - }
> - else if ( ('a' <= tolower(c)) && (tolower(c) <= 'f') ) {
> - contentByte = (contentByte << 4) | (tolower(c)-'a'+10);
> - }
> - else {
> - llvm::report_fatal_error("non-hex digit found in content [ ]");
> - }
> - break;
> - case inValueSequenceEnd:
> - if (c == '\n') {
> - entries.push_back(new Entry(key, nullptr, sequenceBytes, depth,
> - nextKeyIsStartOfDocument,
> - nextKeyIsStartOfSequence));
> - nextKeyIsStartOfSequence = false;
> - nextKeyIsStartOfDocument = false;
> - state = inDocument;
> - depth = 0;
> - }
> - break;
> - }
> - }
> -}
> -
> -
> -
> class YAMLReference : public Reference {
> public:
> - YAMLReference() : _target(nullptr), _targetName(nullptr),
> - _offsetInAtom(0), _addend(0), _kind(0) { }
> + YAMLReference()
> + : _target(nullptr)
> + , _offsetInAtom(0)
> + , _addend(0)
> + , _kind(0)
> + {}
>
> virtual uint64_t offsetInAtom() const {
> return _offsetInAtom;
> @@ -275,7 +85,7 @@
> _kind = k;
> }
>
> - virtual const Atom* target() const {
> + virtual const Atom *target() const {
> return _target;
> }
>
> @@ -287,19 +97,17 @@
> _addend = a;
> }
>
> - virtual void setTarget(const Atom* newAtom) {
> + virtual void setTarget(const Atom *newAtom) {
> _target = newAtom;
> }
>
> - const Atom* _target;
> - const char* _targetName;
> - uint64_t _offsetInAtom;
> - Addend _addend;
> - Kind _kind;
> + const Atom *_target;
> + StringRef _targetName;
> + uint64_t _offsetInAtom;
> + Addend _addend;
> + Kind _kind;
> };
>
> -
> -
> class YAMLDefinedAtom;
>
> class YAMLFile : public ArchiveLibraryFile {
> @@ -315,16 +123,16 @@
> return _kind;
> }
>
> - virtual const atom_collection<DefinedAtom>& defined() const {
> + virtual const atom_collection<DefinedAtom> &defined() const {
> return _definedAtoms;
> }
> - virtual const atom_collection<UndefinedAtom>& undefined() const {
> + virtual const atom_collection<UndefinedAtom> &undefined() const {
> return _undefinedAtoms;
> }
> - virtual const atom_collection<SharedLibraryAtom>& sharedLibrary() const {
> + virtual const atom_collection<SharedLibraryAtom> &sharedLibrary() const {
> return _sharedLibraryAtoms;
> }
> - virtual const atom_collection<AbsoluteAtom>& absolute() const {
> + virtual const atom_collection<AbsoluteAtom> &absolute() const {
> return _absoluteAtoms;
> }
>
> @@ -335,39 +143,37 @@
> virtual const File *find(StringRef name, bool dataSymbolOnly) const;
>
> void bindTargetReferences();
> - void addDefinedAtom(YAMLDefinedAtom* atom, const char* refName);
> - void addUndefinedAtom(UndefinedAtom* atom);
> - void addSharedLibraryAtom(SharedLibraryAtom* atom);
> - void addAbsoluteAtom(AbsoluteAtom* atom);
> - Atom* findAtom(const char* name);
> - void addMember(const char*);
> - void setName(const char*);
> + void addDefinedAtom(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);
>
> struct NameAtomPair {
> - NameAtomPair(const char* n, Atom* a) : name(n), atom(a) {}
> - const char* name;
> - Atom* atom;
> + 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<const char*> _memberNames;
> - std::vector<YAMLFile*> _memberFiles;
> - unsigned int _lastRefIndex;
> - File::Kind _kind;
> - bool _inArchive;
> + 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<StringRef> _memberNames;
> + std::vector<std::unique_ptr<YAMLFile>> _memberFiles;
> + unsigned int _lastRefIndex;
> + File::Kind _kind;
> + bool _inArchive;
> };
>
> -
> -
> class YAMLDefinedAtom : public DefinedAtom {
> public:
> YAMLDefinedAtom( uint32_t ord
> - , YAMLFile& file
> + , YAMLFile &file
> , DefinedAtom::Scope scope
> , DefinedAtom::ContentType type
> , DefinedAtom::SectionChoice sectionChoice
> @@ -378,16 +184,16 @@
> , bool isThumb
> , bool isAlias
> , DefinedAtom::Alignment alignment
> - , const char* name
> - , const char* sectionName
> + , StringRef name
> + , StringRef sectionName
> , uint64_t size
> - , std::vector<uint8_t>* content)
> + , std::vector<uint8_t> content)
> : _file(file)
> , _name(name)
> , _sectionName(sectionName)
> , _size(size)
> , _ord(ord)
> - , _content(content)
> + , _content(std::move(content))
> , _alignment(alignment)
> , _scope(scope)
> , _type(type)
> @@ -403,19 +209,16 @@
> file._lastRefIndex = _refEndIndex;
> }
>
> - virtual const class File& file() const {
> + virtual const class File &file() const {
> return _file;
> }
>
> virtual StringRef name() const {
> - if (_name == nullptr)
> - return StringRef();
> - else
> - return _name;
> + return _name;
> }
>
> - virtual uint64_t size() const {
> - return (_content ? _content->size() : _size);
> + virtual uint64_t size() const {
> + return _content.empty() ? _size : _content.size();
> }
>
> virtual DefinedAtom::Scope scope() const {
> @@ -462,11 +265,8 @@
> return _isAlias;
> }
>
> - ArrayRef<uint8_t> rawContent() const {
> - if (_content != nullptr)
> - return ArrayRef<uint8_t>(*_content);
> - else
> - return ArrayRef<uint8_t>();
> + ArrayRef<uint8_t> rawContent() const {
> + return ArrayRef<uint8_t>(_content);
> }
>
> virtual uint64_t ordinal() const {
> @@ -499,23 +299,21 @@
> it = reinterpret_cast<const void*>(index);
> }
>
> -
> -
> void bindTargetReferences() const {
> for (unsigned int i=_refStartIndex; i < _refEndIndex; ++i) {
> - const char* targetName = _file._references[i]._targetName;
> - Atom* targetAtom = _file.findAtom(targetName);
> + StringRef targetName = _file._references[i]._targetName;
> + Atom *targetAtom = _file.findAtom(targetName);
> _file._references[i]._target = targetAtom;
> }
> }
>
> private:
> - YAMLFile& _file;
> - const char * _name;
> - const char * _sectionName;
> + YAMLFile &_file;
> + StringRef _name;
> + StringRef _sectionName;
> unsigned long _size;
> uint32_t _ord;
> - std::vector<uint8_t>* _content;
> + std::vector<uint8_t> _content;
> DefinedAtom::Alignment _alignment;
> DefinedAtom::Scope _scope;
> DefinedAtom::ContentType _type;
> @@ -530,14 +328,19 @@
> unsigned int _refEndIndex;
> };
>
> -
> class YAMLUndefinedAtom : public UndefinedAtom {
> public:
> - YAMLUndefinedAtom(YAMLFile& f, int32_t ord, const char* nm,
> - UndefinedAtom::CanBeNull cbn)
> - : _file(f), _name(nm), _ordinal(ord), _canBeNull(cbn) { }
> + YAMLUndefinedAtom( YAMLFile &f
> + , int32_t ord
> + , StringRef name
> + , UndefinedAtom::CanBeNull cbn)
> + : _file(f)
> + , _name(name)
> + , _ordinal(ord)
> + , _canBeNull(cbn) {
> + }
>
> - virtual const class File& file() const {
> + virtual const class File &file() const {
> return _file;
> }
>
> @@ -549,24 +352,28 @@
> return _canBeNull;
> }
>
> -
> private:
> - YAMLFile& _file;
> - const char * _name;
> - uint32_t _ordinal;
> - UndefinedAtom::CanBeNull _canBeNull;
> + YAMLFile &_file;
> + StringRef _name;
> + uint32_t _ordinal;
> + UndefinedAtom::CanBeNull _canBeNull;
> };
>
> -
> -
> class YAMLSharedLibraryAtom : public SharedLibraryAtom {
> public:
> - YAMLSharedLibraryAtom(YAMLFile& f, int32_t ord, const char* nm,
> - const char* ldnm, bool cbn)
> - : _file(f), _name(nm), _ordinal(ord),
> - _loadName(ldnm), _canBeNull(cbn) { }
> + YAMLSharedLibraryAtom( YAMLFile &f
> + , int32_t ord
> + , StringRef name
> + , StringRef loadName
> + , bool cbn)
> + : _file(f)
> + , _name(name)
> + , _ordinal(ord)
> + , _loadName(loadName)
> + , _canBeNull(cbn) {
> + }
>
> - virtual const class File& file() const {
> + virtual const class File &file() const {
> return _file;
> }
>
> @@ -575,33 +382,31 @@
> }
>
> virtual StringRef loadName() const {
> - if ( _loadName == nullptr )
> - return StringRef();
> - else
> - return StringRef(_loadName);
> + return _loadName;
> }
>
> virtual bool canBeNullAtRuntime() const {
> return _canBeNull;
> }
>
> -
> private:
> - YAMLFile& _file;
> - const char * _name;
> - uint32_t _ordinal;
> - const char * _loadName;
> - bool _canBeNull;
> + YAMLFile &_file;
> + StringRef _name;
> + uint32_t _ordinal;
> + StringRef _loadName;
> + bool _canBeNull;
> };
>
> -
> -
> class YAMLAbsoluteAtom : public AbsoluteAtom {
> public:
> - YAMLAbsoluteAtom(YAMLFile& f, int32_t ord, const char* nm, uint64_t v)
> - : _file(f), _name(nm), _ordinal(ord), _value(v) { }
> + YAMLAbsoluteAtom(YAMLFile &f, int32_t ord, StringRef name, uint64_t v)
> + : _file(f)
> + , _name(name)
> + , _ordinal(ord)
> + , _value(v) {
> + }
>
> - virtual const class File& file() const {
> + virtual const class File &file() const {
> return _file;
> }
>
> @@ -614,95 +419,89 @@
> }
>
> private:
> - YAMLFile& _file;
> - const char * _name;
> - uint32_t _ordinal;
> - uint64_t _value;
> + YAMLFile &_file;
> + StringRef _name;
> + uint32_t _ordinal;
> + uint64_t _value;
> };
>
> -
> -
> void YAMLFile::bindTargetReferences() {
> - for (const DefinedAtom *defAtom : _definedAtoms) {
> - const YAMLDefinedAtom* atom =
> - reinterpret_cast<const YAMLDefinedAtom*>(defAtom);
> - atom->bindTargetReferences();
> - }
> + for (const DefinedAtom *defAtom : _definedAtoms) {
> + const YAMLDefinedAtom *atom =
> + reinterpret_cast<const YAMLDefinedAtom*>(defAtom);
> + atom->bindTargetReferences();
> + }
> }
>
> -Atom* YAMLFile::findAtom(const char* name) {
> - for (std::vector<NameAtomPair>::const_iterator it = _nameToAtomMapping.begin();
> - it != _nameToAtomMapping.end(); ++it) {
> - if ( strcmp(name, it->name) == 0 )
> - return it->atom;
> +Atom *YAMLFile::findAtom(StringRef name) {
> + for (auto &ci : _nameToAtomMapping) {
> + if (ci.name == name)
> + return ci.atom;
> }
> llvm::report_fatal_error("reference to atom that does not exist");
> }
>
> -void YAMLFile::addDefinedAtom(YAMLDefinedAtom* atom, const char* refName) {
> +void YAMLFile::addDefinedAtom(YAMLDefinedAtom *atom, StringRef refName) {
> _definedAtoms._atoms.push_back(atom);
> - assert(refName != nullptr);
> _nameToAtomMapping.push_back(NameAtomPair(refName, atom));
> }
>
> -void YAMLFile::addUndefinedAtom(UndefinedAtom* atom) {
> +void YAMLFile::addUndefinedAtom(UndefinedAtom *atom) {
> _undefinedAtoms._atoms.push_back(atom);
> - _nameToAtomMapping.push_back(NameAtomPair(atom->name().data(), atom));
> + _nameToAtomMapping.push_back(NameAtomPair(atom->name(), atom));
> }
>
> -void YAMLFile::addSharedLibraryAtom(SharedLibraryAtom* atom) {
> +void YAMLFile::addSharedLibraryAtom(SharedLibraryAtom *atom) {
> _sharedLibraryAtoms._atoms.push_back(atom);
> - _nameToAtomMapping.push_back(NameAtomPair(atom->name().data(), atom));
> + _nameToAtomMapping.push_back(NameAtomPair(atom->name(), atom));
> }
>
> -void YAMLFile::addAbsoluteAtom(AbsoluteAtom* atom) {
> +void YAMLFile::addAbsoluteAtom(AbsoluteAtom *atom) {
> _absoluteAtoms._atoms.push_back(atom);
> - _nameToAtomMapping.push_back(NameAtomPair(atom->name().data(), atom));
> + _nameToAtomMapping.push_back(NameAtomPair(atom->name(), atom));
> }
>
> -void YAMLFile::addMember(const char* name) {
> +void YAMLFile::addMember(StringRef name) {
> _memberNames.push_back(name);
> }
>
> -void YAMLFile::setName(const char* name) {
> +void YAMLFile::setName(StringRef name) {
> _path = StringRef(name);
> }
>
> const File *YAMLFile::find(StringRef name, bool dataSymbolOnly) const {
> - for (YAMLFile *file : _memberFiles) {
> + for (auto &file : _memberFiles) {
> for (const DefinedAtom *atom : file->defined() ) {
> - if ( name.equals(atom->name()) )
> - return file;
> + if (name == atom->name())
> + return file.get();
> }
> }
> - return NULL;
> + return nullptr;
> }
>
> -
> -
> class YAMLAtomState {
> public:
> - YAMLAtomState(Platform& platform);
> + YAMLAtomState(Platform &platform);
>
> - void setName(const char *n);
> - void setRefName(const char *n);
> - void setAlign2(const char *n);
> + void setName(StringRef n);
> + void setRefName(StringRef n);
> + void setAlign2(StringRef n);
>
> - void setFixupKind(const char *n);
> - void setFixupTarget(const char *n);
> + void setFixupKind(StringRef n);
> + void setFixupTarget(StringRef n);
> void addFixup(YAMLFile *f);
>
> void makeAtom(YAMLFile&);
>
> - Platform& _platform;
> - const char * _name;
> - const char * _refName;
> - const char * _sectionName;
> - const char* _loadName;
> + Platform &_platform;
> + StringRef _name;
> + StringRef _refName;
> + StringRef _sectionName;
> + StringRef _loadName;
> unsigned long long _size;
> uint64_t _value;
> uint32_t _ordinal;
> - std::vector<uint8_t>* _content;
> + std::vector<uint8_t> _content;
> DefinedAtom::Alignment _alignment;
> Atom::Definition _definition;
> DefinedAtom::Scope _scope;
> @@ -719,16 +518,11 @@
> };
>
>
> -YAMLAtomState::YAMLAtomState(Platform& platform)
> +YAMLAtomState::YAMLAtomState(Platform &platform)
> : _platform(platform)
> - , _name(nullptr)
> - , _refName(nullptr)
> - , _sectionName(nullptr)
> - , _loadName(nullptr)
> , _size(0)
> , _value(0)
> , _ordinal(0)
> - , _content(nullptr)
> , _alignment(0, 0)
> , _definition(KeyValues::definitionDefault)
> , _scope(KeyValues::scopeDefault)
> @@ -740,357 +534,415 @@
> , _permissions(KeyValues::permissionsDefault)
> , _isThumb(KeyValues::isThumbDefault)
> , _isAlias(KeyValues::isAliasDefault)
> - , _canBeNull(KeyValues::canBeNullDefault)
> - {
> - }
> -
> + , _canBeNull(KeyValues::canBeNullDefault) {
> +}
>
> -void YAMLAtomState::makeAtom(YAMLFile& f) {
> - if ( _definition == Atom::definitionRegular ) {
> - YAMLDefinedAtom *a = new YAMLDefinedAtom(_ordinal, f, _scope, _type,
> - _sectionChoice, _interpose, _merge, _deadStrip,
> - _permissions, _isThumb, _isAlias,
> - _alignment, _name, _sectionName, _size, _content);
> - f.addDefinedAtom(a, _refName ? _refName : _name);
> +void YAMLAtomState::makeAtom(YAMLFile &f) {
> + if (_definition == Atom::definitionRegular) {
> + YAMLDefinedAtom *a =
> + new YAMLDefinedAtom( _ordinal
> + , f
> + , _scope
> + , _type
> + , _sectionChoice
> + , _interpose
> + , _merge
> + , _deadStrip
> + , _permissions
> + , _isThumb
> + , _isAlias
> + , _alignment
> + , _name
> + , _sectionName
> + , _size
> + , _content
> + );
> + f.addDefinedAtom(a, !_refName.empty() ? _refName : _name);
> ++_ordinal;
> - }
> - else if ( _definition == Atom::definitionUndefined ) {
> + } else if (_definition == Atom::definitionUndefined) {
> UndefinedAtom *a = new YAMLUndefinedAtom(f, _ordinal, _name, _canBeNull);
> f.addUndefinedAtom(a);
> ++_ordinal;
> - }
> - else if ( _definition == Atom::definitionSharedLibrary ) {
> + } else if (_definition == Atom::definitionSharedLibrary) {
> bool nullable = (_canBeNull == UndefinedAtom::canBeNullAtRuntime);
> SharedLibraryAtom *a = new YAMLSharedLibraryAtom(f, _ordinal, _name,
> _loadName, nullable);
> f.addSharedLibraryAtom(a);
> ++_ordinal;
> - }
> - else if ( _definition == Atom::definitionAbsolute ) {
> + } else if (_definition == Atom::definitionAbsolute) {
> AbsoluteAtom *a = new YAMLAbsoluteAtom(f, _ordinal, _name, _value);
> f.addAbsoluteAtom(a);
> ++_ordinal;
> }
>
> // reset state for next atom
> - _name = nullptr;
> - _refName = nullptr;
> - _sectionName = nullptr;
> - _loadName = nullptr;
> - _size = 0;
> - _value = 0;
> - _ordinal = 0;
> - _content = nullptr;
> - _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._targetName = nullptr;
> - _ref._addend = 0;
> - _ref._offsetInAtom = 0;
> - _ref._kind = 0;
> + _name = StringRef();
> + _refName = StringRef();
> + _sectionName = StringRef();
> + _loadName = 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._targetName = StringRef();
> + _ref._addend = 0;
> + _ref._offsetInAtom = 0;
> + _ref._kind = 0;
> }
>
> -void YAMLAtomState::setName(const char *n) {
> +void YAMLAtomState::setName(StringRef n) {
> _name = n;
> }
>
> -void YAMLAtomState::setRefName(const char *n) {
> +void YAMLAtomState::setRefName(StringRef n) {
> _refName = n;
> }
>
> -void YAMLAtomState::setAlign2(const char *s) {
> +void YAMLAtomState::setAlign2(StringRef s) {
> if (StringRef(s).getAsInteger(10, _alignment.powerOf2))
> _alignment.powerOf2 = 1;
> }
>
> -void YAMLAtomState::setFixupKind(const char *s) {
> +void YAMLAtomState::setFixupKind(StringRef s) {
> _ref._kind = _platform.kindFromString(StringRef(s));
> }
>
> -void YAMLAtomState::setFixupTarget(const char *s) {
> +void YAMLAtomState::setFixupTarget(StringRef s) {
> _ref._targetName = s;
> }
>
> -
> void YAMLAtomState::addFixup(YAMLFile *f) {
> f->_references.push_back(_ref);
> // clear for next ref
> _ref._target = nullptr;
> - _ref._targetName = nullptr;
> + _ref._targetName = StringRef();
> _ref._addend = 0;
> _ref._offsetInAtom = 0;
> _ref._kind = 0;
> }
>
> -
> -} // anonymous namespace
> -
> -
> -
> -
> -
> -/// parseObjectText - Parse the specified YAML formatted MemoryBuffer
> -/// into lld::File object(s) and append each to the specified vector<File*>.
> -error_code parseObjectText( llvm::MemoryBuffer *mb
> - , Platform& platform
> - , std::vector<const File *> &result) {
> - std::vector<const YAML::Entry *> entries;
> - std::vector<YAMLFile*> allFiles;
> - YAML::parse(mb, entries);
> -
> - YAMLFile *file = nullptr;
> - YAMLAtomState atomState(platform);
> - bool inAtoms = false;
> - bool inFixups = false;
> - bool inMembers = false;
> - int depthForAtoms = -1;
> - int depthForFixups = -1;
> - int depthForMembers= -1;
> - int lastDepth = -1;
> - bool haveAtom = false;
> - bool haveFixup = false;
> - bool hasArchives = false;
> -
> - for (std::vector<const YAML::Entry *>::iterator it = entries.begin();
> - it != entries.end(); ++it) {
> - const YAML::Entry *entry = *it;
> -
> - if (entry->beginDocument) {
> - if (file != nullptr) {
> - if (haveAtom) {
> - atomState.makeAtom(*file);
> - haveAtom = false;
> - }
> - file->bindTargetReferences();
> - allFiles.push_back(file);
> - }
> - file = new YAMLFile();
> - inAtoms = false;
> - depthForAtoms = -1;
> - }
> - if (lastDepth > entry->depth) {
> - // end of fixup sequence
> - if (haveFixup) {
> - atomState.addFixup(file);
> - haveFixup = false;
> - }
> +llvm::error_code parseFixup( llvm::yaml::MappingNode *mn
> + , llvm::yaml::Stream &s
> + , Platform &p
> + , YAMLFile &f
> + , YAMLAtomState &yas) {
> + using namespace llvm::yaml;
> + llvm::SmallString<32> storage;
> +
> + for (auto &keyval : *mn) {
> + ScalarNode *key = llvm::dyn_cast<ScalarNode>(keyval.getKey());
> + if (!key) {
> + s.printError(key, "Expected a scalar value");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + ScalarNode *value = llvm::dyn_cast<ScalarNode>(keyval.getValue());
> + if (!value) {
> + s.printError(value, "Expected a scalar value");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + llvm::StringRef keyValue = key->getValue(storage);
> + if (keyValue == KeyValues::fixupsOffsetKeyword) {
> + if (!getAs(value, yas._ref._offsetInAtom)) {
> + s.printError(value, "Invalid value for offset");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + } else if (keyValue == KeyValues::fixupsKindKeyword) {
> + yas._ref._kind = p.kindFromString(value->getValue(storage));
> + } else if (keyValue == KeyValues::fixupsTargetKeyword) {
> + // FIXME: string lifetime.
> + yas._ref._targetName = value->getValue(storage);
> + } else if (keyValue == KeyValues::fixupsAddendKeyword) {
> + if (!getAs(value, yas._ref._addend)) {
> + s.printError(value, "Invalid value for addend");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + } else {
> + s.printError(key, "Unrecognized key");
> + return make_error_code(yaml_reader_error::unknown_keyword);
> }
> + }
> + yas.addFixup(&f);
> + return make_error_code(yaml_reader_error::success);
> +}
>
> - if (inAtoms && (depthForAtoms == -1)) {
> - depthForAtoms = entry->depth;
> - }
> - if (inFixups && (depthForFixups == -1)) {
> - depthForFixups = entry->depth;
> - }
> - if (inMembers && (depthForMembers == -1)) {
> - depthForMembers = entry->depth;
> - }
> - if ( !inFixups && (strcmp(entry->key, KeyValues::fileKindKeyword) == 0) ) {
> - file->_kind = KeyValues::fileKind(entry->value);
> - if ( file->_kind == File::kindArchiveLibrary )
> - hasArchives = true;
> - }
> - else if (strcmp(entry->key, KeyValues::fileMembersKeyword) == 0) {
> - inMembers = true;
> - }
> - else if (strcmp(entry->key, KeyValues::fileAtomsKeyword) == 0) {
> - inAtoms = true;
> - }
> - else if ( !inAtoms && !inMembers
> - && (strcmp(entry->key, KeyValues::nameKeyword) == 0) ) {
> - file->setName(entry->value);
> - }
> - if (inAtoms) {
> - if (depthForAtoms == entry->depth) {
> - if (entry->beginSequence) {
> - if (haveAtom) {
> - atomState.makeAtom(*file);
> - haveAtom = false;
> - }
> - }
> - if (strcmp(entry->key, KeyValues::nameKeyword) == 0) {
> - atomState.setName(entry->value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::refNameKeyword) == 0) {
> - atomState.setRefName(entry->value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::definitionKeyword) == 0) {
> - atomState._definition = KeyValues::definition(entry->value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::scopeKeyword) == 0) {
> - atomState._scope = KeyValues::scope(entry->value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::contentTypeKeyword) == 0) {
> - atomState._type = KeyValues::contentType(entry->value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::deadStripKindKeyword) == 0) {
> - atomState._deadStrip = KeyValues::deadStripKind(entry->value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::sectionChoiceKeyword) == 0) {
> - atomState._sectionChoice = KeyValues::sectionChoice(entry->value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::mergeKeyword) == 0) {
> - atomState._merge = KeyValues::merge(entry->value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::interposableKeyword) == 0) {
> - atomState._interpose = KeyValues::interposable(entry->value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::isThumbKeyword) == 0) {
> - atomState._isThumb = KeyValues::isThumb(entry->value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::isAliasKeyword) == 0) {
> - atomState._isAlias = KeyValues::isAlias(entry->value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::canBeNullKeyword) == 0) {
> - atomState._canBeNull = KeyValues::canBeNull(entry->value);
> - if ( atomState._definition == Atom::definitionSharedLibrary ) {
> - if ( atomState._canBeNull == UndefinedAtom::canBeNullAtBuildtime )
> - return make_error_code(yaml_reader_error::illegal_value);
> - }
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::sectionNameKeyword) == 0) {
> - atomState._sectionName = entry->value;
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::sizeKeyword) == 0) {
> - StringRef val = entry->value;
> - if (val.getAsInteger(0, atomState._size))
> +llvm::error_code parseAtom( llvm::yaml::MappingNode *mn
> + , llvm::yaml::Stream &s
> + , Platform &p
> + , YAMLFile &f) {
> + using namespace llvm::yaml;
> + YAMLAtomState yas(p);
> + llvm::SmallString<32> storage;
> +
> + for (MappingNode::iterator i = mn->begin(), e = mn->end(); i != e; ++i) {
> + ScalarNode *Key = llvm::dyn_cast<ScalarNode>(i->getKey());
> + if (!Key)
> + return make_error_code(yaml_reader_error::illegal_value);
> + llvm::StringRef KeyValue = Key->getValue(storage);
> + if (KeyValue == KeyValues::contentKeyword) {
> + ScalarNode *scalarValue = llvm::dyn_cast<ScalarNode>(i->getValue());
> + if (scalarValue) {
> + yas._type = KeyValues::contentType(scalarValue->getValue(storage));
> + } else {
> + SequenceNode *Value = llvm::dyn_cast<SequenceNode>(i->getValue());
> + if (!Value) {
> + s.printError(i->getValue(), "Expected a sequence");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + for (SequenceNode::iterator ci = Value->begin(), ce = Value->end();
> + ci != ce; ++ci) {
> + ScalarNode *Entry = llvm::dyn_cast<ScalarNode>(&*ci);
> + if (!Entry) {
> + s.printError(i->getValue(), "Expected a scalar value");
> return make_error_code(yaml_reader_error::illegal_value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::contentKeyword) == 0) {
> - atomState._content = entry->valueSequenceBytes;
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, "align2") == 0) {
> - atomState.setAlign2(entry->value);
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::fixupsKeyword) == 0) {
> - inFixups = true;
> - }
> - else if (strcmp(entry->key, KeyValues::loadNameKeyword) == 0) {
> - atomState._loadName = entry->value;
> - haveAtom = true;
> - }
> - else if (strcmp(entry->key, KeyValues::valueKeyword) == 0) {
> - llvm::APInt Val;
> - StringRef(entry->value).getAsInteger(0, Val);
> - atomState._value = Val.getZExtValue();
> - haveAtom = true;
> - }
> - else {
> - return make_error_code(yaml_reader_error::unknown_keyword);
> - }
> - }
> - else if (depthForFixups == entry->depth) {
> - if (entry->beginSequence) {
> - if (haveFixup) {
> - atomState.addFixup(file);
> - haveFixup = false;
> }
> - }
> - if (strcmp(entry->key, KeyValues::fixupsKindKeyword) == 0) {
> - atomState.setFixupKind(entry->value);
> - haveFixup = true;
> - }
> - else if (strcmp(entry->key, KeyValues::fixupsOffsetKeyword) == 0) {
> - if (StringRef(entry->value).getAsInteger(0,
> - atomState._ref._offsetInAtom))
> + unsigned int ContentByte;
> + if (Entry->getValue(storage).getAsInteger(16, ContentByte)) {
> + s.printError(i->getValue(), "Invalid content byte");
> return make_error_code(yaml_reader_error::illegal_value);
> - haveFixup = true;
> - }
> - else if (strcmp(entry->key, KeyValues::fixupsTargetKeyword) == 0) {
> - atomState.setFixupTarget(entry->value);
> - haveFixup = true;
> - }
> - else if (strcmp(entry->key, KeyValues::fixupsAddendKeyword) == 0) {
> - StringRef Addend(entry->value);
> - if (Addend.getAsInteger(0, atomState._ref._addend))
> + }
> + if (ContentByte > 0xFF) {
> + s.printError(i->getValue(), "Byte out of range (> 0xFF)");
> return make_error_code(yaml_reader_error::illegal_value);
> - haveFixup = true;
> + }
> + yas._content.push_back(ContentByte & 0xFF);
> }
> }
> - }
> - else if (inMembers) {
> - if (depthForMembers == entry->depth) {
> - if (entry->beginSequence) {
> - if (strcmp(entry->key, KeyValues::nameKeyword) == 0) {
> - file->addMember(entry->value);
> - }
> + } else if (KeyValue == KeyValues::fixupsKeyword) {
> + SequenceNode *Value = llvm::dyn_cast<SequenceNode>(i->getValue());
> + if (!Value) {
> + s.printError(i->getValue(), "Expected a sequence");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + for (auto &i : *Value) {
> + MappingNode *Fixup = llvm::dyn_cast<MappingNode>(&i);
> + if (!Fixup) {
> + s.printError(&i, "Expected a map");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + if (error_code ec = parseFixup(Fixup, s, p, f, yas))
> + return ec;
> + }
> + } else {
> + // The rest of theses all require value to be a scalar.
> + ScalarNode *Value = llvm::dyn_cast<ScalarNode>(i->getValue());
> + if (!Value) {
> + s.printError(i->getValue(), "Expected a scalar value");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + if (KeyValue == KeyValues::nameKeyword) {
> + // FIXME: String lifetime.
> + yas.setName(Value->getValue(storage));
> + } else if (KeyValue == KeyValues::refNameKeyword) {
> + // FIXME: String lifetime.
> + yas.setRefName(Value->getValue(storage));
> + } else if (KeyValue == KeyValues::valueKeyword) {
> + if (!getAs(Value, yas._value)) {
> + s.printError(Value, "Invalid value for value");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + } else if (KeyValue == KeyValues::loadNameKeyword)
> + // FIXME: String lifetime.
> + yas._loadName = Value->getValue(storage);
> + else if (KeyValue == KeyValues::definitionKeyword)
> + yas._definition = KeyValues::definition(Value->getValue(storage));
> + else if (KeyValue == KeyValues::scopeKeyword)
> + yas._scope = KeyValues::scope(Value->getValue(storage));
> + else if (KeyValue == KeyValues::contentTypeKeyword)
> + yas._type = KeyValues::contentType(Value->getValue(storage));
> + else if (KeyValue == KeyValues::deadStripKindKeyword)
> + yas._deadStrip = KeyValues::deadStripKind(Value->getValue(storage));
> + else if (KeyValue == KeyValues::sectionChoiceKeyword)
> + yas._sectionChoice = KeyValues::sectionChoice(Value->getValue(storage));
> + else if (KeyValue == KeyValues::mergeKeyword)
> + yas._merge = KeyValues::merge(Value->getValue(storage));
> + else if (KeyValue == KeyValues::interposableKeyword)
> + yas._interpose = KeyValues::interposable(Value->getValue(storage));
> + else if (KeyValue == KeyValues::isThumbKeyword) {
> + if (!getAs(Value, yas._isThumb)) {
> + s.printError(Value, "Invalid value for isThumb");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + } else if (KeyValue == KeyValues::isAliasKeyword) {
> + if (!getAs(Value, yas._isAlias)) {
> + s.printError(Value, "Invalid value for isAlias");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + } else if (KeyValue == KeyValues::canBeNullKeyword) {
> + yas._canBeNull = KeyValues::canBeNull(Value->getValue(storage));
> + if (yas._definition == Atom::definitionSharedLibrary
> + && yas._canBeNull == UndefinedAtom::canBeNullAtBuildtime) {
> + s.printError(Value, "Invalid value for can be null");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + } else if (KeyValue == KeyValues::sectionNameKeyword)
> + // FIXME: String lifetime.
> + yas._sectionName = Value->getValue(storage);
> + else if (KeyValue == KeyValues::sizeKeyword) {
> + if (!getAs(Value, yas._size)) {
> + s.printError(Value, "Invalid value for size");
> + return make_error_code(yaml_reader_error::illegal_value);
> }
> + } else if (KeyValue == "align2")
> + yas.setAlign2(Value->getValue(storage));
> + else {
> + s.printError(Key, "Unrecognized key");
> + return make_error_code(yaml_reader_error::unknown_keyword);
> }
> }
> - lastDepth = entry->depth;
> }
> - if (haveAtom) {
> - atomState.makeAtom(*file);
> + yas.makeAtom(f);
> + return make_error_code(yaml_reader_error::success);
> +}
> +
> +llvm::error_code parseAtoms( llvm::yaml::SequenceNode *atoms
> + , llvm::yaml::Stream &s
> + , Platform &p
> + , YAMLFile &f) {
> + using namespace llvm::yaml;
> +
> + for (auto &atom : *atoms) {
> + if (MappingNode *a = llvm::dyn_cast<MappingNode>(&atom)) {
> + if (llvm::error_code ec = parseAtom(a, s, p, f))
> + return ec;
> + } else {
> + s.printError(&atom, "Expected map");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> }
> - if (file != nullptr) {
> - file->bindTargetReferences();
> - allFiles.push_back(file);
> - }
> -
> - // If yaml contained archive files, push members down into archives
> - if ( hasArchives ) {
> - for (YAMLFile *f : allFiles) {
> - if ( f->kind() == File::kindArchiveLibrary ) {
> - for (const char *memberName : f->_memberNames ) {
> - for (YAMLFile *f2 : allFiles) {
> - if ( f2->path().equals(memberName) ) {
> - f2->_inArchive = true;
> - f->_memberFiles.push_back(f2);
> - }
> - }
> + return make_error_code(yaml_reader_error::success);
> +}
> +
> +llvm::error_code parseArchive( llvm::yaml::SequenceNode *archive
> + , llvm::yaml::Stream &s
> + , Platform &p
> + , YAMLFile &f) {
> + using namespace llvm::yaml;
> + llvm::SmallString<32> storage;
> +
> + for (auto &member : *archive) {
> + std::unique_ptr<YAMLFile> mf(new YAMLFile);
> + MappingNode *mem = llvm::dyn_cast<MappingNode>(&member);
> + if (!mem) {
> + s.printError(&member, "Expected map");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + for (auto &keyVal : *mem) {
> + ScalarNode *key = llvm::dyn_cast<ScalarNode>(keyVal.getKey());
> + if (!key) {
> + s.printError(keyVal.getKey(), "Expected scalar value");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + if (key->getValue(storage) == "name") {
> + ScalarNode *value = llvm::dyn_cast<ScalarNode>(keyVal.getValue());
> + if (!value) {
> + s.printError(keyVal.getValue(), "Expected scalar value");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + // FIXME: String lifetime.
> + mf->setName(value->getValue(storage));
> + } else if (key->getValue(storage) == "atoms") {
> + SequenceNode *atoms = llvm::dyn_cast<SequenceNode>(keyVal.getValue());
> + if (!atoms) {
> + s.printError(keyVal.getValue(), "Expected sequence");
> + return make_error_code(yaml_reader_error::illegal_value);
> }
> + if (error_code ec = parseAtoms(atoms, s, p, *mf))
> + return ec;
> + } else {
> + s.printError(key, "Unrecognized key");
> + return make_error_code(yaml_reader_error::unknown_keyword);
> }
> }
> + f._memberFiles.push_back(std::move(mf));
> }
> - // Copy files that have not been pushed into archives to result.
> - for (YAMLFile *f : allFiles) {
> - if ( ! f->_inArchive ) {
> - result.push_back(f);
> + return make_error_code(yaml_reader_error::success);
> +}
> +
> +/// parseObjectText - Parse the specified YAML formatted MemoryBuffer
> +/// into lld::File object(s) and append each to the specified vector<File*>.
> +error_code parseObjectText( llvm::MemoryBuffer *mb
> + , Platform& platform
> + , std::vector<std::unique_ptr<const File>> &result) {
> + using namespace llvm::yaml;
> + llvm::SourceMgr sm;
> + Stream stream(mb->getBuffer(), sm);
> +
> + llvm::SmallString<32> storage;
> + for (Document &d : stream) {
> + std::unique_ptr<YAMLFile> CurFile(new YAMLFile);
> + if (llvm::isa<NullNode>(d.getRoot()))
> + continue; // Empty files are allowed.
> + MappingNode *n = llvm::dyn_cast<MappingNode>(d.getRoot());
> + if (!n) {
> + stream.printError(d.getRoot(), "Expected map");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + for (MappingNode::iterator mi = n->begin(), me = n->end(); mi != me; ++mi) {
> + ScalarNode *key = llvm::dyn_cast<ScalarNode>(mi->getKey());
> + if (!key) {
> + stream.printError(mi->getValue(), "Expected scalar value");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + if (key->getValue(storage) == "atoms") {
> + SequenceNode *Atoms = llvm::dyn_cast<SequenceNode>(mi->getValue());
> + if (!Atoms) {
> + stream.printError(mi->getValue(), "Expected sequence");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + if (error_code ec = parseAtoms(Atoms, stream, platform, *CurFile))
> + return ec;
> + } else if (key->getValue(storage) == "archive") {
> + CurFile->_kind = YAMLFile::kindArchiveLibrary;
> + SequenceNode *members = llvm::dyn_cast<SequenceNode>(mi->getValue());
> + if (!members) {
> + stream.printError(mi->getValue(), "Expected sequence");
> + return make_error_code(yaml_reader_error::illegal_value);
> + }
> + if (error_code ec = parseArchive( members
> + , stream
> + , platform
> + , *CurFile))
> + return ec;
> + } else {
> + stream.printError(key, "Unrecognized key");
> + return make_error_code(yaml_reader_error::unknown_keyword);
> + }
> }
> + if (stream.failed())
> + return make_error_code(yaml_reader_error::illegal_value);
> + CurFile->bindTargetReferences();
> + result.emplace_back(CurFile.release());
> }
>
> return make_error_code(yaml_reader_error::success);
> }
>
> -
> //
> // Fill in vector<File*> from path to input text file.
> //
> error_code parseObjectTextFileOrSTDIN( StringRef path
> , Platform& platform
> - , std::vector<const File*>& result) {
> + , std::vector<
> + std::unique_ptr<const File>>& result) {
> OwningPtr<llvm::MemoryBuffer> mb;
> if (error_code ec = llvm::MemoryBuffer::getFileOrSTDIN(path, mb))
> return ec;
>
> - return parseObjectText(mb.get(), platform, result);
> + return parseObjectText(mb.take(), platform, result);
> }
>
> } // namespace yaml
>
> Modified: lld/trunk/test/archive-basic.objtxt
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/archive-basic.objtxt?rev=155847&r1=155846&r2=155847&view=diff
> ==============================================================================
> --- lld/trunk/test/archive-basic.objtxt (original)
> +++ lld/trunk/test/archive-basic.objtxt Mon Apr 30 16:20:13 2012
> @@ -9,34 +9,29 @@
> atoms:
> - name: foo
> type: code
> -
> +
> - name: bar
> definition: undefined
>
> ---
> -name: bar.o
> -atoms:
> - - name: bar
> - scope: global
> - type: code
> -
> - - name: bar2
> - type: code
> -
> ----
> -name: baz.o
> -atoms:
> - - name: baz
> - scope: global
> - type: code
> -
> - - name: baz2
> - type: code
> ----
> -kind: archive
> -members:
> - - name: bar.o
> - - name: baz.o
> +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
> +
> + - name: baz2
> + type: code
> ...
>
> # CHECK: name: foo
>
> Modified: lld/trunk/test/archive-chain.objtxt
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/test/archive-chain.objtxt?rev=155847&r1=155846&r2=155847&view=diff
> ==============================================================================
> --- lld/trunk/test/archive-chain.objtxt (original)
> +++ lld/trunk/test/archive-chain.objtxt Mon Apr 30 16:20:13 2012
> @@ -8,60 +8,52 @@
> atoms:
> - name: foo
> type: code
> -
> - - name: bar1
> - definition: undefined
>
> ----
> -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
> -
> - - name: bar2b
> - type: code
> -
> ----
> -name: baz1.o
> -atoms:
> - - name: baz1
> - scope: global
> - type: code
> -
> - - name: baz1b
> - type: code
> ----
> -name: baz2.o
> -atoms:
> - - name: baz2
> - scope: global
> - type: code
> -
> - - name: baz2b
> - type: code
> ----
> -kind: archive
> -members:
> - - name: bar1.o
> - - name: bar2.o
> +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
> +
> + - name: bar2b
> + type: code
> +
> ---
> -kind: archive
> -members:
> - - name: baz1.o
> - - name: baz2.o
> +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
> +
> + - 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=155847&r1=155846&r2=155847&view=diff
> ==============================================================================
> --- lld/trunk/test/archive-tentdef-search.objtxt (original)
> +++ lld/trunk/test/archive-tentdef-search.objtxt Mon Apr 30 16:20:13 2012
> @@ -11,26 +11,22 @@
> atoms:
> - name: foo
> type: code
> -
> +
> - name: bar
> scope: global
> content: zero-fill
> merge: asTentative
>
> ---
> -name: bar.o
> -atoms:
> - - name: bar
> - scope: global
> - type: data
> -
> - - name: bar2
> - type: data
> -
> ----
> -kind: archive
> -members:
> - - name: bar.o
> +archive:
> + - name: bar.o
> + - atoms:
> + - name: bar
> + scope: global
> + type: data
> +
> + - name: bar2
> + type: data
> ...
>
> # CHK1: name: foo
>
> Modified: lld/trunk/tools/lld-core/lld-core.cpp
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/tools/lld-core/lld-core.cpp?rev=155847&r1=155846&r2=155847&view=diff
> ==============================================================================
> --- lld/trunk/tools/lld-core/lld-core.cpp (original)
> +++ lld/trunk/tools/lld-core/lld-core.cpp Mon Apr 30 16:20:13 2012
> @@ -422,7 +422,7 @@
> llvm::cl::ParseCommandLineOptions(argc, argv);
>
> // create platform for testing
> - Platform* platform = NULL;
> + Platform* platform = nullptr;
> switch ( platformSelected ) {
> case platformTesting:
> platform = new TestingPlatform();
> @@ -433,7 +433,7 @@
> }
>
> // read input YAML doc into object file(s)
> - std::vector<const File *> files;
> + std::vector<std::unique_ptr<const File>> files;
> if (error(yaml::parseObjectTextFileOrSTDIN(cmdLineInputFilePath,
> *platform, files))) {
> return 1;
> @@ -444,7 +444,7 @@
>
> // create object to mange input files
> InputFiles inputFiles;
> - for (const File *file : files) {
> + for (const auto &file : files) {
> inputFiles.appendFile(*file);
> }
>
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list