[Solaris] emit .init_array instead of .ctors on Solaris (Sparc/x86)

[fedor.sergeev]

Summary

Honor Options.UseInitArray on Solaris targets.

Addressing PR33293.

[davide]

Can you add a test?
Also, I'd like to know the following: does the Solaris linker (whatever it's called) support mixing'n'matching of .ctors and .init_array ? (gold implements some logic to merge them in order to ensure all the global constructors are called even if you have some objects file with .ctors and some others with .init_array as input.

[fedor.sergeev]

In D33868#772185, @davide wrote:

Can you add a test?

Sure, will do it.
Can you tell me where should I add it - test/Target?
I was planning to add some clang tests, but that can only happen after more changes to clang (enabling -fuse-init-array by default).

Also, I'd like to know the following: does the Solaris linker (whatever it's called) support mixing'n'matching of .ctors and .init_array ?
(gold implements some logic to merge them in order to ensure all the global constructors are called even if you have some objects file with .ctors and some others with .init_array as input.

Solaris ld does not do any merging of .ctors and .init_array:

] old-g++ -c ctor1.cc
] elfdump -c ctor1.o | egrep "ctors|init_array"
Section Header[6]:  sh_name: .ctors
Section Header[7]:  sh_name: .rel.ctors
] clang++ -c ctor2.cc
] elfdump -c ctor2.o | egrep "ctors|init_array"
Section Header[6]:  sh_name: .init_array
Section Header[7]:  sh_name: .rel.init_array

.ctors are being handled purely by crtbegin.o

] old-g++ ctor1.o ctor2.o
] elfdump -c a.out | egrep "ctors|init_array"
Section Header[21]:  sh_name: .init_array
Section Header[23]:  sh_name: .ctors
] ./a.out
I()              <--- from init_array
C()              <--- from ctors
main
] new-g++ ctor1.o ctor2.o
] elfdump -c a.out | egrep "ctors|init_array"
Section Header[21]:  sh_name: .init_array
Section Header[23]:  sh_name: .ctors
] ./a.out
I()
main

But that is an overall problem of a Solaris system that results in g++ incompatibility between versions.
If you have an object with .ctors you have to link it with ctors-handling g++ runtime ("old" one).

Changing behavior of clang/llvm does not make anything worse here, since it is ctors that misbehaves and this change allows to get rid of ctors.

[davide]

In D33868#772189, @fedor.sergeev wrote:

In D33868#772185, @davide wrote:

Can you add a test?

Sure, will do it.
Can you tell me where should I add it - test/Target?
I was planning to add some clang tests, but that can only happen after more changes to clang (enabling -fuse-init-array by default).

You can probably mimic what we do for Linux here (see how it's tested).

Also, I'd like to know the following: does the Solaris linker (whatever it's called) support mixing'n'matching of .ctors and .init_array ?
(gold implements some logic to merge them in order to ensure all the global constructors are called even if you have some objects file with .ctors and some others with .init_array as input.

Solaris ld does not do any merging of .ctors and .init_array:

] old-g++ -c ctor1.cc
] elfdump -c ctor1.o | egrep "ctors|init_array"
Section Header[6]:  sh_name: .ctors
Section Header[7]:  sh_name: .rel.ctors
] clang++ -c ctor2.cc
] elfdump -c ctor2.o | egrep "ctors|init_array"
Section Header[6]:  sh_name: .init_array
Section Header[7]:  sh_name: .rel.init_array

.ctors are being handled purely by crtbegin.o

] old-g++ ctor1.o ctor2.o
] elfdump -c a.out | egrep "ctors|init_array"
Section Header[21]:  sh_name: .init_array
Section Header[23]:  sh_name: .ctors
] ./a.out
I()              <--- from init_array
C()              <--- from ctors
main
] new-g++ ctor1.o ctor2.o
] elfdump -c a.out | egrep "ctors|init_array"
Section Header[21]:  sh_name: .init_array
Section Header[23]:  sh_name: .ctors
] ./a.out
I()
main

But that is an overall problem of a Solaris system that results in g++ incompatibility between versions.
If you have an object with .ctors you have to link it with ctors-handling g++ runtime ("old" one).

Changing behavior of clang/llvm does not make anything worse here, since it is ctors that misbehaves and this change allows to get rid of ctors.

This is an unfortunate effect of transitioning. I agree there's nothing can be done in the compiler as it can't possibly know about other object files, but you might consider fixing this in your linker, assuming you have a compelling use case (tracking down these bugs is fairly annoying).

[fedor.sergeev]

X86 constructor.ll test updated, SPARC constructor.ll added.

] bin/llvm-lit test/CodeGen/SPARC/constructor.ll
-- Testing: 1 tests, 1 threads --
PASS: LLVM :: CodeGen/SPARC/constructor.ll (1 of 1)
Testing Time: 0.22s
  Expected Passes    : 1

] bin/llvm-lit test/CodeGen/X86/constructor.ll
-- Testing: 1 tests, 1 threads --
PASS: LLVM :: CodeGen/X86/constructor.ll (1 of 1)
Testing Time: 0.23s
  Expected Passes    : 1

[fedor.sergeev]

Gentle ping...
... tests are ready.

[krytarowski]

I will leave it to Davide.

[fedor.sergeev]

ping...

[davide]

I think this is fine, but please wait if @rafael has comments about it.

[fedor.sergeev]

So what am I supposed to do here?
Is there any chance for @rafael to actually comment on this?
Is it a blocking action or am I allowed to find somebody to integrate this for me after some lead time?

[davide]

In D33868#785937, @fedor.sergeev wrote:

So what am I supposed to do here?
Is there any chance for @rafael to actually comment on this?
Is it a blocking action or am I allowed to find somebody to integrate this for me after some lead time?

I pinged Rafael and asked him to take another look.
In general if somebody doesn't reply after one week it's OK to ping the patch.
Please be patient as people from time to time have a non-trivial review backlog.

llvm/trunk/lib/Target/Sparc/SparcTargetObjectFile.h

 class TargetMachine;
 
 class SparcELFTargetObjectFile : public TargetLoweringObjectFileELF {
 public:
   SparcELFTargetObjectFile() :
     TargetLoweringObjectFileELF()
   {}
 
+  void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
+
   const MCExpr *getTTypeGlobalReference(const GlobalValue *GV,
                                         unsigned Encoding,
                                         const TargetMachine &TM,
                                         MachineModuleInfo *MMI,
                                         MCStreamer &Streamer) const override;
 };
 
 } // end namespace llvm
 
 #endif

llvm/trunk/lib/Target/Sparc/SparcTargetObjectFile.cpp

 #include "SparcTargetObjectFile.h"
 #include "MCTargetDesc/SparcMCExpr.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/Target/TargetLowering.h"
 
 using namespace llvm;
 
+void SparcELFTargetObjectFile::Initialize(MCContext &Ctx,
+                                          const TargetMachine &TM) {
+  TargetLoweringObjectFileELF::Initialize(Ctx, TM);
+  InitializeELF(TM.Options.UseInitArray);
+}
+
 const MCExpr *SparcELFTargetObjectFile::getTTypeGlobalReference(
     const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
     MachineModuleInfo *MMI, MCStreamer &Streamer) const {
 
   if (Encoding & dwarf::DW_EH_PE_pcrel) {
     MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
 
     MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", TM);

llvm/trunk/lib/Target/X86/X86TargetMachine.cpp

if (TT.getArch() == Triple::x86_64)
       return llvm::make_unique<X86_64MachoTargetObjectFile>();
     return llvm::make_unique<TargetLoweringObjectFileMachO>();
   }
 
   if (TT.isOSFreeBSD())
     return llvm::make_unique<X86FreeBSDTargetObjectFile>();
   if (TT.isOSLinux() || TT.isOSNaCl() || TT.isOSIAMCU())
     return llvm::make_unique<X86LinuxNaClTargetObjectFile>();
+  if (TT.isOSSolaris())
+    return llvm::make_unique<X86SolarisTargetObjectFile>();
   if (TT.isOSFuchsia())
     return llvm::make_unique<X86FuchsiaTargetObjectFile>();
   if (TT.isOSBinFormatELF())
     return llvm::make_unique<X86ELFTargetObjectFile>();
   if (TT.isKnownWindowsMSVCEnvironment() || TT.isWindowsCoreCLREnvironment())
     return llvm::make_unique<X86WindowsTargetObjectFile>();
   if (TT.isOSBinFormatCOFF())
     return llvm::make_unique<TargetLoweringObjectFileCOFF>();

llvm/trunk/lib/Target/X86/X86TargetObjectFile.h

namespace llvm {
   };
 
   /// 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 Solaris on x86/x86-64.
+  class X86SolarisTargetObjectFile : 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 *
     lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS,
                            const TargetMachine &TM) const override;
 
     /// \brief Given a mergeable constant with the specified size and relocation
     /// information, return a section that it should be placed in.
     MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
                                      const Constant *C,
                                      unsigned &Align) const override;
   };
 
 } // end namespace llvm
 
 #endif

llvm/trunk/lib/Target/X86/X86TargetObjectFile.cpp

 
 void
 X86LinuxNaClTargetObjectFile::Initialize(MCContext &Ctx,
                                          const TargetMachine &TM) {
   TargetLoweringObjectFileELF::Initialize(Ctx, TM);
   InitializeELF(TM.Options.UseInitArray);
 }
 
+void X86SolarisTargetObjectFile::Initialize(MCContext &Ctx,
+                                            const TargetMachine &TM) {
+  TargetLoweringObjectFileELF::Initialize(Ctx, TM);
+  InitializeELF(TM.Options.UseInitArray);
+}
+
 const MCExpr *X86WindowsTargetObjectFile::lowerRelativeReference(
     const GlobalValue *LHS, const GlobalValue *RHS,
     const TargetMachine &TM) const {
   // Our symbols should exist in address space zero, cowardly no-op if
   // otherwise.
   if (LHS->getType()->getPointerAddressSpace() != 0 ||
       RHS->getType()->getPointerAddressSpace() != 0)
     return nullptr;

llvm/trunk/test/CodeGen/SPARC/constructor.ll

+; RUN: llc -mtriple sparc-sun-solaris2.11 -use-ctors < %s | FileCheck --check-prefix=CTOR %s
+; RUN: llc -mtriple sparc-sun-solaris2.11 < %s | FileCheck --check-prefix=INIT-ARRAY %s
[e-mail]_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
+}
+
+define void @g() {
+entry:
+  ret void
+}
+
+; CTOR:    .section  .ctors.65520,#alloc,#write
+; CTOR-NEXT: .p2align      2
+; CTOR-NEXT: .word  g
+; CTOR-NEXT: .section      .ctors,#alloc,#write
+; CTOR-NEXT: .p2align      2
+; CTOR-NEXT: .word  f
+
+; INIT-ARRAY:    .section  .init_array.15,#alloc,#write
+; INIT-ARRAY-NEXT: .p2align  2
+; INIT-ARRAY-NEXT: .word g
+; INIT-ARRAY-NEXT: .section  .init_array,#alloc,#write
+; INIT-ARRAY-NEXT: .p2align  2
+; INIT-ARRAY-NEXT: .word f

llvm/trunk/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-unknown-freebsd -use-ctors < %s | FileCheck --check-prefix=CTOR %s
+; RUN: llc -mtriple x86_64-pc-solaris2.11 -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-freebsd < %s | FileCheck --check-prefix=INIT-ARRAY %s
+; RUN: llc -mtriple x86_64-pc-solaris2.11 < %s | FileCheck --check-prefix=INIT-ARRAY %s
 ; RUN: llc -mtriple x86_64-unknown-nacl < %s | FileCheck --check-prefix=NACL %s
 ; RUN: llc -mtriple i586-intel-elfiamcu -use-ctors < %s | FileCheck %s --check-prefix=MCU-CTORS
 ; RUN: llc -mtriple i586-intel-elfiamcu < %s | FileCheck %s --check-prefix=MCU-INIT-ARRAY
 @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() {