[ELF2] Check for TLS mismatch in symbol resolution.

[ikudrin]

Summary

The linker should generate an error if a TLS symbol is resolved for a non-TLS reference and vice versa.
The patch addresses PR24244.

[ruiu]

LGTM

ELF/SymbolTable.cpp

178–179

Move Message to the beginning of the parameter list.

ELF/SymbolTable.h

private:
   void addELFFile(ELFFileBase *File);
   void addLazy(Lazy *New);
   void addMemberFile(Lazy *Body);
   template <class ELFT> void addUndefinedSym(StringRef Name);
 
   template <class ELFT> void init(uint16_t EMachine);
   template <class ELFT> void resolve(SymbolBody *Body);
   template <class ELFT>
-  void reportConflict(const SymbolBody &Old, const SymbolBody &New);
+  void reportConflict(const SymbolBody &Old, const SymbolBody &New,
+                      const Twine &Message, bool Warning);
 
   std::vector<std::unique_ptr<ArchiveFile>> ArchiveFiles;
 
   // The order the global symbols are in is not defined. We can use an arbitrary
   // order, but it has to be reproducible. That is true even when cross linking.
   // The default hashing of StringRef produces different results on 32 and 64
   // bit systems so we use a MapVector. That is arbitrary, deterministic but
   // a bit inefficient.

ELF/SymbolTable.cpp

case ELF64BEKind:
     addELFFile<ELF64BE>(File);
     break;
   default:
     llvm_unreachable("Invalid kind");
   }
 }
 
 template <class ELFT>
-void SymbolTable::reportConflict(const SymbolBody &Old, const SymbolBody &New) {
+void SymbolTable::reportConflict(const SymbolBody &Old, const SymbolBody &New,
+                                 const Twine &Message, bool Warning) {
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
 
   const Elf_Sym &OldE = cast<ELFSymbolBody<ELFT>>(Old).Sym;
   const Elf_Sym &NewE = cast<ELFSymbolBody<ELFT>>(New).Sym;
   ELFFileBase *OldFile = nullptr;
   ELFFileBase *NewFile = nullptr;
 
   for (const std::unique_ptr<ObjectFileBase> &F : ObjectFiles) {
     const auto &File = cast<ObjectFile<ELFT>>(*F);
     Elf_Sym_Range Syms = File.getObj().symbols(File.getSymbolTable());
     if (&OldE > Syms.begin() && &OldE < Syms.end())
       OldFile = F.get();
     if (&NewE > Syms.begin() && &NewE < Syms.end())
       NewFile = F.get();
   }
 
-  std::string Msg = (Twine("duplicate symbol: ") + Old.getName() + " in " +
+  std::string Msg = (Message + ": " + Old.getName() + " in " +
                      OldFile->getName() + " and " + NewFile->getName())
                         .str();
-  if (Config->AllowMultipleDefinition)
+  if (Warning)
     warning(Msg);
   else
     error(Msg);
 }
 
 // This function resolves conflicts if there's an existing symbol with
 // the same name. Decisions are made based on symbol type.
 template <class ELFT> void SymbolTable::resolve(SymbolBody *New) {
if (Lazy *L = dyn_cast<Lazy>(Existing)) {
     }
 
     // Found a definition for something also in an archive. Ignore the archive
     // definition.
     Sym->Body = New;
     return;
   }
 
+  if (New->isTLS() != Existing->isTLS())
+    reportConflict<ELFT>(*Existing, *New, "TLS attribute mismatch for symbol",
+                         false);
+
   // compare() returns -1, 0, or 1 if the lhs symbol is less preferable,
   // equivalent (conflicting), or more preferable, respectively.
   int comp = Existing->compare<ELFT>(New);
   if (comp < 0)
     Sym->Body = New;
   else if (comp == 0)
-    reportConflict<ELFT>(*Existing, *New);
+    reportConflict<ELFT>(*Existing, *New, "duplicate symbol",
+                         Config->AllowMultipleDefinition);
 }
 
 Symbol *SymbolTable::insert(SymbolBody *New) {
   // Find an existing Symbol or create and insert a new one.
   StringRef Name = New->getName();
   Symbol *&Sym = Symtab[Name];
   if (!Sym) {
     Sym = new (Alloc) Symbol(New);

ELF/Symbols.h

public:
   bool isUndefined() const { return SymbolKind == UndefinedKind; }
   bool isDefined() const { return SymbolKind <= DefinedLast; }
   bool isCommon() const { return SymbolKind == DefinedCommonKind; }
   bool isLazy() const { return SymbolKind == LazyKind; }
   bool isShared() const { return SymbolKind == SharedKind; }
   bool isUsedInRegularObj() const { return IsUsedInRegularObj; }
   bool isUsedInDynamicReloc() const { return IsUsedInDynamicReloc; }
   void setUsedInDynamicReloc() { IsUsedInDynamicReloc = true; }
+  bool isTLS() const { return IsTLS; }
 
   // Returns the symbol name.
   StringRef getName() const { return Name; }
 
   uint8_t getMostConstrainingVisibility() const {
     return MostConstrainingVisibility;
   }
 
public:
   SymbolBody *repl() { return Backref ? Backref->Body : this; }
 
   // Decides which symbol should "win" in the symbol table, this or
   // the Other. Returns 1 if this wins, -1 if the Other wins, or 0 if
   // they are duplicate (conflicting) symbols.
   template <class ELFT> int compare(SymbolBody *Other);
 
 protected:
-  SymbolBody(Kind K, StringRef Name, bool IsWeak, uint8_t Visibility)
+  SymbolBody(Kind K, StringRef Name, bool IsWeak, uint8_t Visibility,
+             bool IsTLS)
       : SymbolKind(K), IsWeak(IsWeak), MostConstrainingVisibility(Visibility),
-        Name(Name) {
+        IsTLS(IsTLS), Name(Name) {
     IsUsedInRegularObj = K != SharedKind && K != LazyKind;
     IsUsedInDynamicReloc = 0;
   }
 
   const unsigned SymbolKind : 8;
   unsigned IsWeak : 1;
   unsigned MostConstrainingVisibility : 2;
   unsigned IsUsedInRegularObj : 1;
   unsigned IsUsedInDynamicReloc : 1;
+  unsigned IsTLS : 1;
   unsigned DynamicSymbolTableIndex = 0;
   unsigned GotIndex = -1;
   unsigned PltIndex = -1;
   StringRef Name;
   Symbol *Backref = nullptr;
 };
 
 // This is for symbols created from elf files and not from the command line.
 // Since they come from object files, they have a Elf_Sym.
 //
 // FIXME: Another alternative is to give every symbol an Elf_Sym. To do that
 // we have to delay creating the symbol table until the output format is
 // known and some of its methods will be templated. We should experiment with
 // that once we have a bit more code.
 template <class ELFT> class ELFSymbolBody : public SymbolBody {
 protected:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   ELFSymbolBody(Kind K, StringRef Name, const Elf_Sym &Sym)
       : SymbolBody(K, Name, Sym.getBinding() == llvm::ELF::STB_WEAK,
-                   Sym.getVisibility()),
+                   Sym.getVisibility(), Sym.getType() == llvm::ELF::STT_TLS),
         Sym(Sym) {}
 
 public:
   const Elf_Sym &Sym;
 
   static bool classof(const SymbolBody *S) {
     Kind K = S->kind();
     return K >= DefinedFirst && K <= UndefinedKind;

 // This class represents a symbol defined in an archive file. It is
 // created from an archive file header, and it knows how to load an
 // object file from an archive to replace itself with a defined
 // symbol. If the resolver finds both Undefined and Lazy for
 // the same name, it will ask the Lazy to load a file.
 class Lazy : public SymbolBody {
 public:
   Lazy(ArchiveFile *F, const llvm::object::Archive::Symbol S)
-      : SymbolBody(LazyKind, S.getName(), false, llvm::ELF::STV_DEFAULT),
+      : SymbolBody(LazyKind, S.getName(), false, llvm::ELF::STV_DEFAULT, false),
         File(F), Sym(S) {}
 
   static bool classof(const SymbolBody *S) { return S->kind() == LazyKind; }
 
   // Returns an object file for this symbol, or a nullptr if the file
   // was already returned.
   std::unique_ptr<InputFile> getMember();
 

test/elf2/Inputs/tls-mismatch.s

+.tbss
+.globl tlsvar
+tlsvar:
+  .space 4

test/elf2/tls-mismatch.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/tls-mismatch.s -o %t2
+// RUN: not lld -flavor gnu2 %t %t2 -o %t3 2>&1 | FileCheck %s
+// CHECK: TLS attribute mismatch for symbol: tlsvar
+
+.globl _start
+_start:
+  movl (tlsvar),%edx