# - https://llvm.org/bugs/show_bug.cgi?id=22623

# - 22346218 - LLVM's assembler printer on SPARC needs a lot of work

# - 21874221 - clang C++ does not properly initialize the C++

# Standard Library's iostreams

# - 22582382 - Sun ld .init_array/.fini_array handling is incompatible

# with the GNU Toolchain

# - 22065707 - LLVM SPARC assembler generator emits wrong ELF Section flags

# For upstream - maybe.

--- include/llvm/MC/MCStreamer.h	2014-12-05 18:14:41.000000000 -0800

+++ include/llvm/MC/MCStreamer.h	2015-12-09 15:14:25.413937273 -0800

@@ -478,6 +478,13 @@

   ///

   virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value);

+  /// EmitELFSize - Emit an ELF .size directive.

+  ///

+  /// This corresponds to an assembler statement such as:

+  ///  .size symbol, expression, but without a temp .label.

+  ///

+  virtual void EmitELFSize(StringRef Name);

+

   /// \brief Emit a Linker Optimization Hint (LOH) directive.

   /// \param Args - Arguments of the LOH.

   virtual void EmitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) {}

--- include/llvm/MC/MCSymbol.h	2014-12-24 02:27:50.000000000 -0800

+++ include/llvm/MC/MCSymbol.h	2015-12-09 14:05:18.864224028 -0800

@@ -51,23 +51,25 @@

     /// IsTemporary - True if this is an assembler temporary label, which

     /// typically does not survive in the .o file's symbol table.  Usually

     /// "Lfoo" or ".foo".

-    unsigned IsTemporary : 1;

+    bool IsTemporary;

     /// \brief True if this symbol can be redefined.

-    unsigned IsRedefinable : 1;

+    bool IsRedefinable;

     /// IsUsed - True if this symbol has been used.

-    mutable unsigned IsUsed : 1;

+    mutable bool IsUsed;

-  private:  // MCContext creates and uniques these.

+  protected:  // MCContext creates and uniques these.

     friend class MCExpr;

     friend class MCContext;

+

     MCSymbol(StringRef name, bool isTemporary)

       : Name(name), Section(nullptr), Value(nullptr),

-        IsTemporary(isTemporary), IsRedefinable(false), IsUsed(false) {}

+      IsTemporary(isTemporary), IsRedefinable(false), IsUsed(false) {}

     MCSymbol(const MCSymbol&) LLVM_DELETED_FUNCTION;

     void operator=(const MCSymbol&) LLVM_DELETED_FUNCTION;

+

   public:

     /// getName - Get the symbol name.

     StringRef getName() const { return Name; }

--- lib/MC/MCAsmStreamer.cpp	2015-01-14 03:23:27.000000000 -0800

+++ lib/MC/MCAsmStreamer.cpp	2015-12-09 15:14:32.728543403 -0800

@@ -40,17 +40,18 @@

 protected:

   formatted_raw_ostream &OS;

   const MCAsmInfo *MAI;

+

 private:

   std::unique_ptr<MCInstPrinter> InstPrinter;

   std::unique_ptr<MCCodeEmitter> Emitter;

   std::unique_ptr<MCAsmBackend> AsmBackend;

-  SmallString<128> CommentToEmit;

+  SmallString<256> CommentToEmit;

   raw_svector_ostream CommentStream;

-  unsigned IsVerboseAsm : 1;

-  unsigned ShowInst : 1;

-  unsigned UseDwarfDirectory : 1;

+  bool IsVerboseAsm;

+  bool ShowInst;

+  bool UseDwarfDirectory;

   void EmitRegisterName(int64_t Register);

   void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;

@@ -61,10 +62,10 @@

                 bool isVerboseAsm, bool useDwarfDirectory,

                 MCInstPrinter *printer, MCCodeEmitter *emitter,

                 MCAsmBackend *asmbackend, bool showInst)

-      : MCStreamer(Context), OS(os), MAI(Context.getAsmInfo()),

-        InstPrinter(printer), Emitter(emitter), AsmBackend(asmbackend),

-        CommentStream(CommentToEmit), IsVerboseAsm(isVerboseAsm),

-        ShowInst(showInst), UseDwarfDirectory(useDwarfDirectory) {

+    : MCStreamer(Context), OS(os), MAI(Context.getAsmInfo()),

+    InstPrinter(printer), Emitter(emitter), AsmBackend(asmbackend),

+    CommentStream(CommentToEmit), IsVerboseAsm(isVerboseAsm),

+    ShowInst(showInst), UseDwarfDirectory(useDwarfDirectory) {

     if (InstPrinter && IsVerboseAsm)

       InstPrinter->setCommentStream(CommentStream);

   }

@@ -75,8 +76,10 @@

       OS << '\n';

       return;

     }

+

     EmitCommentsAndEOL();

   }

+

   void EmitCommentsAndEOL();

   /// isVerboseAsm - Return true if this streamer supports verbose assembly at

@@ -139,6 +142,7 @@

   void EmitCOFFSectionIndex(MCSymbol const *Symbol) override;

   void EmitCOFFSecRel32(MCSymbol const *Symbol) override;

   void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;

+  void EmitELFSize(StringRef Name) override;

   void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,

                         unsigned ByteAlignment) override;

@@ -501,6 +505,11 @@

   OS << "\t.size\t" << *Symbol << ", " << *Value << '\n';

 }

+void MCAsmStreamer::EmitELFSize(StringRef Name) {

+  assert(MAI->hasDotTypeDotSizeDirective());

+  OS << "\t.size\t" << Name << ", .-" << Name << '\n';

+}

+

 void MCAsmStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,

                                      unsigned ByteAlignment) {

   // Common symbols do not belong to any actual section.

@@ -843,7 +852,7 @@

   if (NumFiles == Table.getMCDwarfFiles().size())

     return FileNo;

-  SmallString<128> FullPathName;

+  SmallString<PATH_MAX> FullPathName;

   if (!UseDwarfDirectory && !Directory.empty()) {

     if (sys::path::is_absolute(Filename))

--- lib/MC/MCSectionELF.cpp	2014-10-09 14:23:39.000000000 -0700

+++ lib/MC/MCSectionELF.cpp	2016-01-21 10:12:17.006210825 -0800

@@ -59,8 +59,10 @@

                                         raw_ostream &OS,

                                         const MCExpr *Subsection) const {

+  StringRef SectionName = getSectionName();

+

   if (ShouldOmitSectionDirective(SectionName, MAI)) {

-    OS << '\t' << getSectionName();

+    OS << '\t' << SectionName;

     if (Subsection)

       OS << '\t' << *Subsection;

     OS << '\n';

@@ -68,35 +70,20 @@

   }

   OS << "\t.section\t";

-  printName(OS, getSectionName());

-

-  // Handle the weird solaris syntax if desired.

-  if (MAI.usesSunStyleELFSectionSwitchSyntax() &&

-      !(Flags & ELF::SHF_MERGE)) {

-    if (Flags & ELF::SHF_ALLOC)

-      OS << ",#alloc";

-    if (Flags & ELF::SHF_EXECINSTR)

-      OS << ",#execinstr";

-    if (Flags & ELF::SHF_WRITE)

-      OS << ",#write";

-    if (Flags & ELF::SHF_EXCLUDE)

-      OS << ",#exclude";

-    if (Flags & ELF::SHF_TLS)

-      OS << ",#tls";

-    OS << '\n';

-    return;

-  }

+  printName(OS, SectionName);

   OS << ",\"";

   if (Flags & ELF::SHF_ALLOC)

     OS << 'a';

   if (Flags & ELF::SHF_EXCLUDE)

     OS << 'e';

-  if (Flags & ELF::SHF_EXECINSTR)

+  if ((Flags & ELF::SHF_EXECINSTR) && (Type != ELF::SHT_INIT_ARRAY) &&

+      (Type != ELF::SHT_FINI_ARRAY) && (Type != ELF::SHT_PREINIT_ARRAY))

     OS << 'x';

   if (Flags & ELF::SHF_GROUP)

     OS << 'G';

-  if (Flags & ELF::SHF_WRITE)

+  if ((Flags & ELF::SHF_WRITE) || (Type == ELF::SHT_INIT_ARRAY) ||

+      (Type == ELF::SHT_FINI_ARRAY) || (Type == ELF::SHT_PREINIT_ARRAY))

     OS << 'w';

   if (Flags & ELF::SHF_MERGE)

     OS << 'M';

@@ -144,6 +131,7 @@

     printName(OS, Group->getName());

     OS << ",comdat";

   }

+

   OS << '\n';

   if (Subsection)

--- lib/MC/MCStreamer.cpp	2014-11-03 04:19:03.000000000 -0800

+++ lib/MC/MCStreamer.cpp	2015-12-09 15:15:14.428496845 -0800

@@ -636,6 +636,7 @@

 void MCStreamer::EmitCOFFSymbolStorageClass(int StorageClass) {}

 void MCStreamer::EmitCOFFSymbolType(int Type) {}

 void MCStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {}

+void MCStreamer::EmitELFSize(StringRef Name) {}

 void MCStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,

                                        unsigned ByteAlignment) {}

 void MCStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,

--- tools/clang/lib/CodeGen/CGBlocks.cpp	2015-10-05 11:01:32.352334965 -0700

+++ tools/clang/lib/CodeGen/CGBlocks.cpp	2015-12-07 15:24:59.295683990 -0800

@@ -1248,8 +1248,8 @@

         DI->EmitDeclareOfBlockDeclRefVariable(variable, BlockPointerDbgLoc,

                                               Builder, blockInfo,

-                                              entry_ptr == entry->end()

-                                              ? nullptr : entry_ptr);

+                                              entry_ptr == entry->end() ?

+                                              nullptr : &*entry_ptr);

       }

     }

     // Recover location if it was changed in the above loop.

--- tools/clang/lib/CodeGen/CGCall.cpp	2015-10-05 11:01:32.348582888 -0700

+++ tools/clang/lib/CodeGen/CGCall.cpp	2015-12-07 15:26:25.691201743 -0800

@@ -2230,7 +2230,7 @@

     if (RetAI.getInAllocaSRet()) {

       llvm::Function::arg_iterator EI = CurFn->arg_end();

       --EI;

-      llvm::Value *ArgStruct = EI;

+      llvm::Value *ArgStruct = &*EI;

       llvm::Value *SRet =

           Builder.CreateStructGEP(ArgStruct, RetAI.getInAllocaFieldIndex());

       RV = Builder.CreateLoad(SRet, "sret");

@@ -2246,7 +2246,7 @@

       ComplexPairTy RT =

         EmitLoadOfComplex(MakeNaturalAlignAddrLValue(ReturnValue, RetTy),

                           EndLoc);

-      EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(AI, RetTy),

+      EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(&*AI, RetTy),

                          /*isInit*/ true);

       break;

     }

@@ -2255,7 +2255,7 @@

       break;

     case TEK_Scalar:

       EmitStoreOfScalar(Builder.CreateLoad(ReturnValue),

-                        MakeNaturalAlignAddrLValue(AI, RetTy),

+                        MakeNaturalAlignAddrLValue(&*AI, RetTy),

                         /*isInit*/ true);

       break;

     }

--- tools/clang/lib/CodeGen/CGDeclCXX.cpp	2015-10-05 11:01:32.000000000 -0700

+++ tools/clang/lib/CodeGen/CGDeclCXX.cpp	2016-02-01 09:42:57.409779098 -0800

@@ -23,6 +23,8 @@

 using namespace clang;

 using namespace CodeGen;

+static unsigned InitPriority = 128;

+

 static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D,

                          llvm::Constant *DeclPtr) {

   assert(D.hasGlobalStorage() && "VarDecl must have global storage!");

@@ -137,9 +139,9 @@

                                                bool PerformInit) {

   const Expr *Init = D.getInit();

-  QualType T = D.getType();

+  QualType QT = D.getType();

-  if (!T->isReferenceType()) {

+  if (!QT->isReferenceType()) {

     if (getLangOpts().OpenMP && D.hasAttr<OMPThreadPrivateDeclAttr>())

       (void)CGM.getOpenMPRuntime().EmitOMPThreadPrivateVarDefinition(

           &D, DeclPtr, D.getAttr<OMPThreadPrivateDeclAttr>()->getLocation(),

@@ -157,7 +159,7 @@

          "destruction for reference");

   unsigned Alignment = getContext().getDeclAlign(&D).getQuantity();

   RValue RV = EmitReferenceBindingToExpr(Init);

-  EmitStoreOfScalar(RV.getScalarVal(), DeclPtr, false, Alignment, T);

+  EmitStoreOfScalar(RV.getScalarVal(), DeclPtr, false, Alignment, QT);

 }

 /// Create a stub function, suitable for being passed to atexit,

@@ -166,22 +168,25 @@

                                                   llvm::Constant *dtor,

                                                   llvm::Constant *addr) {

   // Get the destructor function type, void(*)(void).

-  llvm::FunctionType *ty = llvm::FunctionType::get(CGM.VoidTy, false);

-  SmallString<256> FnName;

+  llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);

+  SmallString<512> FnName;

   {

     llvm::raw_svector_ostream Out(FnName);

     CGM.getCXXABI().getMangleContext().mangleDynamicAtExitDestructor(&VD, Out);

   }

-  llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction(ty, FnName.str(),

-                                                              VD.getLocation());

+

+  llvm::Function *Fn =

+    CGM.CreateGlobalInitOrDestructFunction(FTy, FnName.str(),

+                                           VD.getLocation());

   CodeGenFunction CGF(CGM);

-  CGF.StartFunction(&VD, CGM.getContext().VoidTy, fn,

-                    CGM.getTypes().arrangeNullaryFunction(), FunctionArgList());

+  CGF.StartFunction(&VD, CGM.getContext().VoidTy, Fn,

+                    CGM.getTypes().arrangeNullaryFunction(),

+                    FunctionArgList());

   llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr);

- 

+

  // Make sure the call and the callee agree on calling convention.

   if (llvm::Function *dtorFn =

         dyn_cast<llvm::Function>(dtor->stripPointerCasts()))

@@ -189,7 +194,7 @@

   CGF.FinishFunction();

-  return fn;

+  return Fn;

 }

 /// Register a global destructor using the C atexit runtime function.

@@ -203,12 +208,12 @@

   llvm::FunctionType *atexitTy =

     llvm::FunctionType::get(IntTy, dtorStub->getType(), false);

-  llvm::Constant *atexit =

+  llvm::Constant *atExit =

     CGM.CreateRuntimeFunction(atexitTy, "atexit");

-  if (llvm::Function *atexitFn = dyn_cast<llvm::Function>(atexit))

+  if (llvm::Function *atexitFn = dyn_cast<llvm::Function>(atExit))

     atexitFn->setDoesNotThrow();

-  EmitNounwindRuntimeCall(atexit, dtorStub);

+  EmitNounwindRuntimeCall(atExit, dtorStub);

 }

 void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D,

@@ -225,15 +230,29 @@

   CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr, PerformInit);

 }

-llvm::Function *CodeGenModule::CreateGlobalInitOrDestructFunction(

-    llvm::FunctionType *FTy, const Twine &Name, SourceLocation Loc, bool TLS) {

+llvm::Function*

+CodeGenModule::CreateGlobalInitOrDestructFunction(llvm::FunctionType *FTy,

+                                                  const Twine &Name,

+                                                  SourceLocation Loc,

+                                                  bool TLS) {

   llvm::Function *Fn =

     llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage,

                            Name, &getModule());

+

+  // Set the section if needed.

   if (!getLangOpts().AppleKext && !TLS) {

-    // Set the section if needed.

-    if (const char *Section = getTarget().getStaticInitSectionSpecifier())

-      Fn->setSection(Section);

+    if (const char *Section = getTarget().getStaticInitSectionSpecifier()) {

+      if (getTriple().getOS() == llvm::Triple::Solaris) {

+        std::string FNm = Fn->getName().str();

+        if ((FNm.find("_GLOBAL__sub_I_") != std::string::npos) &&

+            !CodeGenOpts.UseInitArray)

+          Fn->setSection(Section);

+        else

+          Fn->setSection(".text");

+      } else {

+        Fn->setSection(Section);

+      }

+    }

   }

   Fn->setCallingConv(getRuntimeCC());

@@ -241,13 +260,16 @@

   if (!getLangOpts().Exceptions)

     Fn->setDoesNotThrow();

-  if (!isInSanitizerBlacklist(Fn, Loc)) {

-    if (getLangOpts().Sanitize.has(SanitizerKind::Address))

-      Fn->addFnAttr(llvm::Attribute::SanitizeAddress);

-    if (getLangOpts().Sanitize.has(SanitizerKind::Thread))

-      Fn->addFnAttr(llvm::Attribute::SanitizeThread);

-    if (getLangOpts().Sanitize.has(SanitizerKind::Memory))

-      Fn->addFnAttr(llvm::Attribute::SanitizeMemory);

+  // Solaris does not yet support the Sanitizer Libraries.

+  if (getTriple().getOS() != llvm::Triple::Solaris) {

+    if (!isInSanitizerBlacklist(Fn, Loc)) {

+      if (getLangOpts().Sanitize.has(SanitizerKind::Address))

+        Fn->addFnAttr(llvm::Attribute::SanitizeAddress);

+      if (getLangOpts().Sanitize.has(SanitizerKind::Thread))

+        Fn->addFnAttr(llvm::Attribute::SanitizeThread);

+      if (getLangOpts().Sanitize.has(SanitizerKind::Memory))

+        Fn->addFnAttr(llvm::Attribute::SanitizeMemory);

+    }

   }

   return Fn;

@@ -260,9 +282,21 @@

                                           llvm::GlobalVariable *GV,

                                           llvm::Function *InitFunc,

                                           InitSegAttr *ISA) {

-  llvm::GlobalVariable *PtrArray = new llvm::GlobalVariable(

-      TheModule, InitFunc->getType(), /*isConstant=*/true,

-      llvm::GlobalValue::PrivateLinkage, InitFunc, "__cxx_init_fn_ptr");

+  std::string GVN("__cxx_init_fn_ptr");

+  if (getTriple().getOS() == llvm::Triple::Solaris) {

+    GVN += "_";

+    GVN += std::to_string(InitPriority++);

+  }

+

+  llvm::GlobalVariable *PtrArray = nullptr;

+

+  PtrArray = new llvm::GlobalVariable(TheModule, InitFunc->getType(),

+                                      /*isConstant=*/ true,

+                                      llvm::GlobalValue::PrivateLinkage,

+                                      InitFunc, GVN);

+

+  assert(PtrArray && "Invalid Function Pointer Array!");

+

   PtrArray->setSection(ISA->getSection());

   addUsedGlobal(PtrArray);

@@ -283,22 +317,76 @@

 CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,

                                             llvm::GlobalVariable *Addr,

                                             bool PerformInit) {

-  llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);

+  llvm::FunctionType *FTy = nullptr;

+  std::vector<llvm::Type*> ArgsVec;

+

+  if (getTriple().getOS() == llvm::Triple::Solaris) {

+    ArgsVec.push_back(IntTy);

+    ArgsVec.push_back(IntTy);

+    FTy = llvm::FunctionType::get(VoidTy, ArgsVec, false);

+  } else {

+    FTy = llvm::FunctionType::get(VoidTy, false);

+  }

+

   SmallString<256> FnName;

   {

     llvm::raw_svector_ostream Out(FnName);

-    getCXXABI().getMangleContext().mangleDynamicInitializer(D, Out);

+    if (getTriple().getOS() == llvm::Triple::Solaris)

+      getCXXABI().getMangleContext().mangleGCCDynamicInitializer(D, Out);

+    else

+      getCXXABI().getMangleContext().mangleDynamicInitializer(D, Out);

   }

   // Create a variable initialization function.

   llvm::Function *Fn =

       CreateGlobalInitOrDestructFunction(FTy, FnName.str(), D->getLocation());

+  Fn->setDoesNotThrow();

   auto *ISA = D->getAttr<InitSegAttr>();

-  CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr,

-                                                          PerformInit);

-  llvm::GlobalVariable *COMDATKey =

+  if (getTriple().getOS() == llvm::Triple::Solaris) {

+    ASTContext &Ctx = getContext();

+    auto *IPA = D->getAttr<InitPriorityAttr>();

+    if (!IPA) {

+      IPA = InitPriorityAttr::CreateImplicit(Ctx, /* InitPriority */ 65535);

+      VarDecl *DD = const_cast<VarDecl*>(D);

+      DD->addAttr(IPA);

+    }

+

+    if (!ISA && CodeGenOpts.UseInitArray) {

+      ISA = InitSegAttr::CreateImplicit(Ctx, PerformInit ?

+                                        StringRef(".init_array") :

+                                        StringRef(".fini_array"));

+      VarDecl *DD = const_cast<VarDecl*>(D);

+      DD->addAttr(ISA);

+    }

+  }

+

+  FunctionArgList ArgList;

+  ASTContext &Ctx = getContext();

+  // We cannot allocate these dynamically because of a very ill-conceived

+  // operator new overload in DeclBase.h.

+  ImplicitParamDecl IAFirst(Ctx, /*DC=*/ nullptr, D->getLocation(),

+                            /*Id=*/ nullptr, Ctx.UnsignedIntTy);

+  ImplicitParamDecl IASecond(Ctx, /*DC=*/ nullptr, D->getLocation(),

+                             /*Id=*/ nullptr, Ctx.UnsignedIntTy);

+

+  if (getTriple().getOS() == llvm::Triple::Solaris) {

+    // Add Parameters to the Function ArgumentList on Solaris

+    // for compatibility with the GCC C++ Runtime.

+    ArgList.push_back(&IAFirst);

+    ArgList.push_back(&IASecond);

+  }

+

+  CodeGenFunction CGF(*this);

+  CGF.GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr, PerformInit, ArgList);

+

+  llvm::GlobalVariable *COMDATKey;

+

+  if (getTriple().getOS() == llvm::Triple::Solaris)

+    COMDATKey = D->isExternallyVisible() ? Addr : nullptr;

+  else

+    COMDATKey =

       supportsCOMDAT() && D->isExternallyVisible() ? Addr : nullptr;

   if (D->getTLSKind()) {

@@ -370,7 +458,6 @@

   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);

-

   // Create our global initialization function.

   if (!PrioritizedCXXGlobalInits.empty()) {

     SmallVector<llvm::Function *, 8> LocalCXXGlobalInits;

@@ -391,9 +478,10 @@

       // sure the function names are also ordered as priorities.

       std::string PrioritySuffix = llvm::utostr(Priority);

       // Priority is always <= 65535 (enforced by sema).

-      PrioritySuffix = std::string(6-PrioritySuffix.size(), '0')+PrioritySuffix;

-      llvm::Function *Fn = CreateGlobalInitOrDestructFunction(

-          FTy, "_GLOBAL__I_" + PrioritySuffix);

+      PrioritySuffix =

+        std::string(6 - PrioritySuffix.size(), '0') + PrioritySuffix;

+      llvm::Function *Fn =

+        CreateGlobalInitOrDestructFunction(FTy, "_GLOBAL__I_" + PrioritySuffix);

       for (; I < PrioE; ++I)