Make NaCl's use of .init_array for static constructors match Linux

[dschuff]

Summary

The generic ELF TargetObjectFile defaults to .ctors, but Linux's
defaults to .init_array by calling InitializeELF with the value of
UseInitArray from TargetMachine. Make NaCl's behavior match.

[jvoung]

looks okay -- a couple nits

lib/Target/X86/X86TargetMachine.cpp

40–41

nit: the class is called "Linux" but now it applies to Linux and NaCl.

I wonder if the the X86ELFTargetObjectFile and X86Linux should just be merged.

It's kind of odd in terms of naming that the X86ELFTargetObjectFile doesn't call InitializeELF =)

The fact that some systems use ctors and others use init_array is supposed to be controlled by the TM.Options.UseInitArray not so much whether InitializeELF is called or not. On the other hand, I'm not sure if clang sets that option correctly for each user of ELF + X86, so that might be a reason to check that as a separate change.

test/CodeGen/X86/constructor.ll

33

nit: Can these be NACL-NEXT for uniformity?

[dschuff]

• review comments

lib/Target/X86/X86TargetMachine.cpp

 
 static std::unique_ptr<TargetLoweringObjectFile> createTLOF(const Triple &TT) {
   if (TT.isOSBinFormatMachO()) {
     if (TT.getArch() == Triple::x86_64)
       return make_unique<X86_64MachoTargetObjectFile>();
     return make_unique<TargetLoweringObjectFileMachO>();
   }
 
-  if (TT.isOSLinux())
-    return make_unique<X86LinuxTargetObjectFile>();
+  if (TT.isOSLinux() || TT.isOSNaCl())
+    return make_unique<X86LinuxNaClTargetObjectFile>();
   if (TT.isOSBinFormatELF())
     return make_unique<X86ELFTargetObjectFile>();
   if (TT.isKnownWindowsMSVCEnvironment())
     return make_unique<X86WindowsTargetObjectFile>();
   if (TT.isOSBinFormatCOFF())
     return make_unique<TargetLoweringObjectFileCOFF>();
   llvm_unreachable("unknown subtarget type");
 }

lib/Target/X86/X86TargetObjectFile.h

namespace llvm {
 
   /// \brief This implemenatation is used for X86 ELF targets that don't
   /// have a further specialization.
   class X86ELFTargetObjectFile : public TargetLoweringObjectFileELF {
     /// \brief Describe a TLS variable address within debug info.
     const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const override;
   };
 
-  /// X86LinuxTargetObjectFile - This implementation is used for linux x86
-  /// and x86-64.
-  class X86LinuxTargetObjectFile : public X86ELFTargetObjectFile {
+  /// X86LinuxNaClTargetObjectFile - This implementation is used for linux and
+  /// Native Client on x86 and x86-64.
+  class X86LinuxNaClTargetObjectFile : public X86ELFTargetObjectFile {
     void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
   };
 
   /// \brief This implementation is used for Windows targets on x86 and x86-64.
   class X86WindowsTargetObjectFile : public TargetLoweringObjectFileCOFF {
     const MCExpr *
     getExecutableRelativeSymbol(const ConstantExpr *CE, Mangler &Mang,
                                 const TargetMachine &TM) const override;

lib/Target/X86/X86TargetObjectFile.cpp

 }
 
 const MCExpr *X86ELFTargetObjectFile::getDebugThreadLocalSymbol(
     const MCSymbol *Sym) const {
   return MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_DTPOFF, getContext());
 }
 
 void
-X86LinuxTargetObjectFile::Initialize(MCContext &Ctx, const TargetMachine &TM) {
+X86LinuxNaClTargetObjectFile::Initialize(MCContext &Ctx,
+                                         const TargetMachine &TM) {
   TargetLoweringObjectFileELF::Initialize(Ctx, TM);
   InitializeELF(TM.Options.UseInitArray);
 }
 
 const MCExpr *X86WindowsTargetObjectFile::getExecutableRelativeSymbol(
     const ConstantExpr *CE, Mangler &Mang, const TargetMachine &TM) const {
   // We are looking for the difference of two symbols, need a subtraction
   // operation.

test/CodeGen/X86/constructor.ll

 ; RUN: llc -mtriple x86_64-pc-linux -use-ctors < %s | FileCheck --check-prefix=CTOR %s
 ; RUN: llc -mtriple x86_64-pc-linux < %s | FileCheck --check-prefix=INIT-ARRAY %s
+; RUN: llc -mtriple x86_64-unknown-nacl < %s | FileCheck --check-prefix=NACL %s
 @llvm.global_ctors = appending global [2 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @f, i8* null}, { i32, void ()*, i8* } { i32 15, void ()* @g, i8* @v }]
 
 @v = weak_odr global i8 0
 
 define void @f() {
 entry:
   ret void
 }

 ; CTOR-NEXT:  .quad f
 
 ; INIT-ARRAY:   .section  .init_array.15,"aGw",@init_array,v,comdat
 ; INIT-ARRAY-NEXT:  .align  8
 ; INIT-ARRAY-NEXT:  .quad g
 ; INIT-ARRAY-NEXT:  .section  .init_array,"aw",@init_array
 ; INIT-ARRAY-NEXT:  .align  8
 ; INIT-ARRAY-NEXT:  .quad f
+
+; NACL:   .section  .init_array.15,"aGw",@init_array,v,comdat
+; NACL-NEXT:  .align  4
+; NACL-NEXT:  .long g
+; NACL-NEXT:  .section  .init_array,"aw",@init_array
+; NACL-NEXT:  .align  4
+; NACL-NEXT:  .long f