Do not consider Shared symbols as defined symbols.

[ruiu]

Summary

I don't remember why I made shared symbols one type of defined symbols.
Shared symbols aren't undefined, so it could be considered defined, but
categorizing three symbols as:

• defined
  • really defined
  • shared
• undefined

is not as intuitive as

• defined
• shared
• undefined

to me. So, in this patch, I made a change to stop handling shared
symbols as defined symbols.

Surprisingly, I didn't have to update any tests for this change.

[ruiu]

• actually fix the class hierarchy

[ruiu]

What do you think of this?

With this patch, we can remove isInCurrentOutput() because it is equivalent to isa<Defined>().

[ruiu]

• Rebased

[pcc]

LGTM

This change makes sense to me as it should allow for further simplification of the class hierarchy.

lld/trunk/ELF/Symbols.h

 template <class ELFT> class SharedFile;
 
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
     DefinedFirst,
     DefinedRegularKind = DefinedFirst,
-    SharedKind,
     DefinedCommonKind,
     DefinedLast = DefinedCommonKind,
+    SharedKind,
     UndefinedKind,
     LazyArchiveKind,
     LazyObjectKind,
   };
 
   Symbol(Kind K) : SymbolKind(K) {}
   Kind kind() const { return static_cast<Kind>(SymbolKind); }
 

 class Undefined : public Symbol {
 public:
   Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type)
       : Symbol(UndefinedKind, Name, IsLocal, StOther, Type) {}
 
   static bool classof(const Symbol *S) { return S->kind() == UndefinedKind; }
 };
 
-class SharedSymbol : public Defined {
+class SharedSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) { return S->kind() == SharedKind; }
 
   SharedSymbol(StringRef Name, uint8_t StOther, uint8_t Type, uint64_t Value,
                uint64_t Size, uint32_t Alignment, const void *Verdef)
-      : Defined(SharedKind, Name, /*IsLocal=*/false, StOther, Type),
+      : Symbol(SharedKind, Name, /*IsLocal=*/false, StOther, Type),
         Verdef(Verdef), Value(Value), Size(Size), Alignment(Alignment) {
     // GNU ifunc is a mechanism to allow user-supplied functions to
     // resolve PLT slot values at load-time. This is contrary to the
     // regualr symbol resolution scheme in which symbols are resolved just
     // by name. Using this hook, you can program how symbols are solved
     // for you program. For example, you can make "memcpy" to be resolved
     // to a SSE-enabled version of memcpy only when a machine running the
     // program supports the SSE instruction set.