Small Data SectionKind and PPC-EABI SDA Relocation

[jackoalan]

Summary

This patch refactors GlobalVariable section classification on targets by adding the target-independent notion of small-data sections in SectionKind. This is done by logically extending those sections that may be small, with existing predicates masking the "small bit" out:

/// SmallDataSections - Data sections where individual entries are capped
/// for size, typically for global-register-relative relocation.
/// These test as logical equivalents with respect to their unspecified
/// counterparts, but not vice-versa.

   /// SmallKindMask - Used to access the underlying Kind
   SmallKindMask = 0x7f,

   /// SmallData - This is writeable data that has a non-zero initializer.
   SmallData = (Data | 0x80),

   /// SmallReadOnly - This is non-writeable data that has a non-zero
   /// initializer.
   SmallReadOnly = (ReadOnly | 0x80),

   /// SmallBSS - This is writeable data that has a zero initializer.
   SmallBSS = (BSS | 0x80),

   /// SmallCommon - These represent tentative definitions, which always
   /// have a zero initializer and are never marked 'constant'.
   SmallCommon = (Common | 0x80)

Small data support calls were seemingly duplicated from the Mips TargetLoweringObjectFile into Hexagon and Lanai targets. This has been folded into a virtual TargetLoweringObjectFile::isGlobalInSmallSectionKind method; targets may implement this to share the core SectionKind classification mechanism invoked by TargetLoweringObjectFile::getKindForGlobal. TargetLoweringObjectFile::isGlobalInSmallSection is a new target-independent way to perform this test on any GlobalObject, definition or declaration. Additionally, this aids SelectionDAG implementations by having a consistent and clear predicate when producing small data access code.

Additionally, a new PPC-EABI Subtarget is defined with memri relocation triggering to take advantage of the R_PPC_EMB_SDA21 relocation type.

[sdardis]

include/llvm/MC/SectionKind.h

121

You should define SmallKind = 0x80, and use that throughout instead of the magic number 0x80.

138

Bikeshedding, but I think this should be BaseKind() or UnderlyingKind().

[jackoalan]

Create SmallKind = 0x80 enum entry, rename smallUnderlyingKind() to UnderlyingKind()

[jackoalan]

Little-endian addressing fix. Uses addressing described in "3.1.4.4 PowerPC Instruction Addressing in Little-Endian Mode" section of programming manual. (needed to think of it from the offset operand end)

IsLittleEndian? 0 : 1

[echristo]

I'd very much like to avoid this use of the subtarget here. You're basing object file level code generation based on something that changes on a per function basis and not on a global basis. I don't think the mips port is a good foundation to build this work on top of here.

My suggestion would be to base it upon either a) the target triple, or b) the information in the top level TargetMachine without the lower level subtarget info.

Thanks.

-eric

[jackoalan]

Remove PPCSubtarget:: useEABISmallDataSections() flag, opting for direct TargetTriple::isEABI().

Also remove intrinsically redundant EABI conditionals within PPCEmbeddedTargetObjectFile imps.

[jackoalan]

Remove stray blank line, Rebase against upstream master.

[jackoalan]

Rebase against latest master. check-all test results match those experienced on base master.

[kparzysz]

Looks ok from Hexagon's perspective.

[jackoalan]

Object file ABI tag is now set with the following for PPC:

uint8_t OSABI = TT.isEABI() ? ELF::ELFOSABI_STANDALONE :
                MCELFObjectTargetWriter::getOSABI(TT.getOS());

Linker can now deterministically synthesize _SDA_BASE_ symbols for EABI targets.

Also add tests for ADDR14 and REL14 relocations.

[jackoalan]

To better follow GCC convention, use sda21 rather than sdarx as the symbol variant.

Also remove stray getSubtargetImpl and register-strip-prevention unrelated to patch.

[jackoalan]

Add target-independent small data classification for constants via MachineConstantPoolEntry::getSectionKind().

[jackoalan]

Rebase against upstream master

[echristo]

lib/Target/PowerPC/PPCTargetObjectFile.cpp

15

I don't think you need this anymore FWIW.

include/llvm/ADT/Triple.h

return getEnvironment() == Triple::Musl ||
            getEnvironment() == Triple::MuslEABIHF;
   }
 
   /// Tests whether the target is NVPTX (32- or 64-bit).
   bool isNVPTX() const {
     return getArch() == Triple::nvptx || getArch() == Triple::nvptx64;
   }
 
-  /// Tests wether the target supports comdat
+  /// Tests whether the environment is EABI
+  bool isEABI() const { return getEnvironment() == Triple::EABI; }
+
+  /// Tests whether the target supports comdat
   bool supportsCOMDAT() const { return !isOSBinFormatMachO(); }
 
   /// @}
   /// @name Mutators
   /// @{
 
   /// setArch - Set the architecture (first) component of the triple
   /// to a known type.

include/llvm/CodeGen/MachineConstantPool.h

public:
 
   Type *getType() const;
 
   /// This method classifies the entry according to whether or not it may
   /// generate a relocation entry.  This must be conservative, so if it might
   /// codegen to a relocatable entry, it should say so.
   bool needsRelocation() const;
 
-  SectionKind getSectionKind(const DataLayout *DL) const;
+  SectionKind getSectionKind(const DataLayout *DL,
+                             const TargetMachine &TM) const;
 };
 
 /// The MachineConstantPool class keeps track of constants referenced by a
 /// function which must be spilled to memory.  This is used for constants which
 /// are unable to be used directly as operands to instructions, which typically
 /// include floating point and large integer constants.
 ///
 /// Instructions reference the address of these constant pool constants through

include/llvm/MC/MCExpr.h

enum VariantKind : uint16_t {
     VK_PPC_GOT_TLSGD_HA,   // symbol@got@tlsgd@ha
     VK_PPC_TLSGD,          // symbol@tlsgd
     VK_PPC_GOT_TLSLD,      // symbol@got@tlsld
     VK_PPC_GOT_TLSLD_LO,   // symbol@got@tlsld@l
     VK_PPC_GOT_TLSLD_HI,   // symbol@got@tlsld@h
     VK_PPC_GOT_TLSLD_HA,   // symbol@got@tlsld@ha
     VK_PPC_TLSLD,          // symbol@tlsld
     VK_PPC_LOCAL,          // symbol@local
+    VK_PPC_SDA,            // symbol@sda21
 
     VK_COFF_IMGREL32, // symbol@imgrel (image-relative)
 
     VK_Hexagon_PCREL,
     VK_Hexagon_LO16,
     VK_Hexagon_HI16,
     VK_Hexagon_GPREL,
     VK_Hexagon_GD_GOT,

include/llvm/MC/SectionKind.h

/// to during program runtime.
                /// BSSExtern - This is BSS data with normal external linkage.
                BSSExtern,
 
            /// Common - Data with common linkage.  These represent tentative
            /// definitions, which always have a zero initializer and are never
            /// marked 'constant'.
            Common,
 
-           /// This is writeable data that has a non-zero initializer.
+           /// Data - This is writeable data that has a non-zero initializer.
            Data,
 
            /// ReadOnlyWithRel - These are global variables that are never
            /// written to by the program, but that have relocations, so they
            /// must be stuck in a writeable section so that the dynamic linker
            /// can write to them.  If it chooses to, the dynamic linker can
            /// mark the pages these globals end up on as read-only after it is
            /// done with its relocation phase.
-           ReadOnlyWithRel
+           ReadOnlyWithRel,
+
+    /// SmallDataSections - Data sections where individual entries are capped
+    /// for size, typically for global-register-relative relocation.
+    /// These test as logical equivalents with respect to their unspecified
+    /// counterparts, but not vice-versa.
+
+       /// SmallKindMask - Used to access the underlying Kind
+       SmallKindMask = 0x7f,
+
+       /// SmallKind - Used to logically qualify a type as small
+       SmallKind = 0x80,
+
+       /// SmallData - This is writeable data that has a non-zero initializer.
+       SmallData = (Data | SmallKind),
+
+       /// SmallReadOnly - This is non-writeable data that has a non-zero
+       /// initializer.
+       SmallReadOnly = (ReadOnly | SmallKind),
+
+       /// SmallBSS - This is writeable data that has a zero initializer.
+       SmallBSS = (BSS | SmallKind),
+
+       /// SmallCommon - These represent tentative definitions, which always
+       /// have a zero initializer and are never marked 'constant'.
+       SmallCommon = (Common | SmallKind)
   } K : 8;
+
+  int UnderlyingKind() const { return K & SmallKindMask; }
+
 public:
 
   bool isMetadata() const { return K == Metadata; }
   bool isText() const { return K == Text; }
 
   bool isReadOnly() const {
-    return K == ReadOnly || isMergeableCString() ||
+    return UnderlyingKind() == ReadOnly || isMergeableCString() ||
            isMergeableConst();
   }
 
   bool isMergeableCString() const {
     return K == Mergeable1ByteCString || K == Mergeable2ByteCString ||
            K == Mergeable4ByteCString;
   }
   bool isMergeable1ByteCString() const { return K == Mergeable1ByteCString; }
public:
 
   bool isThreadBSS() const { return K == ThreadBSS; }
   bool isThreadData() const { return K == ThreadData; }
 
   bool isGlobalWriteableData() const {
     return isBSS() || isCommon() || isData() || isReadOnlyWithRel();
   }
 
-  bool isBSS() const { return K == BSS || K == BSSLocal || K == BSSExtern; }
-  bool isBSSLocal() const { return K == BSSLocal; }
-  bool isBSSExtern() const { return K == BSSExtern; }
+  bool isBSS() const {
+    int UK = UnderlyingKind();
+    return UK == BSS || UK == BSSLocal || UK == BSSExtern;
+  }
+  bool isBSSLocal() const { return UnderlyingKind() == BSSLocal; }
+  bool isBSSExtern() const { return UnderlyingKind() == BSSExtern; }
 
-  bool isCommon() const { return K == Common; }
+  bool isCommon() const { return UnderlyingKind() == Common; }
 
-  bool isData() const { return K == Data; }
+  bool isData() const { return UnderlyingKind() == Data; }
 
   bool isReadOnlyWithRel() const {
     return K == ReadOnlyWithRel;
   }
+
+  bool isSmallData() const { return K == SmallData; }
+  bool isSmallReadOnly() const { return K == SmallReadOnly; }
+  bool isSmallBSS() const { return K == SmallBSS; }
+  bool isSmallCommon() const { return K == SmallCommon; }
+  bool isSmallKind() const { return (K & SmallKind) == SmallKind; }
 private:
   static SectionKind get(Kind K) {
     SectionKind Res;
     Res.K = K;
     return Res;
   }
 public:
 
public:
   static SectionKind getThreadBSS() { return get(ThreadBSS); }
   static SectionKind getThreadData() { return get(ThreadData); }
   static SectionKind getBSS() { return get(BSS); }
   static SectionKind getBSSLocal() { return get(BSSLocal); }
   static SectionKind getBSSExtern() { return get(BSSExtern); }
   static SectionKind getCommon() { return get(Common); }
   static SectionKind getData() { return get(Data); }
   static SectionKind getReadOnlyWithRel() { return get(ReadOnlyWithRel); }
+  static SectionKind getSmallData() { return get(SmallData); }
+  static SectionKind getSmallReadOnly() { return get(SmallReadOnly); }
+  static SectionKind getSmallBSS() { return get(SmallBSS); }
+  static SectionKind getSmallCommon() { return get(SmallCommon); }
 };
 
 } // end namespace llvm
 
 #endif

include/llvm/Support/ELFRelocs/PowerPC.def

 #undef R_PPC_GOT_TPREL16_HI
 #undef R_PPC_GOT_TPREL16_HA
 #undef R_PPC_GOT_DTPREL16
 #undef R_PPC_GOT_DTPREL16_LO
 #undef R_PPC_GOT_DTPREL16_HI
 #undef R_PPC_GOT_DTPREL16_HA
 #undef R_PPC_TLSGD
 #undef R_PPC_TLSLD
+#undef R_PPC_EMB_NADDR32
+#undef R_PPC_EMB_NADDR16
+#undef R_PPC_EMB_NADDR16_LO
+#undef R_PPC_EMB_NADDR16_HI
+#undef R_PPC_EMB_NADDR16_HA
+#undef R_PPC_EMB_SDAI16
+#undef R_PPC_EMB_SDA2I16
+#undef R_PPC_EMB_SDA2REL
+#undef R_PPC_EMB_SDA21
+#undef R_PPC_EMB_MRKREF
+#undef R_PPC_EMB_RELSEC16
+#undef R_PPC_EMB_RELST_LO
+#undef R_PPC_EMB_RELST_HI
+#undef R_PPC_EMB_RELST_HA
+#undef R_PPC_EMB_BIT_FLD
+#undef R_PPC_EMB_RELSDA
 #undef R_PPC_REL16
 #undef R_PPC_REL16_LO
 #undef R_PPC_REL16_HI
 #undef R_PPC_REL16_HA
 
 ELF_RELOC(R_PPC_NONE,                   0)      /* No relocation. */
 ELF_RELOC(R_PPC_ADDR32,                 1)
 ELF_RELOC(R_PPC_ADDR24,                 2)

 ELF_RELOC(R_PPC_GOT_TPREL16_HI,         89)
 ELF_RELOC(R_PPC_GOT_TPREL16_HA,         90)
 ELF_RELOC(R_PPC_GOT_DTPREL16,           91)
 ELF_RELOC(R_PPC_GOT_DTPREL16_LO,        92)
 ELF_RELOC(R_PPC_GOT_DTPREL16_HI,        93)
 ELF_RELOC(R_PPC_GOT_DTPREL16_HA,        94)
 ELF_RELOC(R_PPC_TLSGD,                  95)
 ELF_RELOC(R_PPC_TLSLD,                  96)
+ELF_RELOC(R_PPC_EMB_NADDR32,            101)
+ELF_RELOC(R_PPC_EMB_NADDR16,            102)
+ELF_RELOC(R_PPC_EMB_NADDR16_LO,         103)
+ELF_RELOC(R_PPC_EMB_NADDR16_HI,         104)
+ELF_RELOC(R_PPC_EMB_NADDR16_HA,         105)
+ELF_RELOC(R_PPC_EMB_SDAI16,             106)
+ELF_RELOC(R_PPC_EMB_SDA2I16,            107)
+ELF_RELOC(R_PPC_EMB_SDA2REL,            108)
+ELF_RELOC(R_PPC_EMB_SDA21,              109)
+ELF_RELOC(R_PPC_EMB_MRKREF,             110)
+ELF_RELOC(R_PPC_EMB_RELSEC16,           111)
+ELF_RELOC(R_PPC_EMB_RELST_LO,           112)
+ELF_RELOC(R_PPC_EMB_RELST_HI,           113)
+ELF_RELOC(R_PPC_EMB_RELST_HA,           114)
+ELF_RELOC(R_PPC_EMB_BIT_FLD,            115)
+ELF_RELOC(R_PPC_EMB_RELSDA,             116)
 ELF_RELOC(R_PPC_REL16,                  249)
 ELF_RELOC(R_PPC_REL16_LO,               250)
 ELF_RELOC(R_PPC_REL16_HI,               251)
 ELF_RELOC(R_PPC_REL16_HA,               252)

include/llvm/Target/TargetLoweringObjectFile.h

virtual MCSection *getSectionForConstant(const DataLayout &DL,
                                            const Constant *C,
                                            unsigned &Align) const;
 
   /// Classify the specified global variable into a set of target independent
   /// categories embodied in SectionKind.
   static SectionKind getKindForGlobal(const GlobalObject *GO,
                                       const TargetMachine &TM);
 
+  /// Determine if constant is allocated in a subtarget small data
+  /// SectionKind.
+  static bool isConstantInSmallSection(const DataLayout &DL,
+                                       const Constant *C,
+                                       const TargetMachine &TM);
+
+  /// Determine if global variable is allocated in a subtarget small data
+  /// SectionKind.
+  static bool isGlobalInSmallSection(const GlobalObject *GO,
+                                     const TargetMachine &TM);
+
   /// This method computes the appropriate section to emit the specified global
   /// variable or function definition. This should not be passed external (or
   /// available externally) globals.
   MCSection *SectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                               const TargetMachine &TM) const;
 
   /// This method computes the appropriate section to emit the specified global
   /// variable or function definition. This should not be passed external (or
public:
 
   virtual void emitLinkerFlagsForGlobal(raw_ostream &OS,
                                         const GlobalValue *GV) const {}
 
 protected:
   virtual MCSection *SelectSectionForGlobal(const GlobalObject *GO,
                                             SectionKind Kind,
                                             const TargetMachine &TM) const = 0;
+  virtual bool isConstantInSmallSectionKind(const DataLayout &DL,
+                                            const Constant *C) const {
+    return false;
+  }
+  virtual bool isGlobalInSmallSectionKind(const GlobalObject *GO,
+                                          const TargetMachine &TM) const {
+    return false;
+  }
 };
 
 } // end namespace llvm
 
 #endif

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

void AsmPrinter::EmitConstantPool() {
 
   // Calculate sections for constant pool entries. We collect entries to go into
   // the same section together to reduce amount of section switch statements.
   SmallVector<SectionCPs, 4> CPSections;
   for (unsigned i = 0, e = CP.size(); i != e; ++i) {
     const MachineConstantPoolEntry &CPE = CP[i];
     unsigned Align = CPE.getAlignment();
 
-    SectionKind Kind = CPE.getSectionKind(&getDataLayout());
+    SectionKind Kind = CPE.getSectionKind(&getDataLayout(), TM);
 
     const Constant *C = nullptr;
     if (!CPE.isMachineConstantPoolEntry())
       C = CPE.Val.ConstVal;
 
     MCSection *S = getObjFileLowering().getSectionForConstant(getDataLayout(),
                                                               Kind, C, Align);
 

lib/CodeGen/MachineFunction.cpp

 #include "llvm/IR/ModuleSlotTracker.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetFrameLowering.h"
 #include "llvm/Target/TargetLowering.h"
+#include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "codegen"
 
 static cl::opt<unsigned>
     AlignAllFunctions("align-all-functions",

 
 bool MachineConstantPoolEntry::needsRelocation() const {
   if (isMachineConstantPoolEntry())
     return true;
   return Val.ConstVal->needsRelocation();
 }
 
 SectionKind
-MachineConstantPoolEntry::getSectionKind(const DataLayout *DL) const {
+MachineConstantPoolEntry::getSectionKind(const DataLayout *DL,
+                                         const TargetMachine &TM) const {
   if (needsRelocation())
     return SectionKind::getReadOnlyWithRel();
+
+  if (!isMachineConstantPoolEntry() &&
+      TargetLoweringObjectFile::isConstantInSmallSection(*DL, Val.ConstVal, TM))
+      return SectionKind::getSmallReadOnly();
+
   switch (DL->getTypeAllocSize(getType())) {
   case 4:
     return SectionKind::getMergeableConst4();
   case 8:
     return SectionKind::getMergeableConst8();
   case 16:
     return SectionKind::getMergeableConst16();
   case 32:

lib/MC/ELFObjectWriter.cpp

bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
   // symbol is not relevant, we cannot replace the symbol with the
   // section and patch the difference in the addend.
   case MCSymbolRefExpr::VK_GOT:
   case MCSymbolRefExpr::VK_PLT:
   case MCSymbolRefExpr::VK_GOTPCREL:
   case MCSymbolRefExpr::VK_PPC_GOT_LO:
   case MCSymbolRefExpr::VK_PPC_GOT_HI:
   case MCSymbolRefExpr::VK_PPC_GOT_HA:
+  case MCSymbolRefExpr::VK_PPC_SDA:
     return true;
   }
 
   // An undefined symbol is not in any section, so the relocation has to point
   // to the symbol itself.
   assert(Sym && "Expected a symbol");
   if (Sym->isUndefined())
     return true;

lib/MC/MCExpr.cpp

StringRef MCSymbolRefExpr::getVariantKindName(VariantKind Kind) {
   case VK_PPC_GOT_TLSGD_HA: return "got@tlsgd@ha";
   case VK_PPC_TLSGD: return "tlsgd";
   case VK_PPC_GOT_TLSLD: return "got@tlsld";
   case VK_PPC_GOT_TLSLD_LO: return "got@tlsld@l";
   case VK_PPC_GOT_TLSLD_HI: return "got@tlsld@h";
   case VK_PPC_GOT_TLSLD_HA: return "got@tlsld@ha";
   case VK_PPC_TLSLD: return "tlsld";
   case VK_PPC_LOCAL: return "local";
+  case VK_PPC_SDA: return "sda21";
   case VK_COFF_IMGREL32: return "IMGREL";
   case VK_Hexagon_PCREL: return "PCREL";
   case VK_Hexagon_LO16: return "LO16";
   case VK_Hexagon_HI16: return "HI16";
   case VK_Hexagon_GPREL: return "GPREL";
   case VK_Hexagon_GD_GOT: return "GDGOT";
   case VK_Hexagon_LD_GOT: return "LDGOT";
   case VK_Hexagon_GD_PLT: return "GDPLT";
return StringSwitch<VariantKind>(Name.lower())
     .Case("higher", VK_PPC_HIGHER)
     .Case("highera", VK_PPC_HIGHERA)
     .Case("highest", VK_PPC_HIGHEST)
     .Case("highesta", VK_PPC_HIGHESTA)
     .Case("got@l", VK_PPC_GOT_LO)
     .Case("got@h", VK_PPC_GOT_HI)
     .Case("got@ha", VK_PPC_GOT_HA)
     .Case("local", VK_PPC_LOCAL)
+    .Case("sda21", VK_PPC_SDA)
     .Case("tocbase", VK_PPC_TOCBASE)
     .Case("toc", VK_PPC_TOC)
     .Case("toc@l", VK_PPC_TOC_LO)
     .Case("toc@h", VK_PPC_TOC_HI)
     .Case("toc@ha", VK_PPC_TOC_HA)
     .Case("tls", VK_PPC_TLS)
     .Case("dtpmod", VK_PPC_DTPMOD)
     .Case("tprel@l", VK_PPC_TPREL_LO)

lib/Target/Hexagon/HexagonISelLowering.cpp

HexagonTargetLowering::LowerGLOBALADDRESS(SDValue Op, SelectionDAG &DAG) const {
   int64_t Offset = GAN->getOffset();
 
   auto &HLOF = *HTM.getObjFileLowering();
   Reloc::Model RM = HTM.getRelocationModel();
 
   if (RM == Reloc::Static) {
     SDValue GA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, Offset);
     const GlobalObject *GO = GV->getBaseObject();
-    if (GO && HLOF.isGlobalInSmallSection(GO, HTM))
+    if (GO && HLOF.isGlobalInSmallSectionKind(GO, HTM))
       return DAG.getNode(HexagonISD::CONST32_GP, dl, PtrVT, GA);
     return DAG.getNode(HexagonISD::CONST32, dl, PtrVT, GA);
   }
 
   bool UsePCRel = getTargetMachine().shouldAssumeDSOLocal(*GV->getParent(), GV);
   if (UsePCRel) {
     SDValue GA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, Offset,
                                             HexagonII::MO_PCREL);

lib/Target/Hexagon/HexagonTargetObjectFile.h

public:
 
     MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override;
 
     MCSection *getExplicitSectionGlobal(const GlobalObject *GO,
                                         SectionKind Kind,
                                         const TargetMachine &TM) const override;
 
-    bool isGlobalInSmallSection(const GlobalObject *GO,
-                                const TargetMachine &TM) const;
+    bool isGlobalInSmallSectionKind(const GlobalObject *GO,
+                                    const TargetMachine &TM) const override;
 
     bool isSmallDataEnabled() const;
 
     unsigned getSmallDataSize() const;
 
   private:
     MCSectionELF *SmallDataSection;
     MCSectionELF *SmallBSSSection;

lib/Target/Hexagon/HexagonTargetObjectFile.cpp

TRACE((GO->hasPrivateLinkage() ? "private_linkage " : "")
          << (GO->hasInternalLinkage() ? "internal " : "")
          << (GO->hasExternalLinkage() ? "external " : "")
          << (GO->hasCommonLinkage() ? "common_linkage " : "")
          << (GO->hasCommonLinkage() ? "common " : "" )
          << (Kind.isCommon() ? "kind_common " : "" )
          << (Kind.isBSS() ? "kind_bss " : "" )
          << (Kind.isBSSLocal() ? "kind_bss_local " : "" ));
 
-  if (isGlobalInSmallSection(GO, TM))
+  if (Kind.isSmallKind())
     return selectSmallSectionForGlobal(GO, Kind, TM);
 
   if (Kind.isCommon()) {
     // This is purely for LTO+Linker Script because commons don't really have a
     // section. However, the BitcodeSectionWriter pass will query for the
     // sections of commons (and the linker expects us to know their section) so
     // we'll return one here.
     return BSSSection;
if (GO->hasSection()) {
     if (Section.find(".access.text.group") != StringRef::npos)
       return getContext().getELFSection(GO->getSection(), ELF::SHT_PROGBITS,
                                         ELF::SHF_ALLOC | ELF::SHF_EXECINSTR);
     if (Section.find(".access.data.group") != StringRef::npos)
       return getContext().getELFSection(GO->getSection(), ELF::SHT_PROGBITS,
                                         ELF::SHF_WRITE | ELF::SHF_ALLOC);
   }
 
-  if (isGlobalInSmallSection(GO, TM))
+  if (Kind.isSmallKind())
     return selectSmallSectionForGlobal(GO, Kind, TM);
 
   // Otherwise, we work the same as ELF.
   TRACE("default_ELF_section\n");
   return TargetLoweringObjectFileELF::getExplicitSectionGlobal(GO, Kind, TM);
 }
 
 
 /// Return true if this global value should be placed into small data/bss
 /// section.
-bool HexagonTargetObjectFile::isGlobalInSmallSection(const GlobalObject *GO,
+bool HexagonTargetObjectFile::isGlobalInSmallSectionKind(const GlobalObject *GO,
       const TargetMachine &TM) const {
   // Only global variables, not functions.
   DEBUG(dbgs() << "Checking if value is in small-data, -G"
                << SmallDataThreshold << ": \"" << GO->getName() << "\": ");
   const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GO);
   if (!GVar) {
     DEBUG(dbgs() << "no, not a global variable\n");
     return false;

lib/Target/Lanai/LanaiISelLowering.cpp

const char *LanaiTargetLowering::getTargetNodeName(unsigned Opcode) const {
   }
 }
 
 SDValue LanaiTargetLowering::LowerConstantPool(SDValue Op,
                                                SelectionDAG &DAG) const {
   SDLoc DL(Op);
   ConstantPoolSDNode *N = cast<ConstantPoolSDNode>(Op);
   const Constant *C = N->getConstVal();
-  const LanaiTargetObjectFile *TLOF =
-      static_cast<const LanaiTargetObjectFile *>(
-          getTargetMachine().getObjFileLowering());
 
   // If the code model is small or constant will be placed in the small section,
   // then assume address will fit in 21-bits.
   if (getTargetMachine().getCodeModel() == CodeModel::Small ||
-      TLOF->isConstantInSmallSection(DAG.getDataLayout(), C)) {
+      TargetLoweringObjectFile::isConstantInSmallSection(
+        DAG.getDataLayout(), C, getTargetMachine())) {
     SDValue Small = DAG.getTargetConstantPool(
         C, MVT::i32, N->getAlignment(), N->getOffset(), LanaiII::MO_NO_FLAG);
     return DAG.getNode(ISD::OR, DL, MVT::i32,
                        DAG.getRegister(Lanai::R0, MVT::i32),
                        DAG.getNode(LanaiISD::SMALL, DL, MVT::i32, Small));
   } else {
     uint8_t OpFlagHi = LanaiII::MO_ABS_HI;
     uint8_t OpFlagLo = LanaiII::MO_ABS_LO;

 }
 
 SDValue LanaiTargetLowering::LowerGlobalAddress(SDValue Op,
                                                 SelectionDAG &DAG) const {
   SDLoc DL(Op);
   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
   int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
 
-  const LanaiTargetObjectFile *TLOF =
-      static_cast<const LanaiTargetObjectFile *>(
-          getTargetMachine().getObjFileLowering());
-
   // If the code model is small or global variable will be placed in the small
   // section, then assume address will fit in 21-bits.
   const GlobalObject *GO = GV->getBaseObject();
   if (getTargetMachine().getCodeModel() == CodeModel::Small ||
-      (GO && TLOF->isGlobalInSmallSection(GO, getTargetMachine()))) {
+      (GO && TargetLoweringObjectFile::isGlobalInSmallSection(
+             GO, getTargetMachine()))) {
     SDValue Small = DAG.getTargetGlobalAddress(
         GV, DL, getPointerTy(DAG.getDataLayout()), Offset, LanaiII::MO_NO_FLAG);
     return DAG.getNode(ISD::OR, DL, MVT::i32,
                        DAG.getRegister(Lanai::R0, MVT::i32),
                        DAG.getNode(LanaiISD::SMALL, DL, MVT::i32, Small));
   } else {
     uint8_t OpFlagHi = LanaiII::MO_ABS_HI;
     uint8_t OpFlagLo = LanaiII::MO_ABS_LO;

lib/Target/Lanai/LanaiTargetObjectFile.h

 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
 
 namespace llvm {
 class LanaiTargetMachine;
 class LanaiTargetObjectFile : public TargetLoweringObjectFileELF {
   MCSection *SmallDataSection;
   MCSection *SmallBSSSection;
 
-  bool isGlobalInSmallSection(const GlobalObject *GO, const TargetMachine &TM,
-                              SectionKind Kind) const;
-  bool isGlobalInSmallSectionImpl(const GlobalObject *GO,
-                                  const TargetMachine &TM) const;
+  /// Return true if this constant should be placed into small data section.
+  bool isConstantInSmallSectionKind(const DataLayout &DL,
+                                    const Constant *CN) const override;
+
+  /// Return true if this global should be placed into small data section.
+  bool isGlobalInSmallSectionKind(const GlobalObject *GO,
+                                  const TargetMachine &TM) const override;
 
 public:
   void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
 
-  /// Return true if this global address should be placed into small data/bss
-  /// section.
-  bool isGlobalInSmallSection(const GlobalObject *GO,
-                              const TargetMachine &TM) const;
-
   MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                     const TargetMachine &TM) const override;
 
-  /// Return true if this constant should be placed into small data section.
-  bool isConstantInSmallSection(const DataLayout &DL, const Constant *CN) const;
-
   MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
                                    const Constant *C,
                                    unsigned &Align) const override;
 };
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_LANAI_LANAITARGETOBJECTFILE_H

lib/Target/Lanai/LanaiTargetObjectFile.cpp

 // gp_rel operator.
 static bool isInSmallSection(uint64_t Size) {
   // gcc has traditionally not treated zero-sized objects as small data, so this
   // is effectively part of the ABI.
   return Size > 0 && Size <= SSThreshold;
 }
 
 // Return true if this global address should be placed into small data/bss
-// section.
-bool LanaiTargetObjectFile::isGlobalInSmallSection(
-    const GlobalObject *GO, const TargetMachine &TM) const {
-  // We first check the case where global is a declaration, because finding
-  // section kind using getKindForGlobal() is only allowed for global
-  // definitions.
-  if (GO->isDeclaration() || GO->hasAvailableExternallyLinkage())
-    return isGlobalInSmallSectionImpl(GO, TM);
-
-  return isGlobalInSmallSection(GO, TM, getKindForGlobal(GO, TM));
-}
-
-// Return true if this global address should be placed into small data/bss
-// section.
-bool LanaiTargetObjectFile::isGlobalInSmallSection(const GlobalObject *GO,
-                                                   const TargetMachine &TM,
-                                                   SectionKind Kind) const {
-  return (isGlobalInSmallSectionImpl(GO, TM) &&
-          (Kind.isData() || Kind.isBSS() || Kind.isCommon()));
-}
-
-// Return true if this global address should be placed into small data/bss
-// section. This method does all the work, except for checking the section
+// section. This method does all the work, directly influencing section
 // kind.
-bool LanaiTargetObjectFile::isGlobalInSmallSectionImpl(
+bool LanaiTargetObjectFile::isGlobalInSmallSectionKind(
     const GlobalObject *GO, const TargetMachine & /*TM*/) const {
   // Only global variables, not functions.
   const auto *GVA = dyn_cast<GlobalVariable>(GO);
   if (!GVA)
     return false;
 
   if (GVA->hasLocalLinkage())
     return false;
 
   if (((GVA->hasExternalLinkage() && GVA->isDeclaration()) ||
        GVA->hasCommonLinkage()))
     return false;
 
   Type *Ty = GVA->getValueType();
   return isInSmallSection(
       GVA->getParent()->getDataLayout().getTypeAllocSize(Ty));
 }
 
 MCSection *LanaiTargetObjectFile::SelectSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
   // Handle Small Section classification here.
-  if (Kind.isBSS() && isGlobalInSmallSection(GO, TM, Kind))
+  if (Kind.isSmallBSS())
     return SmallBSSSection;
-  if (Kind.isData() && isGlobalInSmallSection(GO, TM, Kind))
+  if (Kind.isSmallData())
     return SmallDataSection;
 
   // Otherwise, we work the same as ELF.
   return TargetLoweringObjectFileELF::SelectSectionForGlobal(GO, Kind, TM);
 }
 
 /// Return true if this constant should be placed into small data section.
-bool LanaiTargetObjectFile::isConstantInSmallSection(const DataLayout &DL,
+bool LanaiTargetObjectFile::isConstantInSmallSectionKind(const DataLayout &DL,
                                                          const Constant *CN) const {
   return isInSmallSection(DL.getTypeAllocSize(CN->getType()));
 }
 
 MCSection *LanaiTargetObjectFile::getSectionForConstant(const DataLayout &DL,
                                                         SectionKind Kind,
                                                         const Constant *C,
                                                         unsigned &Align) const {
-  if (isConstantInSmallSection(DL, C))
+  if (Kind.isSmallReadOnly())
     return SmallDataSection;
 
   // Otherwise, we work the same as ELF.
   return TargetLoweringObjectFileELF::getSectionForConstant(DL, Kind, C, Align);
 }

lib/Target/Mips/MipsISelLowering.cpp

 
 SDValue MipsTargetLowering::lowerGlobalAddress(SDValue Op,
                                                SelectionDAG &DAG) const {
   EVT Ty = Op.getValueType();
   GlobalAddressSDNode *N = cast<GlobalAddressSDNode>(Op);
   const GlobalValue *GV = N->getGlobal();
 
   if (!isPositionIndependent() && !ABI.IsN64()) {
-    const MipsTargetObjectFile *TLOF =
-        static_cast<const MipsTargetObjectFile *>(
-            getTargetMachine().getObjFileLowering());
     const GlobalObject *GO = GV->getBaseObject();
-    if (GO && TLOF->IsGlobalInSmallSection(GO, getTargetMachine()))
+    if (GO && TargetLoweringObjectFile::isGlobalInSmallSection(
+              GO, getTargetMachine()))
       // %gp_rel relocation
       return getAddrGPRel(N, SDLoc(N), Ty, DAG);
 
     // %hi/%lo relocation
     return getAddrNonPIC(N, SDLoc(N), Ty, DAG);
   }
 
   // Every other architecture would use shouldAssumeDSOLocal in here, but

 
 SDValue MipsTargetLowering::
 lowerConstantPool(SDValue Op, SelectionDAG &DAG) const
 {
   ConstantPoolSDNode *N = cast<ConstantPoolSDNode>(Op);
   EVT Ty = Op.getValueType();
 
   if (!isPositionIndependent() && !ABI.IsN64()) {
-    const MipsTargetObjectFile *TLOF =
-        static_cast<const MipsTargetObjectFile *>(
-            getTargetMachine().getObjFileLowering());
-
-    if (TLOF->IsConstantInSmallSection(DAG.getDataLayout(), N->getConstVal(),
-                                       getTargetMachine()))
+    if (TargetLoweringObjectFile::isConstantInSmallSection(
+          DAG.getDataLayout(), N->getConstVal(), getTargetMachine()))
       // %gp_rel relocation
       return getAddrGPRel(N, SDLoc(N), Ty, DAG);
 
     return getAddrNonPIC(N, SDLoc(N), Ty, DAG);
   }
 
   return getAddrLocal(N, SDLoc(N), Ty, DAG, ABI.IsN32() || ABI.IsN64());
 }

lib/Target/Mips/MipsTargetObjectFile.h

 
 namespace llvm {
 class MipsTargetMachine;
   class MipsTargetObjectFile : public TargetLoweringObjectFileELF {
     MCSection *SmallDataSection;
     MCSection *SmallBSSSection;
     const MipsTargetMachine *TM;
 
-    bool IsGlobalInSmallSection(const GlobalObject *GO, const TargetMachine &TM,
-                                SectionKind Kind) const;
-    bool IsGlobalInSmallSectionImpl(const GlobalObject *GO,
-                                    const TargetMachine &TM) const;
+    /// Return true if this constant should be placed into small data section.
+    bool isConstantInSmallSectionKind(const DataLayout &DL,
+                                      const Constant *CN) const override;
+
+    /// Return true if this global should be placed into small data section.
+    bool isGlobalInSmallSectionKind(const GlobalObject *GO,
+                                    const TargetMachine &TM) const override;
   public:
 
     void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
 
-    /// Return true if this global address should be placed into small data/bss
-    /// section.
-    bool IsGlobalInSmallSection(const GlobalObject *GO,
-                                const TargetMachine &TM) const;
-
     MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override;
 
-    /// Return true if this constant should be placed into small data section.
-    bool IsConstantInSmallSection(const DataLayout &DL, const Constant *CN,
-                                  const TargetMachine &TM) const;
-
     MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
                                      const Constant *C,
                                      unsigned &Align) const override;
   };
 } // end namespace llvm
 
 #endif

lib/Target/Mips/MipsTargetObjectFile.cpp

 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Target/TargetMachine.h"
 using namespace llvm;
 
 static cl::opt<unsigned>
 SSThreshold("mips-ssection-threshold", cl::Hidden,
-            cl::desc("Small data and bss section threshold size (default=8)"),
+            cl::desc("MIPS: Small data and bss section threshold size (default=8)"),
             cl::init(8));
 
 static cl::opt<bool>
 LocalSData("mlocal-sdata", cl::Hidden,
            cl::desc("MIPS: Use gp_rel for object-local data."),
            cl::init(true));
 
 static cl::opt<bool>

 // gp_rel operator.
 static bool IsInSmallSection(uint64_t Size) {
   // gcc has traditionally not treated zero-sized objects as small data, so this
   // is effectively part of the ABI.
   return Size > 0 && Size <= SSThreshold;
 }
 
 /// Return true if this global address should be placed into small data/bss
-/// section.
-bool MipsTargetObjectFile::IsGlobalInSmallSection(
-    const GlobalObject *GO, const TargetMachine &TM) const {
-  // We first check the case where global is a declaration, because finding
-  // section kind using getKindForGlobal() is only allowed for global
-  // definitions.
-  if (GO->isDeclaration() || GO->hasAvailableExternallyLinkage())
-    return IsGlobalInSmallSectionImpl(GO, TM);
-
-  return IsGlobalInSmallSection(GO, TM, getKindForGlobal(GO, TM));
-}
-
-/// Return true if this global address should be placed into small data/bss
-/// section.
-bool MipsTargetObjectFile::
-IsGlobalInSmallSection(const GlobalObject *GO, const TargetMachine &TM,
-                       SectionKind Kind) const {
-  return (IsGlobalInSmallSectionImpl(GO, TM) &&
-          (Kind.isData() || Kind.isBSS() || Kind.isCommon()));
-}
-
-/// Return true if this global address should be placed into small data/bss
-/// section. This method does all the work, except for checking the section
+/// section. This method does all the work, directly influencing section
 /// kind.
 bool MipsTargetObjectFile::
-IsGlobalInSmallSectionImpl(const GlobalObject *GO,
+isGlobalInSmallSectionKind(const GlobalObject *GO,
                            const TargetMachine &TM) const {
   const MipsSubtarget &Subtarget =
       *static_cast<const MipsTargetMachine &>(TM).getSubtargetImpl();
 
   // Return if small section is not available.
   if (!Subtarget.useSmallSection())
     return false;
 

 }
 
 MCSection *MipsTargetObjectFile::SelectSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
   // TODO: Could also support "weak" symbols as well with ".gnu.linkonce.s.*"
   // sections?
 
   // Handle Small Section classification here.
-  if (Kind.isBSS() && IsGlobalInSmallSection(GO, TM, Kind))
+  if (Kind.isSmallBSS())
     return SmallBSSSection;
-  if (Kind.isData() && IsGlobalInSmallSection(GO, TM, Kind))
+  if (Kind.isSmallData())
     return SmallDataSection;
 
   // Otherwise, we work the same as ELF.
   return TargetLoweringObjectFileELF::SelectSectionForGlobal(GO, Kind, TM);
 }
 
 /// Return true if this constant should be placed into small data section.
-bool MipsTargetObjectFile::IsConstantInSmallSection(
-    const DataLayout &DL, const Constant *CN, const TargetMachine &TM) const {
-  return (static_cast<const MipsTargetMachine &>(TM)
+bool MipsTargetObjectFile::isConstantInSmallSectionKind(
+    const DataLayout &DL, const Constant *CN) const {
+  return (static_cast<const MipsTargetMachine &>(*TM)
               .getSubtargetImpl()
               ->useSmallSection() &&
           LocalSData && IsInSmallSection(DL.getTypeAllocSize(CN->getType())));
 }
 
 /// Return true if this constant should be placed into small data section.
 MCSection *MipsTargetObjectFile::getSectionForConstant(const DataLayout &DL,
                                                        SectionKind Kind,
                                                        const Constant *C,
                                                        unsigned &Align) const {
-  if (IsConstantInSmallSection(DL, C, *TM))
+  if (Kind.isSmallReadOnly())
     return SmallDataSection;
 
   // Otherwise, we work the same as ELF.
   return TargetLoweringObjectFileELF::getSectionForConstant(DL, Kind, C, Align);
 }

lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp

 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCParser/MCAsmLexer.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbolELF.h"
+#include "llvm/Support/ELF.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 static const MCPhysReg RRegs[32] = {
   PPC::R0,  PPC::R1,  PPC::R2,  PPC::R3,
class PPCAsmParser : public MCTargetAsmParser {
   bool ParseOperand(OperandVector &Operands);
 
   bool ParseDirectiveWord(unsigned Size, SMLoc L);
   bool ParseDirectiveTC(unsigned Size, SMLoc L);
   bool ParseDirectiveMachine(SMLoc L);
   bool ParseDarwinDirectiveMachine(SMLoc L);
   bool ParseDirectiveAbiVersion(SMLoc L);
   bool ParseDirectiveLocalEntry(SMLoc L);
+  bool ParseElfSSectionDirective(SMLoc L, StringRef Section,
+                                 unsigned Type, unsigned Flags);
 
   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
                                OperandVector &Operands, MCStreamer &Out,
                                uint64_t &ErrorInfo,
                                bool MatchingInlineAsm) override;
 
   void ProcessInstruction(MCInst &Inst, const OperandVector &Ops);
 
if (!isDarwin()) {
     if (IDVal == ".tc")
       return ParseDirectiveTC(isPPC64()? 8 : 4, DirectiveID.getLoc());
     if (IDVal == ".machine")
       return ParseDirectiveMachine(DirectiveID.getLoc());
     if (IDVal == ".abiversion")
       return ParseDirectiveAbiVersion(DirectiveID.getLoc());
     if (IDVal == ".localentry")
       return ParseDirectiveLocalEntry(DirectiveID.getLoc());
+    if (IDVal == ".sdata")
+      return ParseElfSSectionDirective(DirectiveID.getLoc(), IDVal,
+                                       ELF::SHT_PROGBITS,
+                                       ELF::SHF_WRITE | ELF::SHF_ALLOC);
+    if (IDVal == ".sdata2")
+      return ParseElfSSectionDirective(DirectiveID.getLoc(), IDVal,
+                                       ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
+    if (IDVal == ".sbss")
+      return ParseElfSSectionDirective(DirectiveID.getLoc(), IDVal,
+                                       ELF::SHT_NOBITS,
+                                       ELF::SHF_WRITE | ELF::SHF_ALLOC);
   } else {
     if (IDVal == ".machine")
       return ParseDarwinDirectiveMachine(DirectiveID.getLoc());
   }
   return true;
 }
 
 /// ParseDirectiveWord
bool PPCAsmParser::ParseDirectiveLocalEntry(SMLoc L) {
   PPCTargetStreamer &TStreamer =
       *static_cast<PPCTargetStreamer *>(
            getParser().getStreamer().getTargetStreamer());
   TStreamer.emitLocalEntry(Sym, Expr);
 
   return false;
 }
 
+/// ParseElfSSectionDirective
+///  ::= .sbss
+///  ::= .sdata
+///  ::= .sdata2
+bool PPCAsmParser::ParseElfSSectionDirective(SMLoc L, StringRef Section,
+                                             unsigned Type, unsigned Flags) {
+  // If this is not the end of the statement, report an error.
+  if (getLexer().isNot(AsmToken::EndOfStatement)) {
+    Error(L, "unexpected token, expected end of statement");
+    return false;
+  }
+
+  MCSection *ELFSection = getContext().getELFSection(
+      Section, Type, Flags);
+  getParser().getStreamer().SwitchSection(ELFSection);
+
+  getParser().Lex(); // Eat EndOfStatement token.
+  return false;
+}
 
 
 /// Force static initialization.
 extern "C" void LLVMInitializePowerPCAsmParser() {
   RegisterMCAsmParser<PPCAsmParser> A(getThePPC32Target());
   RegisterMCAsmParser<PPCAsmParser> B(getThePPC64Target());
   RegisterMCAsmParser<PPCAsmParser> C(getThePPC64LETarget());
 }

lib/Target/PowerPC/MCTargetDesc/PPCAsmBackend.cpp

 
 MCAsmBackend *llvm::createPPCAsmBackend(const Target &T,
                                         const MCRegisterInfo &MRI,
                                         const Triple &TT, StringRef CPU,
                                         const MCTargetOptions &Options) {
   if (TT.isOSDarwin())
     return new DarwinPPCAsmBackend(T);
 
-  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TT.getOS());
+  uint8_t OSABI = TT.isEABI() ? ELF::ELFOSABI_STANDALONE :
+                  MCELFObjectTargetWriter::getOSABI(TT.getOS());
   bool IsLittleEndian = TT.getArch() == Triple::ppc64le;
   return new ELFPPCAsmBackend(T, IsLittleEndian, OSABI);
 }

lib/Target/PowerPC/MCTargetDesc/PPCELFObjectWriter.cpp

case PPC::fixup_ppc_half16:
         Type = ELF::R_PPC64_GOT_TPREL16_HA;
         break;
       case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HI:
         Type = ELF::R_PPC64_GOT_DTPREL16_HI;
         break;
       case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HA:
         Type = ELF::R_PPC64_GOT_DTPREL16_HA;
         break;
+      case MCSymbolRefExpr::VK_PPC_SDA:
+        Type = ELF::R_PPC_EMB_SDA21;
+        break;
       }
       break;
     case PPC::fixup_ppc_half16ds:
       switch (Modifier) {
       default: llvm_unreachable("Unsupported Modifier");
       case MCSymbolRefExpr::VK_None:
         Type = ELF::R_PPC64_ADDR16_DS;
         break;

lib/Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp

unsigned get_crbitm_encoding(const MCInst &MI, unsigned OpNo,
                                SmallVectorImpl<MCFixup> &Fixups,
                                const MCSubtargetInfo &STI) const;
 
   /// getMachineOpValue - Return binary encoding of operand. If the machine
   /// operand requires relocation, record the relocation and return zero.
   unsigned getMachineOpValue(const MCInst &MI,const MCOperand &MO,
                              SmallVectorImpl<MCFixup> &Fixups,
                              const MCSubtargetInfo &STI) const;
-  
   // getBinaryCodeForInstr - TableGen'erated function for getting the
   // binary encoding for an instruction.
   uint64_t getBinaryCodeForInstr(const MCInst &MI,
                                  SmallVectorImpl<MCFixup> &Fixups,
                                  const MCSubtargetInfo &STI) const;
   void encodeInstruction(const MCInst &MI, raw_ostream &OS,
                          SmallVectorImpl<MCFixup> &Fixups,
                          const MCSubtargetInfo &STI) const override {
case 8:
         support::endian::Writer<support::little>(OS).write<uint64_t>(Swapped);
       } else {
         support::endian::Writer<support::big>(OS).write<uint64_t>(Bits);
       }
       break;
     default:
       llvm_unreachable ("Invalid instruction size");
     }
-    
     ++MCNumEmitted;  // Keep track of the # of mi's emitted.
   }
 
 private:
   uint64_t computeAvailableFeatures(const FeatureBitset &FB) const;
   void verifyInstructionPredicates(const MCInst &MI,
                                    uint64_t AvailableFeatures) const;
 };
-  
 } // end anonymous namespace
 
 MCCodeEmitter *llvm::createPPCMCCodeEmitter(const MCInstrInfo &MCII,
                                             const MCRegisterInfo &MRI,
                                             MCContext &Ctx) {
   return new PPCMCCodeEmitter(MCII, Ctx);
 }
 
 unsigned PPCMCCodeEmitter::
 getDirectBrEncoding(const MCInst &MI, unsigned OpNo,
                     SmallVectorImpl<MCFixup> &Fixups,
                     const MCSubtargetInfo &STI) const {
   const MCOperand &MO = MI.getOperand(OpNo);
   if (MO.isReg() || MO.isImm()) return getMachineOpValue(MI, MO, Fixups, STI);
-  
   // Add a fixup for the branch target.
   Fixups.push_back(MCFixup::create(0, MO.getExpr(),
                                    (MCFixupKind)PPC::fixup_ppc_br24));
   return 0;
 }
 
 unsigned PPCMCCodeEmitter::getCondBrEncoding(const MCInst &MI, unsigned OpNo,
                                      SmallVectorImpl<MCFixup> &Fixups,
getAbsCondBrEncoding(const MCInst &MI, unsigned OpNo,
   return 0;
 }
 
 unsigned PPCMCCodeEmitter::getImm16Encoding(const MCInst &MI, unsigned OpNo,
                                        SmallVectorImpl<MCFixup> &Fixups,
                                        const MCSubtargetInfo &STI) const {
   const MCOperand &MO = MI.getOperand(OpNo);
   if (MO.isReg() || MO.isImm()) return getMachineOpValue(MI, MO, Fixups, STI);
-  
   // Add a fixup for the immediate field.
   Fixups.push_back(MCFixup::create(IsLittleEndian? 0 : 2, MO.getExpr(),
                                    (MCFixupKind)PPC::fixup_ppc_half16));
   return 0;
 }
 
 unsigned PPCMCCodeEmitter::getMemRIEncoding(const MCInst &MI, unsigned OpNo,
                                             SmallVectorImpl<MCFixup> &Fixups,
                                             const MCSubtargetInfo &STI) const {
   // Encode (imm, reg) as a memri, which has the low 16-bits as the
   // displacement and the next 5 bits as the register #.
   assert(MI.getOperand(OpNo+1).isReg());
   unsigned RegBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), Fixups, STI) << 16;
-  
   const MCOperand &MO = MI.getOperand(OpNo);
   if (MO.isImm())
     return (getMachineOpValue(MI, MO, Fixups, STI) & 0xFFFF) | RegBits;
-  
+  else if (MO.isExpr()) {
+    if (const MCSymbolRefExpr *Expr = dyn_cast<MCSymbolRefExpr>(MO.getExpr())) {
+      if (Expr->getKind() == MCSymbolRefExpr::VK_PPC_SDA) {
+        // Small data relocation must be one byte into instruction
+        Fixups.push_back(MCFixup::create(IsLittleEndian? 0 : 1, MO.getExpr(),
+                                         (MCFixupKind)PPC::fixup_ppc_half16));
+        return 0; // RegBits added by SDA21 relocation
+      }
+    }
+  }
   // Add a fixup for the displacement field.
   Fixups.push_back(MCFixup::create(IsLittleEndian? 0 : 2, MO.getExpr(),
                                    (MCFixupKind)PPC::fixup_ppc_half16));
   return RegBits;
 }
 
 
 unsigned PPCMCCodeEmitter::getMemRIXEncoding(const MCInst &MI, unsigned OpNo,
                                        SmallVectorImpl<MCFixup> &Fixups,
                                        const MCSubtargetInfo &STI) const {
   // Encode (imm, reg) as a memrix, which has the low 14-bits as the
   // displacement and the next 5 bits as the register #.
   assert(MI.getOperand(OpNo+1).isReg());
   unsigned RegBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), Fixups, STI) << 14;
-  
   const MCOperand &MO = MI.getOperand(OpNo);
   if (MO.isImm())
     return ((getMachineOpValue(MI, MO, Fixups, STI) >> 2) & 0x3FFF) | RegBits;
-  
   // Add a fixup for the displacement field.
   Fixups.push_back(MCFixup::create(IsLittleEndian? 0 : 2, MO.getExpr(),
                                    (MCFixupKind)PPC::fixup_ppc_half16ds));
   return RegBits;
 }
 
 unsigned PPCMCCodeEmitter::getMemRIX16Encoding(const MCInst &MI, unsigned OpNo,
                                        SmallVectorImpl<MCFixup> &Fixups,

 }
 
 
 unsigned PPCMCCodeEmitter::getTLSRegEncoding(const MCInst &MI, unsigned OpNo,
                                        SmallVectorImpl<MCFixup> &Fixups,
                                        const MCSubtargetInfo &STI) const {
   const MCOperand &MO = MI.getOperand(OpNo);
   if (MO.isReg()) return getMachineOpValue(MI, MO, Fixups, STI);
-  
   // Add a fixup for the TLS register, which simply provides a relocation
   // hint to the linker that this statement is part of a relocation sequence.
   // Return the thread-pointer register's encoding.
   Fixups.push_back(MCFixup::create(0, MO.getExpr(),
                                    (MCFixupKind)PPC::fixup_ppc_nofixup));
   const Triple &TT = STI.getTargetTriple();
   bool isPPC64 = TT.getArch() == Triple::ppc64 || TT.getArch() == Triple::ppc64le;
   return CTX.getRegisterInfo()->getEncodingValue(isPPC64 ? PPC::X13 : PPC::R2);
if (MO.isReg()) {
     unsigned Encode = CTX.getRegisterInfo()->getEncodingValue(Reg);
 
     if ((MCII.get(MI.getOpcode()).TSFlags & PPCII::UseVSXReg))
       if (PPCInstrInfo::isVRRegister(Reg))
         Encode += 32;
 
     return Encode;
   }
-  
   assert(MO.isImm() &&
          "Relocation required in an instruction that we cannot encode!");
   return MO.getImm();
 }
 
 
 
 #define ENABLE_INSTR_PREDICATE_VERIFIER
 #include "PPCGenMCCodeEmitter.inc"

lib/Target/PowerPC/PPC.h

#endif
   void LowerPPCMachineInstrToMCInst(const MachineInstr *MI, MCInst &OutMI,
                                     AsmPrinter &AP, bool isDarwin);
 
   void initializePPCVSXFMAMutatePass(PassRegistry&);
   void initializePPCBoolRetToIntPass(PassRegistry&);
   extern char &PPCVSXFMAMutateID;
 
   namespace PPCII {
-    
   /// Target Operand Flag enum.
   enum TOF {
     //===------------------------------------------------------------------===//
     // PPC Specific MachineOperand flags.
     MO_NO_FLAG,
 
     /// On a symbol operand "FOO", this indicates that the reference is actually
     /// to "FOO@plt".  This is used for calls and jumps to external functions on
enum TOF {
     MO_TPREL_LO = 4 << 4,
     MO_TPREL_HA = 3 << 4,
 
     /// These values identify relocations on immediates folded
     /// into memory operations.
     MO_DTPREL_LO = 5 << 4,
     MO_TLSLD_LO = 6 << 4,
     MO_TOC_LO = 7 << 4,
+    MO_SDA_LO = 9 << 4,
 
     // Symbol for VK_PPC_TLS fixup attached to an ADD instruction
     MO_TLS = 8 << 4
   };
   } // end namespace PPCII
-  
 } // end namespace llvm;
 
 #endif

lib/Target/PowerPC/PPCISelLowering.cpp

if (isIntS16Immediate(N.getOperand(1), imm) &&
       assert(!cast<ConstantSDNode>(N.getOperand(1).getOperand(1))->getZExtValue()
              && "Cannot handle constant offsets yet!");
       Disp = N.getOperand(1).getOperand(0);  // The global address.
       assert(Disp.getOpcode() == ISD::TargetGlobalAddress ||
              Disp.getOpcode() == ISD::TargetGlobalTLSAddress ||
              Disp.getOpcode() == ISD::TargetConstantPool ||
              Disp.getOpcode() == ISD::TargetJumpTable);
       Base = N.getOperand(0);
+
+      // Apply EABI small data relocation if eligible
+      if (getTargetMachine().getTargetTriple().isEABI()) {
+        if (GlobalAddressSDNode *GSDN =
+            dyn_cast<GlobalAddressSDNode>(Disp.getNode())) {
+          const GlobalValue *GV = GSDN->getGlobal();
+          if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {
+            if (TargetLoweringObjectFile::isGlobalInSmallSection(
+                GVar, getTargetMachine())) {
+              // This register selection is only relevant for ASM printing.
+              // MO_SDA_LO will ensure encoded register is R0, and the linker
+              // selects the actual base register during relocation.
+              Base = DAG.getRegister(GVar->isConstant() ? PPC::R2 : PPC::R13,
+                                     MVT::i32);
+              Disp = DAG.getTargetGlobalAddress(GV, SDLoc(GSDN),
+                                                Disp.getValueType(),
+                                                GSDN->getOffset(),
+                                                PPCII::MO_SDA_LO);
+            }
+          }
+        } else if (ConstantPoolSDNode *CSDN =
+                   dyn_cast<ConstantPoolSDNode>(Disp.getNode())) {
+          const Constant *C = CSDN->getConstVal();
+          if (TargetLoweringObjectFile::isConstantInSmallSection(
+              DAG.getDataLayout(), C, getTargetMachine())) {
+            // This register selection is only relevant for ASM printing.
+            // MO_SDA_LO will ensure encoded register is R0, and the linker
+            // selects the actual base register during relocation.
+            Base = DAG.getRegister(PPC::R2, MVT::i32);
+            Disp = DAG.getTargetConstantPool(C,
+                                             Disp.getValueType(),
+                                             CSDN->getAlignment(),
+                                             CSDN->getOffset(),
+                                             PPCII::MO_SDA_LO);
+          }
+        }
+      }
+
       return true;  // [&g+r]
     }
   } else if (N.getOpcode() == ISD::OR) {
     short imm = 0;
     if (isIntS16Immediate(N.getOperand(1), imm) &&
         (!Aligned || (imm & 3) == 0)) {
       // If this is an or of disjoint bitfields, we can codegen this as an add
       // (for better address arithmetic) if the LHS and RHS of the OR are

lib/Target/PowerPC/PPCMCInstLower.cpp

if (MO.getTargetFlags() & PPCII::MO_NLP_FLAG) {
     if (!StubSym.getPointer()) {
       assert(MO.isGlobal() && "Extern symbol not handled yet");
       StubSym = MachineModuleInfoImpl::
                    StubValueTy(AP.getSymbol(MO.getGlobal()),
                                !MO.getGlobal()->hasInternalLinkage());
     }
     return Sym;
   }
-  
   return Sym;
 }
 
 static MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol,
                               AsmPrinter &Printer, bool isDarwin) {
   MCContext &Ctx = Printer.OutContext;
   MCSymbolRefExpr::VariantKind RefKind = MCSymbolRefExpr::VK_None;
 
case PPCII::MO_TLSLD_LO:
       RefKind = MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO;
       break;
     case PPCII::MO_TOC_LO:
       RefKind = MCSymbolRefExpr::VK_PPC_TOC_LO;
       break;
     case PPCII::MO_TLS:
       RefKind = MCSymbolRefExpr::VK_PPC_TLS;
       break;
+    case PPCII::MO_SDA_LO:
+      RefKind = MCSymbolRefExpr::VK_PPC_SDA;
+      break;
   }
 
   if (MO.getTargetFlags() == PPCII::MO_PLT)
     RefKind = MCSymbolRefExpr::VK_PLT;
 
   const MCExpr *Expr = MCSymbolRefExpr::create(Symbol, RefKind, Ctx);
 
   if (!MO.isJTI() && MO.getOffset())
     Expr = MCBinaryExpr::createAdd(Expr,
                                    MCConstantExpr::create(MO.getOffset(), Ctx),
                                    Ctx);
 
   // Subtract off the PIC base if required.
   if (MO.getTargetFlags() & PPCII::MO_PIC_FLAG) {
     const MachineFunction *MF = MO.getParent()->getParent()->getParent();
-    
     const MCExpr *PB = MCSymbolRefExpr::create(MF->getPICBaseSymbol(), Ctx);
     Expr = MCBinaryExpr::createSub(Expr, PB, Ctx);
   }
 
   // Add ha16() / lo16() markers if required.
   switch (access) {
     case PPCII::MO_LO:
       Expr = PPCMCExpr::createLo(Expr, isDarwin, Ctx);
       break;
     case PPCII::MO_HA:
       Expr = PPCMCExpr::createHa(Expr, isDarwin, Ctx);
       break;
   }
 
   return MCOperand::createExpr(Expr);
 }
 
 void llvm::LowerPPCMachineInstrToMCInst(const MachineInstr *MI, MCInst &OutMI,
                                         AsmPrinter &AP, bool isDarwin) {
   OutMI.setOpcode(MI->getOpcode());
-  
   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
     const MachineOperand &MO = MI->getOperand(i);
-    
     MCOperand MCOp;
     switch (MO.getType()) {
     default:
       MI->dump();
       llvm_unreachable("unknown operand type");
     case MachineOperand::MO_Register:
       assert(!MO.getSubReg() && "Subregs should be eliminated!");
       assert(MO.getReg() > PPC::NoRegister &&
case MachineOperand::MO_ConstantPoolIndex:
       break;
     case MachineOperand::MO_BlockAddress:
       MCOp = GetSymbolRef(MO,AP.GetBlockAddressSymbol(MO.getBlockAddress()),AP,
                           isDarwin);
       break;
     case MachineOperand::MO_RegisterMask:
       continue;
     }
-    
     OutMI.addOperand(MCOp);
   }
 }

lib/Target/PowerPC/PPCSubtarget.h

public:
   bool hasPartwordAtomics() const { return HasPartwordAtomics; }
   bool hasDirectMove() const { return HasDirectMove; }
 
   bool isQPXStackUnaligned() const { return IsQPXStackUnaligned; }
   unsigned getPlatformStackAlignment() const {
     if ((hasQPX() || isBGQ()) && !isQPXStackUnaligned())
       return 32;
 
+    if (isEABI())
+      return 8;
+
     return 16;
   }
   bool hasHTM() const { return HasHTM; }
   bool hasFusion() const { return HasFusion; }
   bool hasFloat128() const { return HasFloat128; }
   bool isISA3_0() const { return IsISA3_0; }
   bool useLongCalls() const { return UseLongCalls; }
   bool needsSwapsForVSXMemOps() const {
     return hasVSX() && isLittleEndian() && !hasP9Vector();
   }
 
   POPCNTDKind hasPOPCNTD() const { return HasPOPCNTD; }
 
   const Triple &getTargetTriple() const { return TargetTriple; }
 
   /// isDarwin - True if this is any darwin platform.
   bool isDarwin() const { return TargetTriple.isMacOSX(); }
   /// isBGQ - True if this is a BG/Q platform.
   bool isBGQ() const { return TargetTriple.getVendor() == Triple::BGQ; }
+  /// isEABI - True if this is an EABI platform.
+  bool isEABI() const { return TargetTriple.isEABI(); }
 
   bool isTargetELF() const { return TargetTriple.isOSBinFormatELF(); }
   bool isTargetMachO() const { return TargetTriple.isOSBinFormatMachO(); }
   bool isTargetLinux() const { return TargetTriple.isOSLinux(); }
 
   bool isDarwinABI() const { return isTargetMachO() || isDarwin(); }
   bool isSVR4ABI() const { return !isDarwinABI(); }
   bool isELFv2ABI() const;

lib/Target/PowerPC/PPCTargetMachine.cpp

 }
 
 static std::unique_ptr<TargetLoweringObjectFile> createTLOF(const Triple &TT) {
   // If it isn't a Mach-O file then it's going to be a linux ELF
   // object file.
   if (TT.isOSDarwin())
     return make_unique<TargetLoweringObjectFileMachO>();
 
+  if (TT.isEABI())
+    return make_unique<PPCEmbeddedTargetObjectFile>();
+
   return make_unique<PPC64LinuxTargetObjectFile>();
 }
 
 static PPCTargetMachine::PPCABI computeTargetABI(const Triple &TT,
                                                  const TargetOptions &Options) {
   if (Options.MCOptions.getABIName().startswith("elfv1"))
     return PPCTargetMachine::PPC_ABI_ELFv1;
   else if (Options.MCOptions.getABIName().startswith("elfv2"))

lib/Target/PowerPC/PPCTargetObjectFile.h

class PPC64LinuxTargetObjectFile : public TargetLoweringObjectFileELF {
 
     MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override;
 
     /// \brief Describe a TLS variable address within debug info.
     const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const override;
   };
 
+  /// PPCEmbeddedTargetObjectFile - This implementation is used for
+  /// 32-bit PPC-EABI.
+  class PPCEmbeddedTargetObjectFile : public TargetLoweringObjectFileELF {
+    MCSection *SmallDataSection = nullptr;
+    MCSection *SmallData2Section = nullptr;
+    MCSection *SmallBssSection = nullptr;
+
+    bool isConstantInSmallSectionKind(const DataLayout &DL,
+                                      const Constant *C) const override;
+
+    bool isGlobalInSmallSectionKind(const GlobalObject *GO,
+                                    const TargetMachine &TM) const override;
+
+  public:
+
+    void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
+
+    MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
+                                      const TargetMachine &TM) const override;
+
+    MCSection *getSectionForConstant(const DataLayout &DL,
+                                     SectionKind Kind,
+                                     const Constant *C,
+                                     unsigned &Align) const override;
+  };
+
 }  // end namespace llvm
 
 #endif

lib/Target/PowerPC/PPCTargetObjectFile.cpp

 //===-- PPCTargetObjectFile.cpp - PPC Object Info -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PPCTargetObjectFile.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCSectionELF.h"
+#include "PPCSubtarget.h"
+#include "PPCTargetMachine.h"
 
 using namespace llvm;
 
+static cl::opt<unsigned>
+SSThreshold("ppc-ssection-threshold", cl::Hidden,
+            cl::desc("PPC: Small data and bss section threshold size (default=8)"),
+            cl::init(8));
+
 void
 PPC64LinuxTargetObjectFile::
 Initialize(MCContext &Ctx, const TargetMachine &TM) {
   TargetLoweringObjectFileELF::Initialize(Ctx, TM);
   InitializeELF(TM.Options.UseInitArray);
 }
 
 MCSection *PPC64LinuxTargetObjectFile::SelectSectionForGlobal(

 getDebugThreadLocalSymbol(const MCSymbol *Sym) const {
   const MCExpr *Expr =
     MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_DTPREL, getContext());
   return MCBinaryExpr::createAdd(Expr,
                                  MCConstantExpr::create(0x8000, getContext()),
                                  getContext());
 }
 
+
+// A address must be loaded from a small section if its size is less than the
+// small section size threshold. Data in this section must be addressed against
+// non-volatile r13 for .sdata/.sbss and r2 for .sdata2.
+static bool isInSmallSection(uint64_t Size) {
+  // gcc has traditionally not treated zero-sized objects as small data, so this
+  // is effectively part of the ABI.
+  return Size > 0 && Size <= SSThreshold;
+}
+
+/// Return true if this constant should be placed into small data/bss
+/// section. This method does all the work, directly influencing section
+/// kind.
+bool PPCEmbeddedTargetObjectFile::
+isConstantInSmallSectionKind(const DataLayout &DL, const Constant *C) const {
+  return isInSmallSection(DL.getTypeAllocSize(C->getType()));
+}
+
+/// Return true if this global address should be placed into small data/bss
+/// section. This method does all the work, directly influencing section
+/// kind.
+bool PPCEmbeddedTargetObjectFile::
+isGlobalInSmallSectionKind(const GlobalObject *GO,
+                           const TargetMachine &TM) const {
+  // Only global variables, not functions.
+  const GlobalVariable *GVA = dyn_cast<GlobalVariable>(GO);
+  if (!GVA)
+    return false;
+
+  Type *Ty = GVA->getValueType();
+  return isInSmallSection(
+      GVA->getParent()->getDataLayout().getTypeAllocSize(Ty));
+}
+
+void
+PPCEmbeddedTargetObjectFile::
+Initialize(MCContext &Ctx, const TargetMachine &TM) {
+  TargetLoweringObjectFileELF::Initialize(Ctx, TM);
+  InitializeELF(TM.Options.UseInitArray);
+
+  SmallDataSection = getContext().getELFSection(
+      ".sdata", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
+  SmallData2Section = getContext().getELFSection(
+      ".sdata2", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
+  SmallBssSection = getContext().getELFSection(
+      ".sbss", ELF::SHT_NOBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
+}
+
+MCSection *PPCEmbeddedTargetObjectFile::SelectSectionForGlobal(
+    const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
+  // Handle Small Section classification here.
+  if (Kind.isSmallBSS())
+    return SmallBssSection;
+  if (Kind.isSmallReadOnly())
+    return SmallData2Section;
+  if (Kind.isSmallKind())
+    return SmallDataSection;
+
+  return TargetLoweringObjectFileELF::SelectSectionForGlobal(GO, Kind, TM);
+}
+
+MCSection *PPCEmbeddedTargetObjectFile::getSectionForConstant(
+    const DataLayout &DL, SectionKind Kind,
+    const Constant *C, unsigned &Align) const {
+  // Handle Small Section classification here.
+  if (Kind.isSmallReadOnly())
+    return SmallData2Section;
+
+  return TargetLoweringObjectFileELF::getSectionForConstant(DL, Kind, C, Align);
+}

lib/Target/TargetLoweringObjectFile.cpp

 /// known to have a type that is an array of 1/2/4 byte elements) ends with a
 /// nul value and contains no other nuls in it.  Note that this is more general
 /// than ConstantDataSequential::isString because we allow 2 & 4 byte strings.
 static bool IsNullTerminatedString(const Constant *C) {
   // First check: is we have constant array terminated with zero
   if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(C)) {
     unsigned NumElts = CDS->getNumElements();
     assert(NumElts != 0 && "Can't have an empty CDS");
-    
     if (CDS->getElementAsInteger(NumElts-1) != 0)
       return false; // Not null terminated.
-    
     // Verify that the null doesn't occur anywhere else in the string.
     for (unsigned i = 0; i != NumElts-1; ++i)
       if (CDS->getElementAsInteger(i) == 0)
         return false;
     return true;
   }
 
   // Another possibility: [1 x i8] zeroinitializer

 
 
 /// getKindForGlobal - This is a top-level target-independent classifier for
 /// a global variable.  Given an global variable and information from TM, it
 /// classifies the global in a variety of ways that make various target
 /// implementations simpler.  The target implementation is free to ignore this
 /// extra info of course.
 SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalObject *GO,
-                                                       const TargetMachine &TM){
+                                                       const TargetMachine &TM) {
   assert(!GO->isDeclaration() && !GO->hasAvailableExternallyLinkage() &&
          "Can only be used for global definitions");
 
   Reloc::Model ReloModel = TM.getRelocationModel();
 
   // Early exit - functions should be always in text sections.
   const auto *GVar = dyn_cast<GlobalVariable>(GO);
   if (!GVar)
     return SectionKind::getText();
 
   // Handle thread-local data first.
   if (GVar->isThreadLocal()) {
     if (isSuitableForBSS(GVar, TM.Options.NoZerosInBSS))
       return SectionKind::getThreadBSS();
     return SectionKind::getThreadData();
   }
 
+  // Provide target-dependent decision for data sections whether the global
+  // should be allocated in the small section.
+  const TargetLoweringObjectFile *TLOF = TM.getObjFileLowering();
+  auto GetData = [=,&TM]() -> SectionKind {
+    return (!TLOF || !TLOF->isGlobalInSmallSectionKind(GO, TM)) ?
+      SectionKind::getData() : SectionKind::getSmallData();
+  };
+  auto GetReadOnly = [=,&TM]() -> SectionKind {
+    return (!TLOF || !TLOF->isGlobalInSmallSectionKind(GO, TM)) ?
+      SectionKind::getReadOnly() : SectionKind::getSmallReadOnly();
+  };
+  auto GetBSS = [=,&TM](SectionKind OrigBSS) -> SectionKind {
+    return (!TLOF || !TLOF->isGlobalInSmallSectionKind(GO, TM)) ?
+      OrigBSS : SectionKind::getSmallBSS();
+  };
+  auto GetCommon = [=,&TM]() -> SectionKind {
+    return (!TLOF || !TLOF->isGlobalInSmallSectionKind(GO, TM)) ?
+      SectionKind::getCommon() : SectionKind::getSmallCommon();
+  };
+  auto GetMergeableConst = [=,&TM](SectionKind OrigMerge) -> SectionKind {
+    return (!TLOF || !TLOF->isGlobalInSmallSectionKind(GO, TM)) ?
+      OrigMerge : SectionKind::getSmallReadOnly();
+  };
+
   // Variables with common linkage always get classified as common.
   if (GVar->hasCommonLinkage())
-    return SectionKind::getCommon();
+    return GetCommon();
 
   // Variable can be easily put to BSS section.
   if (isSuitableForBSS(GVar, TM.Options.NoZerosInBSS)) {
     if (GVar->hasLocalLinkage())
-      return SectionKind::getBSSLocal();
+      return GetBSS(SectionKind::getBSSLocal());
     else if (GVar->hasExternalLinkage())
-      return SectionKind::getBSSExtern();
-    return SectionKind::getBSS();
+      return GetBSS(SectionKind::getBSSExtern());
+    return GetBSS(SectionKind::getBSS());
   }
 
   const Constant *C = GVar->getInitializer();
 
   // If the global is marked constant, we can put it into a mergable section,
   // a mergable string section, or general .data if it contains relocations.
   if (GVar->isConstant()) {
     // If the initializer for the global contains something that requires a
     // relocation, then we may have to drop this into a writable data section
     // even though it is marked const.
     if (!C->needsRelocation()) {
       // If the global is required to have a unique address, it can't be put
       // into a mergable section: just drop it into the general read-only
       // section instead.
       if (!GVar->hasGlobalUnnamedAddr())
-        return SectionKind::getReadOnly();
+        return GetReadOnly();
 
       // If initializer is a null-terminated string, put it in a "cstring"
       // section of the right width.
       if (ArrayType *ATy = dyn_cast<ArrayType>(C->getType())) {
         if (IntegerType *ITy =
               dyn_cast<IntegerType>(ATy->getElementType())) {
           if ((ITy->getBitWidth() == 8 || ITy->getBitWidth() == 16 ||
                ITy->getBitWidth() == 32) &&
if (!C->needsRelocation()) {
         }
       }
 
       // Otherwise, just drop it into a mergable constant section.  If we have
       // a section for this size, use it, otherwise use the arbitrary sized
       // mergable section.
       switch (
           GVar->getParent()->getDataLayout().getTypeAllocSize(C->getType())) {
-      case 4:  return SectionKind::getMergeableConst4();
-      case 8:  return SectionKind::getMergeableConst8();
-      case 16: return SectionKind::getMergeableConst16();
-      case 32: return SectionKind::getMergeableConst32();
+      case 4:  return GetMergeableConst(SectionKind::getMergeableConst4());
+      case 8:  return GetMergeableConst(SectionKind::getMergeableConst8());
+      case 16: return GetMergeableConst(SectionKind::getMergeableConst16());
+      case 32: return GetMergeableConst(SectionKind::getMergeableConst32());
       default:
-        return SectionKind::getReadOnly();
+        return GetReadOnly();
       }
 
     } else {
       // In static, ROPI and RWPI relocation models, the linker will resolve
       // all addresses, so the relocation entries will actually be constants by
       // the time the app starts up.  However, we can't put this into a
       // mergable section, because the linker doesn't take relocations into
       // consideration when it tries to merge entries in the section.
       if (ReloModel == Reloc::Static || ReloModel == Reloc::ROPI ||
           ReloModel == Reloc::RWPI || ReloModel == Reloc::ROPI_RWPI)
-        return SectionKind::getReadOnly();
+        return GetReadOnly();
 
       // Otherwise, the dynamic linker needs to fix it up, put it in the
       // writable data.rel section.
       return SectionKind::getReadOnlyWithRel();
     }
   }
 
   // Okay, this isn't a constant.
-  return SectionKind::getData();
+  return GetData();
+}
+
+/// Determine if constant is allocated in a subtarget small data
+/// SectionKind.
+bool TargetLoweringObjectFile::isConstantInSmallSection(const DataLayout &DL,
+                                                        const Constant *C,
+                                                        const TargetMachine &TM) {
+  const TargetLoweringObjectFile *TLOF = TM.getObjFileLowering();
+  assert(TLOF != nullptr &&
+         "No TargetLoweringObjectFile for small section classification");
+  return TLOF->isConstantInSmallSectionKind(DL, C);
+}
+
+/// Determine if global variable is allocated in a subtarget small data
+/// SectionKind.
+bool TargetLoweringObjectFile::isGlobalInSmallSection(const GlobalObject *GO,
+                                                      const TargetMachine &TM) {
+  if (GO->isDeclaration() || GO->hasAvailableExternallyLinkage()) {
+    // getKindForGlobal only accepts defined objects. This failsafe bypasses
+    // classification steps not needed when handling declarations.
+    const TargetLoweringObjectFile *TLOF = TM.getObjFileLowering();
+    assert(TLOF != nullptr &&
+           "No TargetLoweringObjectFile for small section classification");
+    return TLOF->isGlobalInSmallSectionKind(GO, TM);
+  }
+
+  // Proceed with full SectionKind classification
+  return getKindForGlobal(GO, TM).isSmallKind();
 }
 
 /// This method computes the appropriate section to emit the specified global
 /// variable or function definition.  This should not be passed external (or
 /// available externally) globals.
 MCSection *TargetLoweringObjectFile::SectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
   // Select section name.

lib/Target/X86/X86AsmPrinter.cpp

 }
 
 MCSymbol *X86AsmPrinter::GetCPISymbol(unsigned CPID) const {
   if (Subtarget->isTargetKnownWindowsMSVC()) {
     const MachineConstantPoolEntry &CPE =
         MF->getConstantPool()->getConstants()[CPID];
     if (!CPE.isMachineConstantPoolEntry()) {
       const DataLayout &DL = MF->getDataLayout();
-      SectionKind Kind = CPE.getSectionKind(&DL);
+      SectionKind Kind = CPE.getSectionKind(&DL, TM);
       const Constant *C = CPE.Val.ConstVal;
       unsigned Align = CPE.Alignment;
       if (const MCSectionCOFF *S = dyn_cast<MCSectionCOFF>(
               getObjFileLowering().getSectionForConstant(DL, Kind, C, Align))) {
         if (MCSymbol *Sym = S->getCOMDATSymbol()) {
           if (Sym->isUndefined())
             OutStreamer->EmitSymbolAttribute(Sym, MCSA_Global);
           return Sym;

test/CodeGen/PowerPC/eabi-small-data.ll

+; RUN: llc -mtriple=powerpc-unknown-unknown-eabi -ppc-ssection-threshold=8 < %s | FileCheck %s -check-prefix=SMALL8
+; RUN: llc -mtriple=powerpc-unknown-unknown-eabi -ppc-ssection-threshold=0 < %s | FileCheck %s -check-prefix=SMALL0
+; RUN: llc -mtriple=powerpc-unknown-unknown-eabi -ppc-ssection-threshold=8 < %s | FileCheck %s -check-prefix=SMALLRET8
+; RUN: llc -mtriple=powerpc-unknown-unknown-eabi -ppc-ssection-threshold=0 < %s | FileCheck %s -check-prefix=SMALLRET0
+
+@s1 = internal unnamed_addr global i32 8, align 4
+@s2 = internal unnamed_addr global i32 4, align 4
+@g1 = external global i32
+@c1 = external constant i32
+
+define float @foo() nounwind {
+entry:
+  %0 = load i32, i32* @s1, align 4
+; SMALL8: lwz 3, s1@sda21(13)
+; SMALL0: lwz 3, s1@l(30)
+  tail call void @foo1(i32 %0) nounwind
+; SMALL8: bl foo1
+; SMALL0: bl foo1
+  %1 = load i32, i32* @g1, align 4
+  %2 = load i32, i32* @c1, align 4
+; SMALL8: lwz 3, g1@sda21(13)
+; SMALL8: lwz 4, c1@sda21(2)
+; SMALL0: lis 3, g1@ha
+; SMALL0: lis 4, c1@ha
+; SMALL0: lwz 5, g1@l(3)
+; SMALL0: lwz 4, c1@l(4)
+  %add = add nsw i32 %1, 2
+; SMALL8: stw 3, s1@sda21(13)
+; SMALL8: addi 3, 3, 2
+; SMALL0: stw 5, s1@l(30)
+; SMALL0: addi 5, 5, 2
+  store i32 %1, i32* @s1, align 4
+  store i32 %2, i32* @s2, align 4
+  store i32 %add, i32* @g1, align 4
+; SMALL8: stw 4, s2@sda21(13)
+; SMALL8: stw 3, g1@sda21(13)
+; SMALL0: stw 4, s2@l(7)
+; SMALL0: stw 5, g1@l(3)
+  ret float 1.0
+; SMALLRET8: lfs 1, .LCPI0_0@sda21(2)
+; SMALLRET0: lis 6, .LCPI0_0@ha
+; SMALLRET0: lfs 1, .LCPI0_0@l(6)
+}
+
+declare void @foo1(i32)

test/MC/PowerPC/ppc-reloc.s

 # RUN: llvm-mc -triple=powerpc-unknown-linux-gnu -filetype=obj %s | \
 # RUN: llvm-readobj -r | FileCheck %s
-  .section .text
+  .text
 
   .globl foo
   .type foo,@function
-  .align 2
 foo:
   bl printf@plt
+  bl printf
+  beq printf
+  beqa printf
   bl _GLOBAL_OFFSET_TABLE_@local-4
+  lwz 4, smallval@sda21(13)
+  lis 5, .LC1@ha
+  addi 5, 5, .LC1@l
 .LC1:
   .size foo, . - foo
 
+  .sdata
+  .globl smallval
+smallval:
+  .long 0xDEADBEEF
+  .long foo
+  .long .LC1 - .
+
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section {{.*}} .rela.text {
 # CHECK-NEXT:     0x0 R_PPC_PLTREL24 printf 0x0
-# CHECK-NEXT:     0x4 R_PPC_LOCAL24PC _GLOBAL_OFFSET_TABLE_ 0xFFFFFFFC
+# CHECK-NEXT:     0x4 R_PPC_REL24 printf 0x0
+# CHECK-NEXT:     0x8 R_PPC_REL14 printf 0x0
+# CHECK-NEXT:     0xC R_PPC_ADDR14 printf 0x0
+# CHECK-NEXT:     0x10 R_PPC_LOCAL24PC _GLOBAL_OFFSET_TABLE_ 0xFFFFFFFC
+# CHECK-NEXT:     0x15 R_PPC_EMB_SDA21 smallval 0x0
+# CHECK-NEXT:     0x1A R_PPC_ADDR16_HA .text 0x20
+# CHECK-NEXT:     0x1E R_PPC_ADDR16_LO .text 0x20
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {{.*}} .rela.sdata {
+# CHECK-NEXT:     0x4 R_PPC_ADDR32 foo 0x0
+# CHECK-NEXT:     0x8 R_PPC_REL32 .text 0x20
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]