[X86] Fix R_X86_64_TPOFF32 against weak undefined TLS symbols

A weak undefined TLS symbol has no slot in the PT_TLS segment, so the
thread-pointer-offset formula (S - templateSize) is meaningless for it.
Previously relocTPOFF applied that formula with a bogus symbol value,
producing an incorrect tpoff (e.g. -3) instead of the correct 0.

Two fixes, mirroring lld's R_TPREL handling (if (sym.isUndefined())
return a):

- relocTPOFF (x86_64Relocator.cpp): short-circuit weak undefined symbols
  in a static executable, returning the addend directly instead of
  running the tpoff formula.
- finalizeTLSSymbol (GNULDBackend.cpp): return 0 (not 1/true) for symbols
  without a fragment reference, fixing the st_value written to .symtab for
  undefined TLS symbols.

Add x86_64/linux/WeakUndefTLS covering TPOFF32/64 and DTPOFF32/64 against
weak-undef symbols, a defined-symbol regression guard, and a non-zero
addend case.

Resolves #1540

Signed-off-by: Rachit Mehta <rachmeht@qti.qualcomm.com>

Author: rachitmeht

lib/Target/GNULDBackend.cpp

@@ -759,11 +759,8 @@ uint64_t GNULDBackend::finalizeTLSSymbol(LDSymbol *pSymbol) {
   }
 
   // ignore if symbol has no fragRef
-  // FIXME: This is probably wrong. If a symbol does not have a fragment ref
-  // that implies the symbol is undefined, in that case, the symbol index should
-  // be 0 instead of 1 (true).
   if (!pSymbol->hasFragRef())
-    return true;
+    return false;
 
   // the value of a TLS symbol is the offset to the TLS segment
   std::vector<ELFSegment *> tls_segs =

lib/Target/X86/x86_64Relocator.cpp

@@ -752,6 +752,13 @@ Relocator::Result eld::relocTPOFF(Relocation &pReloc, x86_64Relocator &pParent,
 
   uint64_t TLSTemplateSize = pParent.getTarget().getTLSTemplateSize();
 
+  ResolveInfo *rsym = pReloc.symInfo();
+  if (rsym && rsym->isWeakUndef() &&
+      (pParent.config().codeGenType() == LinkerConfig::Exec)) {
+    Relocator::DWord A = pReloc.addend();
+    return ApplyReloc(pReloc, A, pRelocDesc, DiagEngine, options, pParent);
+  }
+
   if (TLSTemplateSize == 0) {
     pParent.config().raise(Diag::no_pt_tls_segment);
     return Relocator::BadReloc;

test/x86_64/linux/WeakUndefTLS/Inputs/weak_tls_defined.s

@@ -0,0 +1,11 @@
+.section .tdata, "awT", @progbits
+.align 4
+.global real_tls
+real_tls:
+  .long 0
+
+.section .data
+.align 4
+result:
+  .long 0xdeadbeef
+  .reloc result, R_X86_64_TPOFF32, real_tls

test/x86_64/linux/WeakUndefTLS/Inputs/weak_tls_ld.s

@@ -0,0 +1,6 @@
+.weak weak_tls
+.section .data
+.align 4
+result:
+  .long 0xdeadbeef
+  .reloc result, R_X86_64_DTPOFF32, weak_tls

test/x86_64/linux/WeakUndefTLS/Inputs/weak_tls_ld64.s

@@ -0,0 +1,6 @@
+.weak weak_tls
+.section .data
+.align 8
+result:
+  .quad 0xdeadbeefdeadbeef
+  .reloc result, R_X86_64_DTPOFF64, weak_tls

test/x86_64/linux/WeakUndefTLS/Inputs/weak_tls_le.s

@@ -0,0 +1,6 @@
+.weak weak_tls
+.section .data
+.align 4
+result:
+  .long 0xdeadbeef
+  .reloc result, R_X86_64_TPOFF32, weak_tls

test/x86_64/linux/WeakUndefTLS/Inputs/weak_tls_le64.s

@@ -0,0 +1,6 @@
+.weak weak_tls
+.section .data
+.align 8
+result:
+  .quad 0xdeadbeefdeadbeef
+  .reloc result, R_X86_64_TPOFF64, weak_tls

test/x86_64/linux/WeakUndefTLS/Inputs/weak_tls_le_addend.s

@@ -0,0 +1,6 @@
+.weak weak_tls
+.section .data
+.align 4
+result:
+  .long 0xdeadbeef
+  .reloc result, R_X86_64_TPOFF32, weak_tls+2

test/x86_64/linux/WeakUndefTLS/WeakUndefTLS.test

@@ -0,0 +1,61 @@
+#--WeakUndefTLS.test----------Executable--------#
+BEGIN_COMMENT
+# Test R_X86_64_TPOFF32/64 and R_X86_64_DTPOFF32/64 relocations against
+# weak undefined TLS symbols. A weak undefined TLS symbol has no TLS slot,
+# so the tpoff formula must not run; the result is the addend only (= 0
+# for the common case). Mirrors lld's R_TPREL guard:
+#   if (sym.isUndefined()) return a;
+# Also verifies that defined TLS symbols are unaffected (regression guard).
+#END_COMMENT
+
+#START_TEST
+
+# Case 1: TPOFF32 + weak-undef -> 0x00000000
+RUN: %clang %clangopts -c %p/Inputs/weak_tls_le.s -o %t.le.o
+RUN: %link %linkopts -static %t.le.o -o %t.le.exe
+RUN: llvm-objdump -s -j .data %t.le.exe | FileCheck %s --check-prefix=LE32
+
+# Case 2: TPOFF64 + weak-undef -> 0x0000000000000000
+RUN: %clang %clangopts -c %p/Inputs/weak_tls_le64.s -o %t.le64.o
+RUN: %link %linkopts -static %t.le64.o -o %t.le64.exe
+RUN: llvm-objdump -s -j .data %t.le64.exe | FileCheck %s --check-prefix=LE64
+
+# Case 3: DTPOFF32 + weak-undef -> 0x00000000
+RUN: %clang %clangopts -c %p/Inputs/weak_tls_ld.s -o %t.ld.o
+RUN: %link %linkopts -static %t.ld.o -o %t.ld.exe
+RUN: llvm-objdump -s -j .data %t.ld.exe | FileCheck %s --check-prefix=LD32
+
+# Case 4: DTPOFF64 + weak-undef -> 0x0000000000000000
+RUN: %clang %clangopts -c %p/Inputs/weak_tls_ld64.s -o %t.ld64.o
+RUN: %link %linkopts -static %t.ld64.o -o %t.ld64.exe
+RUN: llvm-objdump -s -j .data %t.ld64.exe | FileCheck %s --check-prefix=LD64
+
+# Case 5: TPOFF32 + defined symbol -> -4 = 0xfffffffc (regression guard)
+RUN: %clang %clangopts -c %p/Inputs/weak_tls_defined.s -o %t.def.o
+RUN: %link %linkopts -static %t.def.o -o %t.def.exe
+RUN: llvm-objdump -s -j .data %t.def.exe | FileCheck %s --check-prefix=DEFINED
+
+# Case 6: TPOFF32 + weak-undef + addend=2 -> 0x00000002
+RUN: %clang %clangopts -c %p/Inputs/weak_tls_le_addend.s -o %t.addend.o
+RUN: %link %linkopts -static %t.addend.o -o %t.addend.exe
+RUN: llvm-objdump -s -j .data %t.addend.exe | FileCheck %s --check-prefix=ADDEND
+
+LE32:      Contents of section .data:
+LE32-NEXT: {{[0-9a-f]+}} 00000000
+
+LE64:      Contents of section .data:
+LE64-NEXT: {{[0-9a-f]+}} 00000000 00000000
+
+LD32:      Contents of section .data:
+LD32-NEXT: {{[0-9a-f]+}} 00000000
+
+LD64:      Contents of section .data:
+LD64-NEXT: {{[0-9a-f]+}} 00000000 00000000
+
+DEFINED:      Contents of section .data:
+DEFINED-NEXT: {{[0-9a-f]+}} fcffffff
+
+ADDEND:      Contents of section .data:
+ADDEND-NEXT: {{[0-9a-f]+}} 02000000
+
+#END_TEST