[LLD] Fix Clang-tidy readability-redundant-member-init warnings; other minor fixes

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

[ruiu]

LGTM

lld/trunk/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

 };
 
 } // end anonymous namespace
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(ArchMember)
 LLVM_YAML_IS_SEQUENCE_VECTOR(const lld::Reference *)
 // Always write DefinedAtoms content bytes as a flow sequence.
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(ImplicitHex8)
+
 // for compatibility with gcc-4.7 in C++11 mode, add extra namespace
 namespace llvm {
 namespace yaml {
 
 // This is a custom formatter for RefKind
 template <> struct ScalarTraits<RefKind> {
   static void output(const RefKind &kind, void *ctxt, raw_ostream &out) {
     assert(ctxt != nullptr);
static const lld::File *&element(IO &io, std::vector<const lld::File *> &seq,
     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) : ArchiveLibraryFile("") {}
+
     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; }
 
template <> struct MappingTraits<const lld::File *> {
   class NormalizedFile : public lld::File {
   public:
     NormalizedFile(IO &io)
       : File("", kindNormalizedObject), _io(io), _rnb(nullptr),
         _definedAtomsRef(_definedAtoms._atoms),
         _undefinedAtomsRef(_undefinedAtoms._atoms),
         _sharedLibraryAtomsRef(_sharedLibraryAtoms._atoms),
         _absoluteAtomsRef(_absoluteAtoms._atoms) {}
+
     NormalizedFile(IO &io, const lld::File *file)
         : File(file->path(), kindNormalizedObject), _io(io),
           _rnb(new RefNameBuilder(*file)), _path(file->path()),
         _definedAtomsRef(file->defined()),
         _undefinedAtomsRef(file->undefined()),
         _sharedLibraryAtomsRef(file->sharedLibrary()),
         _absoluteAtomsRef(file->absolute()) {
     }
public:
     // can be freed when File is destroyed.
     StringRef copyString(StringRef str) {
       char *s = _storage.Allocate<char>(str.size());
       memcpy(s, str.data(), str.size());
       return StringRef(s, str.size());
     }
 
     IO                                  &_io;
-    std::unique_ptr<RefNameBuilder> _rnb;
+    std::unique_ptr<RefNameBuilder>      _rnb;
     StringRef                            _path;
     AtomList<lld::DefinedAtom>           _definedAtoms;
     AtomList<lld::UndefinedAtom>         _undefinedAtoms;
     AtomList<lld::SharedLibraryAtom>     _sharedLibraryAtoms;
     AtomList<lld::AbsoluteAtom>          _absoluteAtoms;
     AtomRange<lld::DefinedAtom>          _definedAtomsRef;
     AtomRange<lld::UndefinedAtom>        _undefinedAtomsRef;
     AtomRange<lld::SharedLibraryAtom>    _sharedLibraryAtomsRef;
static void mappingArchive(IO &io, const lld::File *&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)
         : lld::Reference(lld::Reference::KindNamespace::all,
                          lld::Reference::KindArch::all, 0),
-          _target(nullptr), _targetName(), _offset(0), _addend(0), _tag(0) {}
+          _target(nullptr), _offset(0), _addend(0), _tag(0) {}
 
     NormalizedReference(IO &io, const lld::Reference *ref)
         : lld::Reference(ref->kindNamespace(), ref->kindArch(),
                          ref->kindValue()),
           _target(nullptr), _targetName(targetName(io, ref)),
           _offset(ref->offsetInAtom()), _addend(ref->addend()),
           _tag(ref->tag()) {
       _mappedKind.ns = ref->kindNamespace();
const lld::Reference *denormalize(IO &io) {
                                         << _targetName << "' ("
                                         << (const void *)_targetName.data()
                                         << ", " << _targetName.size() << ")\n");
       setKindNamespace(_mappedKind.ns);
       setKindArch(_mappedKind.arch);
       setKindValue(_mappedKind.value);
       return this;
     }
+
     void bind(const RefNameResolver &);
     static StringRef targetName(IO &io, const lld::Reference *ref);
 
     uint64_t offsetInAtom() const override { return _offset; }
     const lld::Atom *target() const override { return _target; }
     Addend addend() const override { return _addend; }
     void setAddend(Addend a) override { _addend = a; }
     void setTarget(const lld::Atom *a) override { _target = a; }

 };
 
 // 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(), _contentType(),
-          _alignment(1), _content(), _references() {
+        : _file(fileFromContext(io)), _contentType(), _alignment(1) {
       static uint32_t ordinalCounter = 1;
       _ordinal = ordinalCounter++;
     }
+
     NormalizedAtom(IO &io, const lld::DefinedAtom *atom)
-        : _file(fileFromContext(io)), _name(atom->name()), _refName(),
+        : _file(fileFromContext(io)), _name(atom->name()),
           _scope(atom->scope()), _interpose(atom->interposable()),
           _merge(atom->merge()), _contentType(atom->contentType()),
           _alignment(atom->alignment()), _sectionChoice(atom->sectionChoice()),
           _deadStrip(atom->deadStrip()), _dynamicExport(atom->dynamicExport()),
           _codeModel(atom->codeModel()),
           _permissions(atom->permissions()), _size(atom->size()),
           _sectionName(atom->customSectionName()),
           _sectionSize(atom->sectionSize()) {
static void mapping(IO &io, lld::DefinedAtom *&atom) {
     const lld::DefinedAtom *atomPtr = atom;
     MappingTraits<const lld::DefinedAtom *>::mapping(io, atomPtr);
     atom = const_cast<lld::DefinedAtom *>(atomPtr);
   }
 };
 
 // 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) {}
+        : _file(fileFromContext(io)), _canBeNull(canBeNullNever) {}
 
     NormalizedAtom(IO &io, const lld::UndefinedAtom *atom)
         : _file(fileFromContext(io)), _name(atom->name()),
           _canBeNull(atom->canBeNull()) {}
 
     ~NormalizedAtom() override = default;
 
     const lld::UndefinedAtom *denormalize(IO &io) {
template <> struct MappingTraits<lld::UndefinedAtom *> {
   }
 };
 
 // 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),
+        : _file(fileFromContext(io)), _canBeNull(false),
           _type(Type::Unknown), _size(0) {}
+
     NormalizedAtom(IO &io, const lld::SharedLibraryAtom *atom)
         : _file(fileFromContext(io)), _name(atom->name()),
           _loadName(atom->loadName()), _canBeNull(atom->canBeNullAtRuntime()),
           _type(atom->type()), _size(atom->size()) {}
 
     ~NormalizedAtom() override = default;
 
     const lld::SharedLibraryAtom *denormalize(IO &io) {
static void mapping(IO &io, lld::SharedLibraryAtom *&atom) {
     const lld::SharedLibraryAtom *atomPtr = atom;
     MappingTraits<const lld::SharedLibraryAtom *>::mapping(io, atomPtr);
     atom = const_cast<lld::SharedLibraryAtom *>(atomPtr);
   }
 };
 
 // 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) {}
+        : _file(fileFromContext(io)), _scope(), _value(0) {}
+
     NormalizedAtom(IO &io, const lld::AbsoluteAtom *atom)
         : _file(fileFromContext(io)), _name(atom->name()),
           _scope(atom->scope()), _value(atom->value()) {}
 
     ~NormalizedAtom() override = default;
 
     const lld::AbsoluteAtom *denormalize(IO &io) {
       YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
       typedef MappingTraits<const lld::File *>::NormalizedFile NormalizedFile;
       NormalizedFile *f = reinterpret_cast<NormalizedFile *>(info->_file);
       if (!_name.empty())
         _name = f->copyString(_name);
 
       DEBUG_WITH_TYPE("WriterYAML",
                       llvm::dbgs() << "created AbsoluteAtom named: '" << _name
                                    << "' (" << (const void *)_name.data()
                                    << ", " << _name.size() << ")\n");
       return this;
     }
+
     // Extract current File object from YAML I/O parsing context
     const lld::File &fileFromContext(IO &io) {
       YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
       assert(info->_file != nullptr);
       return *info->_file;
     }