[lld][ELF] Change MaxAlignment to 2

[shankarke]

Summary

We would want to make sure the target handlers use the same alignment as how they are read.

Setting the MaxAlignment to 2, makes it safe.

[Bigcheese]

lgtm.

I hate archives :(

[Eugene.Zelenko]

Committed in rL192310.

lib/ReaderWriter/ELF/Hexagon/HexagonExecutableAtoms.h

 //===- lib/ReaderWriter/ELF/Hexagon/HexagonExecutableAtoms.h --------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_READER_WRITER_ELF_HEXAGON_EXECUTABLE_ATOM_H
 #define LLD_READER_WRITER_ELF_HEXAGON_EXECUTABLE_ATOM_H
 
 #include "File.h"
 
 namespace lld {
 namespace elf {
-typedef llvm::object::ELFType<llvm::support::little, 4, false> HexagonELFType;
+typedef llvm::object::ELFType<llvm::support::little, 2, false> HexagonELFType;
 class HexagonLinkingContext;
 
 template <class HexagonELFType> class HexagonRuntimeFile
   : public CRuntimeFile<HexagonELFType> {
 public:
   HexagonRuntimeFile(const HexagonLinkingContext &context)
       : CRuntimeFile<HexagonELFType>(context, "Hexagon runtime file") {}
 };
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_HEXAGON_EXECUTABLE_ATOM_H

lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.h

 #define LLD_READER_WRITER_ELF_HEXAGON_RELOCATION_HANDLER_H
 
 #include "HexagonSectionChunks.h"
 #include "HexagonTargetHandler.h"
 #include "lld/ReaderWriter/RelocationHelperFunctions.h"
 
 namespace lld {
 namespace elf {
-typedef llvm::object::ELFType<llvm::support::little, 4, false> HexagonELFType;
 
 class HexagonLinkingContext;
 class HexagonTargetHandler;
 template <class HexagonELFType> class HexagonTargetLayout;
 
 class HexagonTargetRelocationHandler LLVM_FINAL :
     public TargetRelocationHandler<HexagonELFType> {
 public:

lib/ReaderWriter/ELF/Hexagon/HexagonSectionChunks.h

 //===- lib/ReaderWriter/ELF/Hexagon/HexagonSectionChunks.h-----------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLD_READER_WRITER_ELF_HEXAGON_SECTION_CHUNKS_H
 #define LLD_READER_WRITER_ELF_HEXAGON_SECTION_CHUNKS_H
 
 #include "HexagonTargetHandler.h"
 
 namespace lld {
 namespace elf {
-typedef llvm::object::ELFType<llvm::support::little, 4, false> HexagonELFType;
+typedef llvm::object::ELFType<llvm::support::little, 2, false> HexagonELFType;
 template <typename ELFT> class HexagonTargetLayout;
 class HexagonLinkingContext;
 
 /// \brief Handle Hexagon SData section
 template <class HexagonELFType>
 class SDataSection : public AtomSection<HexagonELFType> {
 public:
   SDataSection(const HexagonLinkingContext &context)

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h

 #include "DefaultTargetHandler.h"
 #include "HexagonExecutableAtoms.h"
 #include "HexagonRelocationHandler.h"
 #include "HexagonSectionChunks.h"
 #include "TargetLayout.h"
 
 namespace lld {
 namespace elf {
-typedef llvm::object::ELFType<llvm::support::little, 4, false> HexagonELFType;
+typedef llvm::object::ELFType<llvm::support::little, 2, false> HexagonELFType;
 class HexagonLinkingContext;
 
 /// \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;

lib/ReaderWriter/ELF/PPC/PPCTargetHandler.h

 #ifndef LLD_READER_WRITER_ELF_PPC_TARGET_HANDLER_H
 #define LLD_READER_WRITER_ELF_PPC_TARGET_HANDLER_H
 
 #include "DefaultTargetHandler.h"
 #include "TargetLayout.h"
 
 namespace lld {
 namespace elf {
-typedef llvm::object::ELFType<llvm::support::big, 4, false> PPCELFType;
+typedef llvm::object::ELFType<llvm::support::big, 2, false> PPCELFType;
 class PPCLinkingContext;
 
 class PPCTargetRelocationHandler LLVM_FINAL
     : public TargetRelocationHandler<PPCELFType> {
 public:
   PPCTargetRelocationHandler(const PPCLinkingContext &context)
       : _context(context) {}
 

lib/ReaderWriter/ELF/X86/X86TargetHandler.h

 #ifndef LLD_READER_WRITER_ELF_X86_TARGET_HANDLER_H
 #define LLD_READER_WRITER_ELF_X86_TARGET_HANDLER_H
 
 #include "DefaultTargetHandler.h"
 #include "TargetLayout.h"
 
 namespace lld {
 namespace elf {
-typedef llvm::object::ELFType<llvm::support::little, 4, false> X86ELFType;
+typedef llvm::object::ELFType<llvm::support::little, 2, false> X86ELFType;
 class X86LinkingContext;
 
 class X86TargetRelocationHandler LLVM_FINAL
     : public TargetRelocationHandler<X86ELFType> {
 public:
   X86TargetRelocationHandler(const X86LinkingContext &context)
       : _context(context) {}
 

lib/ReaderWriter/ELF/X86_64/X86_64RelocationHandler.h

 
 #ifndef X86_64_RELOCATION_HANDLER_H
 #define X86_64_RELOCATION_HANDLER_H
 
 #include "X86_64TargetHandler.h"
 
 namespace lld {
 namespace elf {
-typedef llvm::object::ELFType<llvm::support::little, 8, true> X86_64ELFType;
+typedef llvm::object::ELFType<llvm::support::little, 2, true> X86_64ELFType;
 class X86_64LinkingContext;
 
 class X86_64TargetRelocationHandler LLVM_FINAL
     : public TargetRelocationHandler<X86_64ELFType> {
 public:
   X86_64TargetRelocationHandler(const X86_64LinkingContext &context)
       : _tlsSize(0), _context(context) {}
 

lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.h

 #include "File.h"
 #include "X86_64RelocationHandler.h"
 #include "TargetLayout.h"
 
 #include "lld/ReaderWriter/Simple.h"
 
 namespace lld {
 namespace elf {
-typedef llvm::object::ELFType<llvm::support::little, 8, true> X86_64ELFType;
+typedef llvm::object::ELFType<llvm::support::little, 2, true> X86_64ELFType;
 class X86_64LinkingContext;
 
 class X86_64TargetHandler LLVM_FINAL
     : public DefaultTargetHandler<X86_64ELFType> {
 public:
   X86_64TargetHandler(X86_64LinkingContext &targetInfo);
 
   virtual TargetLayout<X86_64ELFType> &targetLayout() {

test/elf/Hexagon/maxalignment.test

+# This tests that we lld is able to get the contentType properly for archives
+# when they intermittently get loaded at an address whose alignment is 2
+
+RUN: lld -flavor gnu -target hexagon --whole-archive %p/Inputs/libMaxAlignment.a \
+RUN: --noinhibit-exec -static -o %t
+RUN: llvm-nm %t | FileCheck %s
+
+CHECK: {{[0-9a-f]+}} D a