LDC: Apply Joakim's Android patches for respective targets

Author: kinke

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

@@ -232,8 +232,9 @@ const MCExpr *TargetLoweringObjectFileELF::getTTypeGlobalReference(
                                                            MMI, Streamer);
 }
 
-static SectionKind getELFKindForNamedSection(StringRef Name, SectionKind K) {
-  // N.B.: The defaults used in here are not the same ones used in MC.
+static SectionKind getELFKindForNamedSection(StringRef Name, SectionKind K,
+                                             const Triple &TargetTriple) {
+  // N.B.: The defaults used in here are no the same ones used in MC.
   // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
   // both gas and MC will produce a section with no flags. Given
   // section(".eh_frame") gcc will produce:
@@ -264,6 +265,7 @@ static SectionKind getELFKindForNamedSection(StringRef Name, SectionKind K) {
     return SectionKind::getThreadData();
 
   if (Name == ".tbss" ||
+      (TargetTriple.isAndroid() && Name == ".tcommon") || // LDC
       Name.startswith(".tbss.") ||
       Name.startswith(".gnu.linkonce.tb.") ||
       Name.startswith(".llvm.linkonce.tb."))
@@ -294,7 +296,7 @@ static unsigned getELFSectionType(StringRef Name, SectionKind K) {
   return ELF::SHT_PROGBITS;
 }
 
-static unsigned getELFSectionFlags(SectionKind K) {
+static unsigned getELFSectionFlags(SectionKind K, const Triple &TargetTriple) {
   unsigned Flags = 0;
 
   if (!K.isMetadata())
@@ -309,7 +311,7 @@ static unsigned getELFSectionFlags(SectionKind K) {
   if (K.isWriteable())
     Flags |= ELF::SHF_WRITE;
 
-  if (K.isThreadLocal())
+  if (K.isThreadLocal() && !TargetTriple.isAndroid()) // LDC
     Flags |= ELF::SHF_TLS;
 
   if (K.isMergeableCString() || K.isMergeableConst())
@@ -375,10 +377,10 @@ MCSection *TargetLoweringObjectFileELF::getExplicitSectionGlobal(
   }
 
   // Infer section flags from the section name if we can.
-  Kind = getELFKindForNamedSection(SectionName, Kind);
+  Kind = getELFKindForNamedSection(SectionName, Kind, getTargetTriple());
 
   StringRef Group = "";
-  unsigned Flags = getELFSectionFlags(Kind);
+  unsigned Flags = getELFSectionFlags(Kind, getTargetTriple());
   if (const Comdat *C = getELFComdat(GO)) {
     Group = C->getName();
     Flags |= ELF::SHF_GROUP;
@@ -502,7 +504,7 @@ static MCSectionELF *selectELFSectionForGlobal(
 
 MCSection *TargetLoweringObjectFileELF::SelectSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
-  unsigned Flags = getELFSectionFlags(Kind);
+  unsigned Flags = getELFSectionFlags(Kind, getTargetTriple());
 
   // If we have -ffunction-section or -fdata-section then we should emit the
   // global value to a uniqued section specifically for it.

lib/MC/MCELFStreamer.cpp

@@ -448,7 +448,12 @@ void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
       break;
     }
     getAssembler().registerSymbol(symRef.getSymbol());
-    cast<MCSymbolELF>(symRef.getSymbol()).setType(ELF::STT_TLS);
+    // LDC
+    {
+      auto ofi = getContext().getObjectFileInfo();
+      if (!(ofi && ofi->getTargetTriple().isAndroid()))
+        cast<MCSymbolELF>(symRef.getSymbol()).setType(ELF::STT_TLS);
+    }
     break;
   }
 

lib/MC/MCObjectFileInfo.cpp

@@ -489,12 +489,14 @@ void MCObjectFileInfo::initELFMCObjectFileInfo(const Triple &T, bool Large) {
   ReadOnlySection =
       Ctx->getELFSection(".rodata", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
 
-  TLSDataSection =
-      Ctx->getELFSection(".tdata", ELF::SHT_PROGBITS,
-                         ELF::SHF_ALLOC | ELF::SHF_TLS | ELF::SHF_WRITE);
+  // LDC
+  const auto tlsFlag = (!getTargetTriple().isAndroid() ? ELF::SHF_TLS : 0);
 
-  TLSBSSSection = Ctx->getELFSection(
-      ".tbss", ELF::SHT_NOBITS, ELF::SHF_ALLOC | ELF::SHF_TLS | ELF::SHF_WRITE);
+  TLSDataSection = Ctx->getELFSection(
+      ".tdata", ELF::SHT_PROGBITS, ELF::SHF_ALLOC | tlsFlag | ELF::SHF_WRITE);
+
+  TLSBSSSection = Ctx->getELFSection(".tbss", ELF::SHT_NOBITS,
+                                     ELF::SHF_ALLOC | tlsFlag | ELF::SHF_WRITE);
 
   DataRelROSection = Ctx->getELFSection(".data.rel.ro", ELF::SHT_PROGBITS,
                                         ELF::SHF_ALLOC | ELF::SHF_WRITE);

lib/Target/AArch64/AArch64ISelLowering.cpp

@@ -4149,6 +4149,31 @@ AArch64TargetLowering::LowerELFGlobalTLSAddress(SDValue Op,
   return DAG.getNode(ISD::ADD, DL, PtrVT, ThreadBase, TPOff);
 }
 
+SDValue
+AArch64TargetLowering::LowerAndroidGlobalTLSAddress(SDValue Op,
+                                                    SelectionDAG &DAG) const {
+  assert(Subtarget->isTargetELF() && "This function expects an ELF target");
+  SDLoc DL(Op);
+  SDValue Result = LowerGlobalAddress(Op, DAG);
+  SDValue Chain = DAG.getEntryNode();
+  ArgListTy Args;
+  ArgListEntry Entry;
+  Type *Ty = (Type *)Type::getInt64Ty(*DAG.getContext());
+  Entry.Node = Result;
+  Entry.Ty = Ty;
+  Args.push_back(Entry);
+
+  // copied, modified from ARMTargetLowering::LowerToTLSGeneralDynamicModel
+  TargetLowering::CallLoweringInfo CLI(DAG);
+  CLI.setDebugLoc(DL).setChain(Chain).setLibCallee(
+      CallingConv::C, Ty,
+      DAG.getExternalSymbol("__tls_get_addr",
+                            getPointerTy(DAG.getDataLayout())),
+      std::move(Args));
+  std::pair<SDValue, SDValue> CallResult = LowerCallTo(CLI);
+  return CallResult.first;
+}
+
 SDValue
 AArch64TargetLowering::LowerWindowsGlobalTLSAddress(SDValue Op,
                                                     SelectionDAG &DAG) const {
@@ -4216,8 +4241,12 @@ SDValue AArch64TargetLowering::LowerGlobalTLSAddress(SDValue Op,
 
   if (Subtarget->isTargetDarwin())
     return LowerDarwinGlobalTLSAddress(Op, DAG);
-  if (Subtarget->isTargetELF())
-    return LowerELFGlobalTLSAddress(Op, DAG);
+  if (Subtarget->isTargetELF()) {
+    if (Subtarget->isTargetAndroid())
+      return LowerAndroidGlobalTLSAddress(Op, DAG); // LDC
+    else
+      return LowerELFGlobalTLSAddress(Op, DAG);
+  }
   if (Subtarget->isTargetWindows())
     return LowerWindowsGlobalTLSAddress(Op, DAG);
 

lib/Target/AArch64/AArch64ISelLowering.h

@@ -589,6 +589,7 @@ class AArch64TargetLowering : public TargetLowering {
   SDValue LowerADDROFRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
+  SDValue LowerAndroidGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const; // LDC
   SDValue LowerDarwinGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerELFGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerELFTLSDescCallSeq(SDValue SymAddr, const SDLoc &DL,

lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.cpp

@@ -13,7 +13,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "AArch64MCExpr.h"
+#include "llvm/MC/MCAssembler.h" // LDC
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCObjectFileInfo.h" // LDC
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCValue.h"
@@ -122,7 +124,12 @@ static void fixELFSymbolsInTLSFixupsImpl(const MCExpr *Expr, MCAssembler &Asm) {
     // We're known to be under a TLS fixup, so any symbol should be
     // modified. There should be only one.
     const MCSymbolRefExpr &SymRef = *cast<MCSymbolRefExpr>(Expr);
-    cast<MCSymbolELF>(SymRef.getSymbol()).setType(ELF::STT_TLS);
+    // LDC
+    {
+      auto ofi = Asm.getContext().getObjectFileInfo();
+      if (!(ofi && ofi->getTargetTriple().isAndroid()))
+        cast<MCSymbolELF>(SymRef.getSymbol()).setType(ELF::STT_TLS);
+    }
     break;
   }
 

lib/Target/ARM/MCTargetDesc/ARMAsmBackendELF.h

@@ -18,15 +18,19 @@ using namespace llvm;
 
 namespace {
 class ARMAsmBackendELF : public ARMAsmBackend {
+  // LDC
+  const bool isAndroid;
+
 public:
   uint8_t OSABI;
   ARMAsmBackendELF(const Target &T, const MCSubtargetInfo &STI, uint8_t OSABI,
                    support::endianness Endian)
-      : ARMAsmBackend(T, STI, Endian), OSABI(OSABI) {}
+      : ARMAsmBackend(T, STI, Endian),
+        isAndroid(STI.getTargetTriple().isAndroid()), OSABI(OSABI) {}
 
   std::unique_ptr<MCObjectTargetWriter>
   createObjectTargetWriter() const override {
-    return createARMELFObjectWriter(OSABI);
+    return createARMELFObjectWriter(OSABI, isAndroid);
   }
 };
 }

lib/Target/ARM/MCTargetDesc/ARMELFObjectWriter.cpp

@@ -25,13 +25,16 @@ using namespace llvm;
 namespace {
 
   class ARMELFObjectWriter : public MCELFObjectTargetWriter {
+    // LDC
+    const bool isAndroid;
+
     enum { DefaultEABIVersion = 0x05000000U };
 
     unsigned GetRelocTypeInner(const MCValue &Target, const MCFixup &Fixup,
                                bool IsPCRel, MCContext &Ctx) const;
 
   public:
-    ARMELFObjectWriter(uint8_t OSABI);
+    ARMELFObjectWriter(uint8_t OSABI, bool IsAndroid);
 
     ~ARMELFObjectWriter() override = default;
 
@@ -44,10 +47,10 @@ namespace {
 
 } // end anonymous namespace
 
-ARMELFObjectWriter::ARMELFObjectWriter(uint8_t OSABI)
-  : MCELFObjectTargetWriter(/*Is64Bit*/ false, OSABI,
-                            ELF::EM_ARM,
-                            /*HasRelocationAddend*/ false) {}
+ARMELFObjectWriter::ARMELFObjectWriter(uint8_t OSABI, bool IsAndroid)
+    : MCELFObjectTargetWriter(/*Is64Bit*/ false, OSABI, ELF::EM_ARM,
+                              /*HasRelocationAddend*/ false),
+      isAndroid(IsAndroid) {}
 
 bool ARMELFObjectWriter::needsRelocateWithSymbol(const MCSymbol &Sym,
                                                  unsigned Type) const {
@@ -164,7 +167,8 @@ unsigned ARMELFObjectWriter::GetRelocTypeInner(const MCValue &Target,
     case MCSymbolRefExpr::VK_GOT:
       return ELF::R_ARM_GOT_BREL;
     case MCSymbolRefExpr::VK_TLSGD:
-      return ELF::R_ARM_TLS_GD32;
+      // LDC
+      return isAndroid ? ELF::R_ARM_GOT_PREL : ELF::R_ARM_TLS_GD32;
     case MCSymbolRefExpr::VK_TPOFF:
       return ELF::R_ARM_TLS_LE32;
     case MCSymbolRefExpr::VK_GOTTPOFF:
@@ -237,6 +241,6 @@ unsigned ARMELFObjectWriter::GetRelocTypeInner(const MCValue &Target,
 }
 
 std::unique_ptr<MCObjectTargetWriter>
-llvm::createARMELFObjectWriter(uint8_t OSABI) {
-  return llvm::make_unique<ARMELFObjectWriter>(OSABI);
+llvm::createARMELFObjectWriter(uint8_t OSABI, bool IsAndroid) {
+  return llvm::make_unique<ARMELFObjectWriter>(OSABI, IsAndroid);
 }

lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h

@@ -87,7 +87,8 @@ MCStreamer *createARMWinCOFFStreamer(MCContext &Context,
                                      bool IncrementalLinkerCompatible);
 
 /// Construct an ELF Mach-O object writer.
-std::unique_ptr<MCObjectTargetWriter> createARMELFObjectWriter(uint8_t OSABI);
+std::unique_ptr<MCObjectTargetWriter> createARMELFObjectWriter(uint8_t OSABI,
+                                                               bool IsAndroid);
 
 /// Construct an ARM Mach-O object writer.
 std::unique_ptr<MCObjectTargetWriter>

lib/Target/X86/MCTargetDesc/X86ELFObjectWriter.cpp

@@ -15,6 +15,7 @@
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixup.h"
+#include "llvm/MC/MCObjectFileInfo.h" // LDC
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -260,7 +261,12 @@ static unsigned getRelocType32(MCContext &Ctx,
   case MCSymbolRefExpr::VK_TLSGD:
     assert(Type == RT32_32);
     assert(!IsPCRel);
-    return ELF::R_386_TLS_GD;
+    // LDC
+    {
+      auto ofi = Ctx.getObjectFileInfo();
+      return ofi && ofi->getTargetTriple().isAndroid() ? ELF::R_386_GOT32
+                                                       : ELF::R_386_TLS_GD;
+    }
   case MCSymbolRefExpr::VK_GOTTPOFF:
     assert(Type == RT32_32);
     assert(!IsPCRel);