add typeDataQuicker

[shankarke]

Summary

This adds typeDataQuicker functionality and adds Hexagon specific atom handling for typeDataQuicker symbol types.

[kledzik]

Is "quicker" the right name? Is that term used elsewhere? I assume this is for the small data that can be accessed with better codegen than regular global data. Do we need to support zero-fill and initialized "quicker" data?

[shankarke]

Yes, We need to support zero filled and initialized quicker data. In addition we need one for commons too. Right now zero filled and commons are being treated similiarly. I am planning to add that functionality in the next set of patches.

[Bigcheese]

Looks fine with these changes.

include/lld/Core/DefinedAtom.h

126

typeDataFast

lib/ReaderWriter/ELF/Atoms.h

252–255

This should be cached.

lib/ReaderWriter/ELF/DefaultLayout.h

300–301

StringSwitch should have one per line.

[shankarke]

include/lld/Core/DefinedAtom.h

126

Ok.

lib/ReaderWriter/ELF/Atoms.h

252–255

ok.

lib/ReaderWriter/ELF/DefaultLayout.h

300–301

ok.

[Eugene.Zelenko]

Committed in rL175901.

include/lld/Core/DefinedAtom.h

     typeLiteral8,           // an eight-btye read-only constant
     typeLiteral16,          // a sixteen-btye read-only constant
     typeData,               // read-write data
+    typeDataQuicker,        // allow data to be quickly accessed
     typeZeroFill,           // zero-fill data
     typeConstData,          // read-only data after dynamic linker is done
     typeObjC1Class,         // ObjC1 class [Darwin]

lib/Core/DefinedAtom.cpp

     return permR__;
 
   case typeData:
+  case typeDataQuicker:
   case typeZeroFill:
   case typeObjC1Class:
   case typeLazyPointer:

lib/ReaderWriter/ELF/Atoms.h

     return _ordinal;
   }
 
+  const Elf_Sym *symbol() const { return _symbol; }
+
+  const Elf_Shdr *section() const { return _section; }
+
   virtual uint64_t size() const {
     // Common symbols are not allocated in object files,
     // so use st_size to tell how many bytes are required.
-    if ((_symbol->getType() == llvm::ELF::STT_COMMON)
-        || _symbol->st_shndx == llvm::ELF::SHN_COMMON)
-      return (uint64_t)_symbol->st_size;
+   
+    // Treat target defined common symbols 
+    if ((_symbol->st_shndx > llvm::ELF::SHN_LOPROC &&
+         _symbol->st_shndx < llvm::ELF::SHN_HIPROC)) {
+      const ELFTargetInfo &eti = (_owningFile.getTargetInfo());
+      TargetHandler<ELFT> &TargetHandler = eti.getTargetHandler<ELFT>();
+      TargetAtomHandler<ELFT> &elfAtomHandler =
+          TargetHandler.targetAtomHandler();
+      if (elfAtomHandler.getType(_symbol) == llvm::ELF::STT_COMMON)
+        return (uint64_t) _symbol->st_size;
+    }
+    if ((_symbol->getType() == llvm::ELF::STT_COMMON) ||
+        _symbol->st_shndx == llvm::ELF::SHN_COMMON)
+      return (uint64_t) _symbol->st_size;
 
     return _contentData.size();
   }

     if (_symbol->getBinding() == llvm::ELF::STB_WEAK)
       return mergeAsWeak;
 
-    if ((_symbol->getType() == llvm::ELF::STT_COMMON)
-        || _symbol->st_shndx == llvm::ELF::SHN_COMMON)
+    // If the symbol is a target defined and if the target
+    // defines the symbol as a common symbol treat it as 
+    // mergeTentative
+    if ((_symbol->st_shndx > llvm::ELF::SHN_LOPROC &&
+         _symbol->st_shndx < llvm::ELF::SHN_HIPROC)) {
+      const ELFTargetInfo &eti = (_owningFile.getTargetInfo());
+      TargetHandler<ELFT> &TargetHandler = eti.getTargetHandler<ELFT>();
+      TargetAtomHandler<ELFT> &elfAtomHandler =
+          TargetHandler.targetAtomHandler();
+      if (elfAtomHandler.getType(_symbol) == llvm::ELF::STT_COMMON)
+        return mergeAsTentative;
+    }
+
+    if ((_symbol->getType() == llvm::ELF::STT_COMMON) ||
+        _symbol->st_shndx == llvm::ELF::SHN_COMMON)
       return mergeAsTentative;
 
     return mergeNo;

     ContentType ret = typeUnknown;
     uint64_t flags = _section->sh_flags;
 
-    if (_symbol->st_shndx > llvm::ELF::SHN_LOPROC &&
-        _symbol->st_shndx < llvm::ELF::SHN_HIPROC) {
-      const ELFTargetInfo &eti =
-          (_owningFile.getTargetInfo());
-      TargetHandler<ELFT> &TargetHandler =
-          eti.getTargetHandler<ELFT>();
+    // Treat target defined symbols 
+    if ((_section->sh_flags & llvm::ELF::SHF_MASKPROC) ||
+        ((_symbol->st_shndx > llvm::ELF::SHN_LOPROC &&
+          _symbol->st_shndx < llvm::ELF::SHN_HIPROC))) {
+      const ELFTargetInfo &eti = (_owningFile.getTargetInfo());
+      TargetHandler<ELFT> &TargetHandler = eti.getTargetHandler<ELFT>();
       TargetAtomHandler<ELFT> &elfAtomHandler =
           TargetHandler.targetAtomHandler();
       return elfAtomHandler.contentType(this);

   virtual Alignment alignment() const {
     // Unallocated common symbols specify their alignment constraints in
     // st_value.
-    if ((_symbol->getType() == llvm::ELF::STT_COMMON)
-        || _symbol->st_shndx == llvm::ELF::SHN_COMMON) {
+   
+    // Treat target defined common symbols 
+    if ((_symbol->st_shndx > llvm::ELF::SHN_LOPROC &&
+         _symbol->st_shndx < llvm::ELF::SHN_HIPROC)) {
+      const ELFTargetInfo &eti = (_owningFile.getTargetInfo());
+      TargetHandler<ELFT> &TargetHandler = eti.getTargetHandler<ELFT>();
+      TargetAtomHandler<ELFT> &elfAtomHandler =
+          TargetHandler.targetAtomHandler();
+      if (elfAtomHandler.getType(_symbol) == llvm::ELF::STT_COMMON)
+        return Alignment(llvm::Log2_64(_symbol->st_value));
+    }
+
+    if ((_symbol->getType() == llvm::ELF::STT_COMMON) ||
+        _symbol->st_shndx == llvm::ELF::SHN_COMMON) {
       return Alignment(llvm::Log2_64(_symbol->st_value));
     }
     return Alignment(llvm::Log2_64(_section->sh_addralign),

lib/ReaderWriter/ELF/DefaultLayout.h

   
   case DefinedAtom::typeConstant:
     return ORDER_RODATA;
-  
   case DefinedAtom::typeData:
+  case DefinedAtom::typeDataQuicker:
     return llvm::StringSwitch<Reference::Kind>(name)
-      .StartsWith(".init_array", ORDER_INIT_ARRAY)
-      .Default(ORDER_DATA);
-  
+        .StartsWith(".init_array", ORDER_INIT_ARRAY).Default(ORDER_DATA);
+
   case DefinedAtom::typeZeroFill:
     return ORDER_BSS;
 

lib/ReaderWriter/ELF/File.h

         bool isCommon = (*si)->getType() == llvm::ELF::STT_COMMON ||
                         (*si)->st_shndx == llvm::ELF::SHN_COMMON;
 
-        DefinedAtom::ContentType c;
-
-        if (((*si)->st_shndx >= llvm::ELF::SHN_LOPROC) &&
-            ((*si)->st_shndx <= llvm::ELF::SHN_HIPROC)) {
+        if ((section && section->sh_flags & llvm::ELF::SHF_MASKPROC) ||
+            (((*si)->st_shndx >= llvm::ELF::SHN_LOPROC) &&
+             ((*si)->st_shndx <= llvm::ELF::SHN_HIPROC))) {
           TargetHandler<ELFT> &TargetHandler =
-              _elfTargetInfo.getTargetHandler<ELFT>();
+              _elfTargetInfo.template getTargetHandler<ELFT>();
           TargetAtomHandler<ELFT> &elfAtomHandler =
               TargetHandler.targetAtomHandler();
-          c = elfAtomHandler.contentType(*si);
+          int64_t targetSymType = elfAtomHandler.getType(*si);
 
-          if (c == DefinedAtom::typeZeroFill ||
-              c == DefinedAtom::typeTLVInitialZeroFill)
+          if (targetSymType == llvm::ELF::STT_COMMON)
             isCommon = true;
         }
 

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h

 #define LLD_READER_WRITER_ELF_HEXAGON_TARGET_HANDLER_H
 
 #include "DefaultTargetHandler.h"
+#include "ExecutableAtoms.h"
 #include "HexagonRelocationHandler.h"
 #include "TargetLayout.h"
 

 typedef llvm::object::ELFType<llvm::support::little, 4, false> HexagonELFType;
 class HexagonTargetInfo;
 
-class HexagonTargetHandler LLVM_FINAL
-    : public DefaultTargetHandler<HexagonELFType> {
+
+/// \brief Handle Hexagon specific Atoms
+template <class HexagonELFType>
+class HexagonTargetAtomHandler LLVM_FINAL :
+    public TargetAtomHandler<HexagonELFType> {
+  typedef llvm::object::Elf_Sym_Impl<HexagonELFType> Elf_Sym;
+  typedef llvm::object::Elf_Shdr_Impl<HexagonELFType> Elf_Shdr;
 public:
+
+  virtual DefinedAtom::ContentType
+  contentType(const ELFDefinedAtom<HexagonELFType> *atom) const {
+    return contentType(atom->section(), atom->symbol());
+  }
+
+  virtual DefinedAtom::ContentType
+  contentType(const Elf_Shdr *section, const Elf_Sym *sym) const {
+    switch (sym->st_shndx) {
+    // Common symbols
+    case llvm::ELF::SHN_HEXAGON_SCOMMON:
+    case llvm::ELF::SHN_HEXAGON_SCOMMON_1:
+    case llvm::ELF::SHN_HEXAGON_SCOMMON_2:
+    case llvm::ELF::SHN_HEXAGON_SCOMMON_4:
+    case llvm::ELF::SHN_HEXAGON_SCOMMON_8:
+      return DefinedAtom::typeZeroFill;
+
+    default:
+      if (section->sh_flags & llvm::ELF::SHF_HEX_GPREL)
+        return DefinedAtom::typeDataQuicker;
+      else
+        llvm_unreachable("unknown symbol type");
+    }
+  }
+
+  virtual DefinedAtom::ContentPermissions
+  contentPermissions(const ELFDefinedAtom<HexagonELFType> *atom) const {
+    // All of the hexagon specific symbols belong in the data segment
+    return DefinedAtom::permRW_;
+  }
+
+  virtual int64_t getType(const Elf_Sym *sym) const {
+    switch (sym->st_shndx) {
+    // Common symbols
+    case llvm::ELF::SHN_HEXAGON_SCOMMON:
+    case llvm::ELF::SHN_HEXAGON_SCOMMON_1:
+    case llvm::ELF::SHN_HEXAGON_SCOMMON_2:
+    case llvm::ELF::SHN_HEXAGON_SCOMMON_4:
+    case llvm::ELF::SHN_HEXAGON_SCOMMON_8:
+      return llvm::ELF::STT_COMMON;
+
+    default:
+      return sym->getType();
+    }
+  }
+};
+
+/// \brief TargetHandler for Hexagon 
+class HexagonTargetHandler LLVM_FINAL :
+    public DefaultTargetHandler<HexagonELFType> {
+public:
   HexagonTargetHandler(HexagonTargetInfo &targetInfo);
 
   virtual TargetLayout<HexagonELFType> &targetLayout() {
     return _targetLayout;
   }
 
+  virtual TargetAtomHandler<HexagonELFType> &targetAtomHandler() {
+    return _targetAtomHandler;
+  }
+
   virtual const HexagonTargetRelocationHandler &getRelocationHandler() const {
     return _relocationHandler;
   }

 private:
   HexagonTargetRelocationHandler _relocationHandler;
   TargetLayout<HexagonELFType> _targetLayout;
+  HexagonTargetAtomHandler<HexagonELFType> _targetAtomHandler;
 };
 } // end namespace elf
 } // end namespace lld

lib/ReaderWriter/ELF/SectionChunks.h

     this->setOrder(order);
     switch (contentType) {
     case DefinedAtom::typeCode:
+    case DefinedAtom::typeDataQuicker:
     case DefinedAtom::typeData:
     case DefinedAtom::typeConstant:
     case DefinedAtom::typeGOT:

     case DefinedAtom::typeStub:
     case DefinedAtom::typeResolver:
     case DefinedAtom::typeTLVInitialData:
+    case DefinedAtom::typeDataQuicker:
       _atoms.push_back(new (_alloc) AtomLayout(atom, fOffset, 0));
       this->_fsize = fOffset + definedAtom->size();
       this->_msize = mOffset + definedAtom->size();

lib/ReaderWriter/ELF/TargetHandler.h

 /// type of atom and its permissions 
 template <class ELFT> class TargetAtomHandler {
 public:
+  typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
 
-  virtual DefinedAtom::ContentType contentType(
-      const ELFDefinedAtom<ELFT> *atom) const {
+  virtual DefinedAtom::ContentType
+  contentType(const ELFDefinedAtom<ELFT> *atom) const {
     return atom->contentType();
   }
 
-  virtual DefinedAtom::ContentType contentType(const Elf_Sym *sym) const {
+  virtual DefinedAtom::ContentType
+  contentType(const Elf_Shdr *shdr, const Elf_Sym *sym) const {
     return DefinedAtom::typeZeroFill;
   }
 

     return atom->permissions();
   }
 
+  virtual int64_t getType(const Elf_Sym *sym) const {
+    return llvm::ELF::STT_NOTYPE;
+  }
 };
 
 template <class ELFT> class TargetRelocationHandler {

lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

                           lld::DefinedAtom::typeCode);
     io.enumCase(value, "stub",                
                           lld::DefinedAtom::typeStub);
-    io.enumCase(value, "constant",            
-                          lld::DefinedAtom::typeConstant);
-    io.enumCase(value, "data",                
-                          lld::DefinedAtom::typeData);
-    io.enumCase(value, "zero-fill",           
-                          lld::DefinedAtom::typeZeroFill);
-    io.enumCase(value, "const-data",                 
-                          lld::DefinedAtom::typeConstData);
+    io.enumCase(value, "constant", lld::DefinedAtom::typeConstant);
+    io.enumCase(value, "data", lld::DefinedAtom::typeData);
+    io.enumCase(value, "quick-data", lld::DefinedAtom::typeDataQuicker);
+    io.enumCase(value, "zero-fill", lld::DefinedAtom::typeZeroFill);
+    io.enumCase(value, "const-data", lld::DefinedAtom::typeConstData);
     io.enumCase(value, "got",                 
                           lld::DefinedAtom::typeGOT);
     io.enumCase(value, "resolver",            

test/elf/branch.objtxt

-RUN: lld-core -reader ELF %p/Inputs/branch-test.hexagon %p/Inputs/target-test.hexagon | FileCheck %s -check-prefix hexagon-yaml
+RUN: lld-core -arch hexagon -reader ELF %p/Inputs/branch-test.hexagon %p/Inputs/target-test.hexagon | FileCheck %s -check-prefix hexagon-yaml
 RUN: lld-core -arch hexagon -reader ELF -writer ELF -o %t1 %p/Inputs/branch-test.hexagon %p/Inputs/target-test.hexagon
 RUN: elf-dump %t1 |  FileCheck -check-prefix=hexagon-elfdump %s 
 

test/elf/quickdata.test

+RUN: lld-core -arch hexagon -reader ELF %p/Inputs/quickdata-test.elf-hexagon | FileCheck %s -check-prefix hexagon
+
+hexagon:  - name:            init
+hexagon:    scope:           global
+hexagon:    type:            quick-data
+hexagon:  - name:            bss1
+hexagon:    scope:           global
+hexagon:    type:            quick-data
+hexagon:  - name:            ac1
+hexagon:    scope:           global
+hexagon:    type:            zero-fill
+hexagon:    size:            1
+hexagon:    merge:           as-tentative
+hexagon:    permissions:     ---