Remove dead code.

[ruiu]

Summary

isAlias always returns false and no one is using it. It was
originally added Atom to query if an atom is an alias for another
atom, assuming that alias atoms are different from normal atoms.

We now support atom aliasing, but the way that's implemented is
in a different way than what isAlias assumed. An alias atom is
just a regular defined atom with no content, and it has a layout-
before edge to alias-to atom so that they are layed out at the
same location in the result. So this is dead code, and it doesn't
make much sense to keep it.

[atanasyan]

LGTM

[ruiu]

Closed by commit rL207989 (authored by @ruiu).

include/lld/Core/DefinedAtom.h

public:
 
   /// \brief Returns the OS memory protections required for this atom's content
   /// at runtime.
   ///
   /// A function atom is R_X, a global variable is RW_, and a read-only constant
   /// is R__.
   virtual ContentPermissions permissions() const;
 
-  /// \brief means this is a zero size atom that exists to provide an alternate
-  /// name for another atom.  Alias atoms must have a special Reference to the
-  /// atom they alias which the layout engine recognizes and forces the alias
-  /// atom to layout right before the target atom.
-  virtual bool isAlias() const = 0;
-
   /// \brief returns a reference to the raw (unrelocated) bytes of this Atom's
   /// content.
   virtual ArrayRef<uint8_t> rawContent() const = 0;
 
   /// This class abstracts iterating over the sequence of References
   /// in an Atom.  Concrete instances of DefinedAtom must implement
   /// the derefIterator() and incrementIterator() methods.
   class reference_iterator {

include/lld/ReaderWriter/Simple.h

SectionPosition sectionPosition() const override {
     return DefinedAtom::sectionPositionAny;
   }
 
   StringRef customSectionName() const override { return StringRef(); }
   DeadStripKind deadStrip() const override {
     return DefinedAtom::deadStripNormal;
   }
 
-  bool isAlias() const override { return false; }
-
   DefinedAtom::reference_iterator begin() const override {
     uintptr_t index = 0;
     const void *it = reinterpret_cast<const void *>(index);
     return reference_iterator(*this, it);
   }
 
   DefinedAtom::reference_iterator end() const override {
     uintptr_t index = _references.size();

lib/ReaderWriter/CoreLinkingContext.cpp

public:
   DeadStripKind deadStrip() const override {
     return DefinedAtom::deadStripNormal;
   }
 
   ContentPermissions permissions() const override {
     return DefinedAtom::permR_X;
   }
 
-  bool isAlias() const override { return false; }
-
   ArrayRef<uint8_t> rawContent() const override { return ArrayRef<uint8_t>(); }
 
   reference_iterator begin() const override {
     return reference_iterator(*this, nullptr);
   }
 
   reference_iterator end() const override {
     return reference_iterator(*this, nullptr);
public:
   DeadStripKind deadStrip() const override {
     return DefinedAtom::deadStripNormal;
   }
 
   ContentPermissions permissions() const override {
     return DefinedAtom::permRW_;
   }
 
-  bool isAlias() const override { return false; }
-
   ArrayRef<uint8_t> rawContent() const override { return ArrayRef<uint8_t>(); }
 
   reference_iterator begin() const override {
     return reference_iterator(*this, nullptr);
   }
 
   reference_iterator end() const override {
     return reference_iterator(*this, nullptr);
for (StringRef name : _passNames) {
     else if (name.equals("stubs"))
       pm.add(std::unique_ptr<Pass>(new TestingStubsPass(*this)));
     else
       llvm_unreachable("bad pass name");
   }
 }
 
 Writer &CoreLinkingContext::writer() const { return *_writer; }
-

lib/ReaderWriter/ELF/Atoms.h

ContentPermissions permissions() const override {
     case llvm::ELF::SHT_FINI_ARRAY:
       return _permissions = permRW_;
 
     default:
       return _permissions = perm___;
     }
   }
 
-  // FIXME: Not Sure if ELF supports alias atoms. Find out more.
-  bool isAlias() const override { return false; }
-
   ArrayRef<uint8_t> rawContent() const override { return _contentData; }
 
   DefinedAtom::reference_iterator begin() const override {
     uintptr_t index = _referenceStartIndex;
     const void *it = reinterpret_cast<const void*>(index);
     return reference_iterator(*this, it);
   }
 
public:
   }
 
   DeadStripKind deadStrip() const override { return deadStripNormal; }
 
   ContentPermissions permissions() const override { return permR__; }
 
   virtual bool isThumb() const { return false; }
 
-  bool isAlias() const override { return false; }
-
   ArrayRef<uint8_t> rawContent() const override { return _contentData; }
 
   DefinedAtom::reference_iterator begin() const override {
     uintptr_t index = 0;
     const void *it = reinterpret_cast<const void *>(index);
     return reference_iterator(*this, it);
   }
 
public:
   SectionPosition sectionPosition() const override {
     return sectionPositionAny;
   }
 
   DeadStripKind deadStrip() const override { return deadStripNormal; }
 
   ContentPermissions permissions() const override { return permRW_; }
 
-  bool isAlias() const override { return false; }
-
   ArrayRef<uint8_t> rawContent() const override { return ArrayRef<uint8_t>(); }
 
   DefinedAtom::reference_iterator begin() const override {
     uintptr_t index = 0;
     const void *it = reinterpret_cast<const void *>(index);
     return reference_iterator(*this, it);
   }
 

lib/ReaderWriter/Native/ReaderNative.cpp

public:
   DynamicExport dynamicExport() const override {
     return (DynamicExport)attributes().dynamicExport;
   }
 
   DefinedAtom::ContentPermissions permissions() const override {
      return (DefinedAtom::ContentPermissions)(attributes().permissions);
   }
 
-  bool isAlias() const override {
-     return (attributes().alias != 0);
-  }
-
   ArrayRef<uint8_t> rawContent() const override;
 
   reference_iterator begin() const override;
 
   reference_iterator end() const override;
 
   const Reference* derefIterator(const void*) const override;
 

lib/ReaderWriter/Native/WriterNative.cpp

NativeAtomAttributesV1 computeAttributesV1(const DefinedAtom& atom) {
     attrs.interposable      = atom.interposable();
     attrs.merge             = atom.merge();
     attrs.contentType       = atom.contentType();
     attrs.sectionChoiceAndPosition
                           = atom.sectionChoice() << 4 | atom.sectionPosition();
     attrs.deadStrip         = atom.deadStrip();
     attrs.dynamicExport     = atom.dynamicExport();
     attrs.permissions       = atom.permissions();
-    attrs.alias             = atom.isAlias();
     return attrs;
   }
 
   NativeAtomAttributesV1 computeAbsoluteAttributes(const AbsoluteAtom& atom) {
     NativeAtomAttributesV1 attrs;
     attrs.scope = atom.scope();
     return attrs;
   }

lib/ReaderWriter/PECOFF/Atoms.h

public:
   Merge merge() const override { return mergeNo; }
   Alignment alignment() const override { return Alignment(0); }
   SectionChoice sectionChoice() const = 0;
   StringRef customSectionName() const override { return ""; }
   SectionPosition sectionPosition() const override {
     return sectionPositionAny;
   }
   DeadStripKind deadStrip() const override { return deadStripNormal; }
-  bool isAlias() const override { return false; }
 
   Kind getKind() const { return _kind; }
 
   void addReference(std::unique_ptr<COFFReference> reference) {
     _references.push_back(std::move(reference));
   }
 
   reference_iterator begin() const override {

lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

public:
     ContentType contentType() const override { return _contentType; }
     Alignment alignment() const override { return _alignment; }
     SectionChoice sectionChoice() const override { return _sectionChoice; }
     StringRef customSectionName() const override { return _sectionName; }
     SectionPosition sectionPosition() const override { return _sectionPosition; }
     DeadStripKind deadStrip() const override { return _deadStrip; }
     DynamicExport dynamicExport() const override { return _dynamicExport; }
     ContentPermissions permissions() const override { return _permissions; }
-    bool isAlias() const override { return false; }
     bool isGroupChild() const { return _isGroupChild; }
     ArrayRef<uint8_t> rawContent() const override {
       if (!occupiesDiskSpace())
         return ArrayRef<uint8_t>();
       return ArrayRef<uint8_t>(
           reinterpret_cast<const uint8_t *>(_content.data()), _content.size());
     }