# 23593143 lli JIT bitcode parsing creates a main function with wrong argc/argv

# 22804878 - implement LLVM JIT on Solaris SPARC

# 22804891 - implement LLVM JIT on Solaris Intel

# 3.9.X for upstream.

--- include/llvm/Support/ELFRelocs/Sparc.def	2015-06-18 07:05:15.000000000 -0800

+++ include/llvm/Support/ELFRelocs/Sparc.def	2016-06-11 11:39:24.768074060 -0800

@@ -87,3 +87,8 @@

 ELF_RELOC(R_SPARC_GOTDATA_OP_HIX22,  82)

 ELF_RELOC(R_SPARC_GOTDATA_OP_LOX10,  83)

 ELF_RELOC(R_SPARC_GOTDATA_OP,     84)

+ELF_RELOC(R_SPARC_H34,            85)

+ELF_RELOC(R_SPARC_SIZE32,         86)

+ELF_RELOC(R_SPARC_SIZE64,         87)

+ELF_RELOC(R_SPARC_WDISP10,        88)

+ELF_RELOC(R_SPARC_NUM,            89)

--- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h	2016-01-10 09:51:50.000000000 -0900

+++ lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h	2016-06-11 21:03:29.000000000 -0800

@@ -117,6 +117,11 @@

     assert(StubOffset <= AllocationSize && "Not enough space allocated!");

   }

+  void setStubOffset(unsigned Value) {

+    StubOffset = Value;

+    assert(StubOffset <= AllocationSize && "Not enough space allocated!");

+  }

+

   uintptr_t getObjAddress() const { return ObjAddress; }

 };

###

--- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h	2015-11-23 12:47:51.000000000 -0900

+++ lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h	2016-06-23 07:17:02.829718055 -0800

@@ -49,6 +49,14 @@

   void resolvePPC64Relocation(const SectionEntry &Section, uint64_t Offset,

                               uint64_t Value, uint32_t Type, int64_t Addend);

+  void resolveSPARC3264Relocation(const SectionEntry &Section,

+                                  uint64_t Offset, uint64_t Value,

+                                  uint32_t Type, int32_t Addend);

+

+  void resolveSPARC64Relocation(const SectionEntry &Section,

+                                uint64_t Offset, uint64_t Value,

+                                uint32_t Type, int64_t Addend);

+

   void resolveSystemZRelocation(const SectionEntry &Section, uint64_t Offset,

                                 uint64_t Value, uint32_t Type, int64_t Addend);

@@ -73,6 +81,10 @@

       return 16;

     else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le)

       return 44;

+    else if (Arch == Triple::sparc)

+      return 16;

+    else if (Arch == Triple::sparcv9)

+      return 32;

     else if (Arch == Triple::x86_64)

       return 6; // 2-byte jmp instruction + 32-bit relative address

     else if (Arch == Triple::systemz)

###

--- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp	2015-11-24 11:37:01.000000000 -0900

+++ lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp	2016-07-04 10:45:23.637041765 -0800

@@ -1016,6 +1016,448 @@

   }

 }

+/// SPARC ELF Relocations - common to 32-bit and 64-bit.

+/// https://docs.oracle.com/cd/E19683-01/817-3677/chapter6-24/index.html

+void RuntimeDyldELF::resolveSPARC3264Relocation(const SectionEntry &Section,

+                                                uint64_t Offset,

+                                                uint64_t Value,

+                                                uint32_t Type,

+                                                int32_t Addend) {

+  uint64_t *TargetAddress =

+    reinterpret_cast<uint64_t*>(reinterpret_cast<void*>(Section.getAddress()));

+  uint64_t *TargetPtr =

+    reinterpret_cast<uint64_t*>(Section.getAddressWithOffset(Offset));

+  uint32_t Reloc = 0U;

+  uint8_t *TargetPtr8 = nullptr;

+  uint16_t *TargetPtr16 = nullptr;

+  uint32_t *TargetPtr32 = nullptr;

+  uint32_t LoadAddress = Section.getLoadAddressWithOffset(Offset) & 0xFFFFFFFF;

+  uint32_t TargetValue = 0U;

+  int32_t RS = 0;

+  int32_t RM = 0;

+

+  switch (Type) {

+  default:

+    llvm_unreachable("Unimplemented SPARC32 Relocation Type!");

+    break;

+  case ELF::R_SPARC_NONE:

+    break;

+  case ELF::R_SPARC_SIZE32:

+    *TargetPtr = Section.getSize() + Addend;

+    break;

+  case ELF::R_SPARC_RELATIVE:

+    *TargetPtr = LoadAddress + Addend;

+    break;

+  case ELF::R_SPARC_COPY:

+    Value += Addend;

+    (void) std::memcpy(TargetPtr,

+                       reinterpret_cast<void*>(static_cast<uintptr_t>(Value)),

+                       Section.getSize());

+    break;

+  case ELF::R_SPARC_8:

+    TargetPtr8 = reinterpret_cast<uint8_t*>(TargetPtr);

+    Value += Addend;

+    *TargetPtr8 = Value;

+    break;

+  case ELF::R_SPARC_16:

+    TargetPtr16 = reinterpret_cast<uint16_t*>(TargetPtr);

+    Value += Addend;

+    *TargetPtr16 = Value;

+    break;

+  case ELF::R_SPARC_32:

+  case ELF::R_SPARC_GLOB_DAT:

+    Value += Addend;

+    *TargetPtr = Value;

+    break;

+  case ELF::R_SPARC_JMP_SLOT:

+    break;

+  case ELF::R_SPARC_TLS_DTPOFF32:

+    Value += Addend;

+    *TargetPtr = Value;

+    break;

+  case ELF::R_SPARC_TLS_TPOFF32:

+    Value += Addend;

+    *TargetPtr = Value - Offset;

+    break;

+  case ELF::R_SPARC_TLS_LE_HIX22:

+    Value -= Offset;

+    Value += Addend;

+    *TargetPtr = (*TargetPtr & 0xFFC00000) | ((~Value) & 0x003FFFFFLL);

+    break;

+  case ELF::R_SPARC_TLS_LE_LOX10:

+    Value -= Offset;

+    Value += Addend;

+    *TargetPtr = (*TargetPtr & 0xFFFFE000) | (Value & 0x000003FFLL);

+    break;

+  case ELF::R_SPARC_DISP8:

+    Value += Addend;

+    TargetPtr8 = reinterpret_cast<uint8_t*>(TargetAddress);

+    *TargetPtr8 = (Value - reinterpret_cast<uintptr_t>(TargetPtr8));

+    break;

+  case ELF::R_SPARC_DISP16:

+    Value += Addend;

+    TargetPtr16 = reinterpret_cast<uint16_t*>(TargetAddress);

+    *TargetPtr16 = (Value - reinterpret_cast<uintptr_t>(TargetPtr16));

+    break;

+  case ELF::R_SPARC_DISP32:

+    Value += Addend;

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetAddress);

+    *TargetPtr32 = (Value - reinterpret_cast<uintptr_t>(TargetPtr32));

+    break;

+  case ELF::R_SPARC_WDISP30:

+  case ELF::R_SPARC_WDISP22:

+  case ELF::R_SPARC_WDISP19:

+  case ELF::R_SPARC_WDISP16:

+  case ELF::R_SPARC_WDISP10:

+    switch (Type) {

+    default:

+      llvm_unreachable("Impossible default case!");

+      break;

+    case ELF::R_SPARC_WDISP30:

+      RS = 2;

+      RM = 0x3FFFFFFF;

+      break;

+    case ELF::R_SPARC_WDISP22:

+      RS = 2;

+      RM = 0x003FFFFF;

+      break;

+    case ELF::R_SPARC_WDISP19:

+      RS = 2;

+      RM = 0x0007FFFF;

+      break;

+    case ELF::R_SPARC_WDISP16:

+      RS = 2;

+      break;

+    case ELF::R_SPARC_WDISP10:

+      RS = 2;

+      break;

+    }

+

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    Reloc = (((Value + Addend) - LoadAddress) >> RS);

+    TargetValue = *TargetPtr32;

+

+    switch (Type) {

+    default:

+      llvm_unreachable("Impossible default case!");

+      break;

+    case ELF::R_SPARC_WDISP16:

+      TargetValue &= ~((0x3 << 20) | 0x3FFF);

+      Reloc = (((Reloc & 0xC000) << (7 - 1)) | (Reloc & 0x3FFFF));

+      *TargetPtr32 = TargetValue | Reloc;

+      break;

+    case ELF::R_SPARC_WDISP10:

+      TargetValue &= ~((0x3 << 19) | (0xFF << 5));

+      Reloc = (((Reloc & 0x300) << (13 - 2)) | ((Reloc & 0xFF) | (7 - 2)));

+      *TargetPtr32 = TargetValue | Reloc;

+      break;

+    case ELF::R_SPARC_WDISP30:

+    case ELF::R_SPARC_WDISP22:

+    case ELF::R_SPARC_WDISP19:

+      TargetValue &= ~RM;

+      Reloc &= RM;

+      *TargetPtr32 = TargetValue | Reloc;

+      break;

+    }

+    break;

+  case ELF::R_SPARC_HI22:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 10;

+    RM = 0x003FFFFF;

+    Reloc = (Value + Addend) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_10:

+    Value += Addend;

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    *TargetPtr32 = Value;

+    break;

+  case ELF::R_SPARC_11:

+    Value += Addend;

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    *TargetPtr32 = Value;

+    break;

+  case ELF::R_SPARC_13:

+    Value += Addend;

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    *TargetPtr32 = Value;

+    break;

+  case ELF::R_SPARC_22:

+    Value += Addend;

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    *TargetPtr32 = Value;

+    break;

+  case ELF::R_SPARC_LO10:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 0;

+    RM = 0x000003FF;

+    Reloc = (Value + Addend) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_LM22:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 10;

+    RM = 0x003FFFFF;

+    Reloc = (Value + Addend) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_HIX22:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 10;

+    RM = 0x3FFFFF;

+    Reloc = Value + Addend;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc ^= ~0;

+    Reloc >>= RS;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_LOX10:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    Reloc = Value + Addend;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~0x1FFF;

+    Reloc &= 0x3FF;

+    Reloc |= 0x1C00;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_HH22:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 42;

+    RM = 0x003FFFFF;

+    Reloc = (Value + Addend) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_HM10:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 32;

+    RM = 0x000003FF;

+    Reloc = (Value + Addend) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_H44:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 22;

+    RM = 0x003FFFFF;

+    Reloc = (Value + Addend) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_M44:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 12;

+    RM = 0x000003FF;

+    Reloc = (Value + Addend) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_L44:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 0;

+    RM = 0x00000FFF;

+    Reloc = (Value + Addend) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_GOT10:

+    assert((Offset != static_cast<uint64_t>(-1)) &&

+           "R_SPARC_GOT10: Invalid offset!");

+    if ((Offset & 1) != 0)

+      Offset &= ~1;

+    else

+      Offset |= 1;

+

+    RS = 0;

+    RM = 0x000003FF;

+    Reloc = (Value + Addend) >> RS;

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_GOT13:

+    assert((Offset != static_cast<uint64_t>(-1)) &&

+           "R_SPARC_GOT13: Invalid offset!");

+    if ((Offset & 1) != 0)

+      Offset &= ~1;

+    else

+      Offset |= 1;

+

+    RS = 0;

+    RM = 0x00001FFF;

+    Reloc = (Value + Addend) >> RS;

+

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_GOT22:

+    assert((Offset != static_cast<uint64_t>(-1)) &&

+           "R_SPARC_GOT22: Invalid offset!");

+    if ((Offset & 1) != 0)

+      Offset &= ~1;

+    else

+      Offset |= 1;

+

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 10;

+    RM = 0x003FFFFF;

+    Reloc = (Value + Addend) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_PC10:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 0;

+    RM =0x000003FF;

+    Reloc = ((Value + Addend) - LoadAddress) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_PC22:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 10;

+    RM = 0x003FFFFF;

+    Reloc = ((Value + Addend) - LoadAddress) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_UA16:

+    TargetPtr8 = reinterpret_cast<uint8_t*>(TargetPtr);

+    TargetPtr8[0] = Value >> 8U;

+    TargetPtr8[1] = Value;

+    break;

+  case ELF::R_SPARC_UA32:

+    TargetPtr8 = reinterpret_cast<uint8_t*>(TargetPtr);

+    TargetPtr8[0] = Value >> 24U;

+    TargetPtr8[1] = Value >> 16U;

+    TargetPtr8[2] = Value >> 8U;

+    TargetPtr8[3] = Value;

+    break;

+  case ELF::R_SPARC_WPLT30:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 2;

+    RM = 0x3FFFFFFF;

+    Reloc = ((Value + Addend) - LoadAddress) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    TargetValue = *TargetPtr32;

+    break;

+  }

+}

+

+/// SPARCV9 ELF Relocatinos - valid in 64-bit only.

+/// https://docs.oracle.com/cd/E19683-01/817-3677/chapter6-24-1/index.html

+void RuntimeDyldELF::resolveSPARC64Relocation(const SectionEntry &Section,

+                                              uint64_t Offset, uint64_t Value,

+                                              uint32_t Type, int64_t Addend) {

+  uint64_t *TargetAddress =

+    reinterpret_cast<uint64_t*>(reinterpret_cast<void*>(Section.getAddress()));

+  uint64_t *TargetPtr =

+    reinterpret_cast<uint64_t*>(Section.getAddressWithOffset(Offset));

+  uint32_t Reloc;

+  uintptr_t TargetPtrVal = reinterpret_cast<uintptr_t>(TargetPtr);

+  uint8_t *TargetPtr8 = nullptr;

+  uint16_t *TargetPtr16 = nullptr;

+  uint32_t *TargetPtr32 = nullptr;

+  uint64_t LoadAddress = Section.getLoadAddressWithOffset(Offset);

+  uint64_t TargetValue = 0ULL;

+  int32_t RS;

+  int32_t RM;

+

+  switch (Type) {

+  case ELF::R_SPARC_HI22:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    RS = 10;

+    RM = 0x003FFFFF;

+    Reloc = (Value + Addend) >> RS;

+    TargetValue = *TargetPtr32;

+    TargetValue &= ~RM;

+    Reloc &= RM;

+    *TargetPtr32 = TargetValue | Reloc;

+    break;

+  case ELF::R_SPARC_64:

+  case ELF::R_SPARC_GLOB_DAT:

+    Value += Addend;

+    *TargetPtr = Value;

+    break;

+  case ELF::R_SPARC_RELATIVE:

+    *TargetPtr = LoadAddress + Addend;

+    break;

+  case ELF::R_SPARC_OLO10:

+    TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+    *TargetPtr32 = (*TargetPtr32 & ~0x1FFF) | (((Value + Addend) & 0x3FF) +

+                                               ((Offset >> 8) & 0x1FFF));

+    break;

+  case ELF::R_SPARC_DISP64:

+    Value += Addend;

+    *TargetPtr = (Value - reinterpret_cast<uintptr_t>(TargetPtr));

+    break;

+  case ELF::R_SPARC_REGISTER:

+    Value += Addend;

+    *TargetPtr = Value;

+    break;

+  case ELF::R_SPARC_PLT64:

+    llvm::errs() << __PRETTY_FUNCTION__

+      << ": Warning: Unimplemented R_SPARC_PLT64 Relocation type.\n" ;

+    break;

+  case ELF::R_SPARC_UA64:

+    Value += Addend;

+    if (0 == (TargetPtrVal & 3)) {

+      TargetPtr32 = reinterpret_cast<uint32_t*>(TargetPtr);

+      TargetPtr32[0] = Value >> 32;

+      TargetPtr32[1] = Value;

+    } else {

+      TargetPtr8 = reinterpret_cast<uint8_t*>(TargetPtr);

+      TargetPtr8[0] = Value >> 56;

+      TargetPtr8[0] = Value >> 48;

+      TargetPtr8[0] = Value >> 40;

+      TargetPtr8[0] = Value >> 32;

+      TargetPtr8[0] = Value >> 24;

+      TargetPtr8[0] = Value >> 16;

+      TargetPtr8[0] = Value >> 8;

+      TargetPtr8[0] = Value;

+    }

+    break;

+  default:

+    resolveSPARC3264Relocation(Section, Offset, Value, Type, Addend);

+    break;

+  }

+}

+

 void RuntimeDyldELF::resolveSystemZRelocation(const SectionEntry &Section,

                                               uint64_t Offset, uint64_t Value,

                                               uint32_t Type, int64_t Addend) {

@@ -1123,6 +1565,12 @@

   case Triple::systemz:

     resolveSystemZRelocation(Section, Offset, Value, Type, Addend);

     break;

+  case Triple::sparc:

+    resolveSPARC3264Relocation(Section, Offset, Value, Type, Addend);

+    break;

+  case Triple::sparcv9:

+    resolveSPARC64Relocation(Section, Offset, Value, Type, Addend);

+    break;

   default:

     llvm_unreachable("Unsupported CPU type!");

   }

@@ -1590,6 +2038,160 @@

       else

         addRelocationForSection(RE, Value.SectionID);

     }

+  } else if (Arch == Triple::sparc) {

+    DEBUG(dbgs() << "This is a SPARC32 relocation.\n");