Initial support for Hexagon target.

[sidneym]

Summary

Support B22_PCREL relocation along with a simple test.

I'm also working on a llvmSupport patch that will detail the instruction set encoding. Many of Hexagon's instructions have immediates that are peppered throughout the word makeing application of fixups tedious since the same relocation fixup may need to be placed in different bits depending on the instruction. That change will be made in llvmSupport so that both lld and llvm-rtdyld can share encoding information.

[ruiu]

ELF/Arch/Hexagon.cpp

47

sizeof(uint32_t) * 8 is always 32.

78

Remove extraneous blank line. If you take a look at other files in lld, you'd notice that we normally don't add a blank line before "default:".

test/ELF/Inputs/hexagon.s

2

Remove a leading empty line.

test/ELF/hexagon.s

3

Remove extranesous space between "mc" and "-filetype"

10

Remove extraneous space characters.

[sidneym]

Made the changes Rui suggested.

[ruiu]

ELF/Arch/Hexagon.cpp

48

We normally don't add const if the variable's scope is narrow.

73

We usually use much shorter variable name for a variable whose scope is very narrow. Just V would be enough for this.

75

I believe we have or32le.

[sidneym]

Adopted more of Rui's suggestions.

[ruiu]

ELF/Arch/Hexagon.cpp

27

Please read other files in the same directory and follow the same naming convention. This should be named just Hexagon.

39

You don't need this assert as you are not depending on it.

51

I believe ValBit (which is bool) is promoted to int because of the usual integer promotion before << is applied, but this is perhaps a bit confusing. It is better to make their types uint32_t.

74

You don't need {} if you do not define a new variable inside {}.

[sidneym]

Integrated suggested changes.

[ruiu]

ELF/Arch/Hexagon.cpp

46–47

Please do not use auto as well. As I said, if you read other code in this directory or other directories in lld, you'd notice that we normally don't use auto unless its type is obvious (i.e. to avoid a repetition like Foo *X = dyn_cast<Foo>(Y)). I'd be more careful to follow the convention by reading code first.

[sidneym]

Use type instead of auto.

[ruiu]

ELF/Arch/Hexagon.cpp

42

I think it needs a comment, but I'll do that in a follow-up patch.

ELF/Arch/Hexagon.cpp

+//===-- Hexagon.cpp -------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "InputFiles.h"
+#include "Symbols.h"
+#include "Target.h"
+#include "lld/Common/ErrorHandler.h"
+#include "llvm/BinaryFormat/ELF.h"
+#include "llvm/Object/ELF.h"
+#include "llvm/Support/Endian.h"
+
+using namespace llvm;
+using namespace llvm::object;
+using namespace llvm::support::endian;
+using namespace llvm::ELF;
+using namespace lld;
+using namespace lld::elf;
+
+namespace {
+class Hexagon final : public TargetInfo {
+public:
+  uint32_t calcEFlags() const override;
+  uint32_t applyMask(uint32_t Mask, uint32_t Data) const;
+  RelExpr getRelExpr(RelType Type, const Symbol &S,
+                     const uint8_t *Loc) const override;
+  void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
+};
+} // namespace
+
+// Support V60 only at the moment.
+uint32_t Hexagon::calcEFlags() const {
+  return 0x60;
+}
+
+uint32_t Hexagon::applyMask(uint32_t Mask, uint32_t Data) const {
+  uint32_t Result = 0;
+  size_t Off = 0;
+
+  for (size_t Bit = 0; Bit != 32; ++Bit) {
+    auto ValBit = (Data >> Off) & 1;
+    auto MaskBit = (Mask >> Bit) & 1;
+    if (MaskBit) {
+      Result |= (ValBit << Bit);
+      ++Off;
+    }
+  }
+  return Result;
+}
+
+RelExpr Hexagon::getRelExpr(RelType Type, const Symbol &S,
+                                 const uint8_t *Loc) const {
+  switch (Type) {
+  case R_HEX_B22_PCREL:
+    return R_PC;
+  default:
+    return R_ABS;
+  }
+}
+
+static void or32le(uint8_t *P, int32_t V) { write32le(P, read32le(P) | V); }
+
+void Hexagon::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
+  switch (Type) {
+  case R_HEX_NONE:
+    break;
+  case R_HEX_B22_PCREL:
+    or32le(Loc, applyMask(0x01ff3ffe, ((Val >> 2) & 0x3fffff)));
+    break;
+  default:
+    error(getErrorLocation(Loc) + "unrecognized reloc " + toString(Type));
+    break;
+  }
+}
+
+TargetInfo *elf::getHexagonTargetInfo() {
+  static Hexagon Target;
+  return &Target;
+}

ELF/CMakeLists.txt

   Arch/AMDGPU.cpp
   Arch/ARM.cpp
   Arch/AVR.cpp
+  Arch/Hexagon.cpp
   Arch/Mips.cpp
   Arch/MipsArchTree.cpp
   Arch/PPC.cpp

ELF/Target.h

 TargetInfo *getAMDGPUTargetInfo();
 TargetInfo *getARMTargetInfo();
 TargetInfo *getAVRTargetInfo();
+TargetInfo *getHexagonTargetInfo();
 TargetInfo *getPPC64TargetInfo();
 TargetInfo *getPPCTargetInfo();
 TargetInfo *getSPARCV9TargetInfo();

ELF/Target.cpp

     return getARMTargetInfo();
   case EM_AVR:
     return getAVRTargetInfo();
+  case EM_HEXAGON:
+    return getHexagonTargetInfo();
   case EM_MIPS:
     switch (Config->EKind) {
     case ELF32LEKind:

test/ELF/Inputs/hexagon.s

+.global _start
+_start:
+  nop
+.global foo
+foo:
+  jumpr lr

test/ELF/hexagon.s

+# REQUIRES: hexagon
+# RUN: llvm-mc -filetype=obj -triple=hexagon-unknown-elf %s -o %t
+# RUN: llvm-mc -filetype=obj -triple=hexagon-unknown-elf %S/Inputs/hexagon.s -o %t2
+# RUN: ld.lld %t2 %t  -o %t3
+# RUN: llvm-objdump -d  %t3 | FileCheck %s
+
+# R_HEX_B22_PCREL
+call #_start
+# CHECK: call 0x11000

test/lit.cfg.py

                           'AMDGPU': 'amdgpu',
                           'ARM': 'arm',
                           'AVR': 'avr',
+                          'Hexagon': 'hexagon',
                           'Mips': 'mips',
                           'PowerPC': 'ppc',
                           'Sparc': 'sparc',