[MachO][TLOF] Add support for local symbols in the indirect symbol table

[thegameg]

Summary

On 32-bit archs, before, we would assume that an indirect symbol will never have local linkage. This can lead to miscompiles where the symbol's value would be 0 and the linker would use that value, because the indirect symbol table would contain the value INDIRECT_SYMBOL_LOCAL for that specific symbol.

[Gerolf]

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1122 ↗

(On Diff #177764)

Please add the comment from radar about this change.

[thegameg]

Add more comments regarding local indirect symbols.

[Gerolf]

LGTM

llvm/trunk/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

const MCExpr *TargetLoweringObjectFileMachO::getIndirectSymViaGOTPCRel(
   //    _delta:
   //       .long   L_extfoo$non_lazy_ptr-(_delta+0)
   //
   //       .section        __IMPORT,__pointers,non_lazy_symbol_pointers
   //    L_extfoo$non_lazy_ptr:
   //       .indirect_symbol        _extfoo
   //       .long   0
   //
+  // The indirect symbol table (and sections of non_lazy_symbol_pointers type)
+  // may point to both local (same translation unit) and global (other
+  // translation units) symbols. Example:
+  //
+  // .section __DATA,__pointers,non_lazy_symbol_pointers
+  // L1:
+  //    .indirect_symbol _myGlobal
+  //    .long 0
+  // L2:
+  //    .indirect_symbol _myLocal
+  //    .long _myLocal
+  //
+  // If the symbol is local, instead of the symbol's index, the assembler
+  // places the constant INDIRECT_SYMBOL_LOCAL into the indirect symbol table.
+  // Then the linker will notice the constant in the table and will look at the
+  // content of the symbol.
   MachineModuleInfoMachO &MachOMMI =
     MMI->getObjFileInfo<MachineModuleInfoMachO>();
   MCContext &Ctx = getContext();
 
   // The offset must consider the original displacement from the base symbol
   // since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
   Offset = -MV.getConstant();
   const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
 
   // Access the final symbol via sym$non_lazy_ptr and generate the appropriated
   // non_lazy_ptr stubs.
   SmallString<128> Name;
   StringRef Suffix = "$non_lazy_ptr";
   Name += MMI->getModule()->getDataLayout().getPrivateGlobalPrefix();
   Name += Sym->getName();
   Name += Suffix;
   MCSymbol *Stub = Ctx.getOrCreateSymbol(Name);
 
   MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub);
-  if (!StubSym.getPointer())
-    StubSym = MachineModuleInfoImpl::
-      StubValueTy(const_cast<MCSymbol *>(Sym), true /* access indirectly */);
+  if (!StubSym.getPointer()) {
+    bool IsIndirectLocal = Sym->isDefined() && !Sym->isExternal();
+    // With the assumption that IsIndirectLocal == GV->hasLocalLinkage().
+    StubSym = MachineModuleInfoImpl::StubValueTy(const_cast<MCSymbol *>(Sym),
+                                                 !IsIndirectLocal);
+  }
 
   const MCExpr *BSymExpr =
     MCSymbolRefExpr::create(BaseSym, MCSymbolRefExpr::VK_None, Ctx);
   const MCExpr *LHS =
     MCSymbolRefExpr::create(Stub, MCSymbolRefExpr::VK_None, Ctx);
 
   if (!Offset)
     return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx);

llvm/trunk/test/MC/MachO/cstexpr-gotpcrel-32.ll

@deltaplus = global i32 add (i32 sub (i32 ptrtoint (i32** @localgotequiv to i32),
                              i32 ptrtoint (i32* @deltaplus to i32)),
                              i32 55)
 
 define i32 @t0(i32 %a) {
   %x = add i32 sub (i32 ptrtoint (i32** @bargotequiv to i32),
                     i32 ptrtoint (i32 (i32)* @t0 to i32)), %a
   ret i32 %x
 }
+
+; Text indirect local symbols.
+; CHECK-LABEL: _localindirect
+; CHECK: .long 65603
+@localindirect = internal constant i32  65603
[e-mail] = private unnamed_addr constant i32* @localindirect
+
+; CHECK-LABEL: _localindirectuser:
+; CHECK: .long   L_localindirect$non_lazy_ptr-_localindirectuser
+@localindirectuser = internal constant
+  i32 sub (i32 ptrtoint (i32** @got.localindirect to i32),
+           i32 ptrtoint (i32* @localindirectuser to i32))
+
+; CHECK-LABEL: L_localindirect$non_lazy_ptr:
+; CHECK: .indirect_symbol _localindirect
+; CHECK-NOT: .long 0
+; CHECK-NEXT: .long _localindirect
+define i8* @testRelativeIndirectSymbol() {
+  %1 = bitcast i32* @localindirectuser to i8*
+  ret i8* %1
+}