Initial test for a mapper that doesn't make too many bindings

clang/cmake/modules/AddClang.cmake

@@ -169,7 +169,7 @@ macro(add_clang_tool name)
  get_target_export_arg(${name} Clang export_to_clangtargets)
  install(TARGETS ${name}
  ${export_to_clangtargets}
- RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+ RUNTIME DESTINATION "${LLVM_TOOLS_INSTALL_DIR}"
  COMPONENT ${name})
 
  if(NOT LLVM_ENABLE_IDE)

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp

@@ -223,7 +223,7 @@ namespace __sanitizer {
  unsigned struct_sockaddr_sz = sizeof(struct sockaddr);
 
  unsigned ucontext_t_sz(void *ctx) {
-# if SANITIZER_GLIBC && SANITIZER_X64
+# if SANITIZER_GLIBC && SANITIZER_X64 && __GLIBC_PREREQ (2, 27)
  // Added in Linux kernel 3.4.0, merged to glibc in 2.16
 # ifndef FP_XSTATE_MAGIC1
 # define FP_XSTATE_MAGIC1 0x46505853U

compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cpp

@@ -16,6 +16,10 @@
 #include "sanitizer_flags.h"
 #include "sanitizer_platform_interceptors.h"
 
+#if !defined(__APPLE__)
+#include <malloc.h>
+#endif
+
 namespace __sanitizer {
 #if SANITIZER_INTERCEPT_TLS_GET_ADDR
 
@@ -139,6 +143,8 @@ DTLS::DTV *DTLS_on_tls_get_addr(void *arg_void, void *res,
  tls_beg = header->start;
  VReport(2, "__tls_get_addr: glibc >=2.19 suspected; tls={0x%zx 0x%zx}\n",
  tls_beg, tls_size);
+ } else if (uptr size = malloc_usable_size((void *)tls_beg)) {
+ tls_size = size;
  } else {
  VReport(2, "__tls_get_addr: Can't guess glibc version\n");
  // This may happen inside the DTOR of main thread, so just ignore it.

compiler-rt/test/msan/Linux/signal_mcontext.cpp

@@ -10,7 +10,7 @@
 
 void handler(int sig, siginfo_t *info, void *uctx) {
  __msan_check_mem_is_initialized(uctx, sizeof(ucontext_t));
-#if defined(__GLIBC__) && defined(__x86_64__)
+#if defined(__GLIBC__) && defined(__x86_64__) && __GLIBC_PREREQ(2, 27)
  auto *mctx = &static_cast<ucontext_t *>(uctx)->uc_mcontext;
  if (auto *fpregs = mctx->fpregs) {
  // The member names differ across header versions, but the actual layout

libunwind/src/CompactUnwinder.hpp

@@ -311,6 +311,50 @@ int CompactUnwinder_x86_64<A>::stepWithCompactEncodingRBPFrame(
  uint32_t savedRegistersLocations =
  EXTRACT_BITS(compactEncoding, UNWIND_X86_64_RBP_FRAME_REGISTERS);
 
+ // If we have not stored EBP yet
+ if (functionStart == registers.getIP()) {
+ uint64_t rsp = registers.getSP();
+ // old esp is ebp less return address
+ registers.setSP(rsp+8);
+ // pop return address into eip
+ registers.setIP(addressSpace.get64(rsp));
+
+ return UNW_STEP_SUCCESS;
+ } else if (functionStart + 1 == registers.getIP()) {
+ uint64_t rsp = registers.getSP();
+ // old esp is ebp less return address
+ registers.setSP(rsp + 16);
+ // pop return address into eip
+ registers.setIP(addressSpace.get64(rsp + 8));
+
+ return UNW_STEP_SUCCESS;
+ }
+
+ // If we're about to return, we've already popped the base pointer
+ uint8_t b = addressSpace.get8(registers.getIP());
+
+ // This is a hack to detect VZEROUPPER but in between popq rbp and ret
+ // It's not pretty but it works
+ if (b == 0xC5) {
+ if ((b = addressSpace.get8(registers.getIP() + 1)) == 0xF8 &&
+ (b = addressSpace.get8(registers.getIP() + 2)) == 0x77)
+ b = addressSpace.get8(registers.getIP() + 3);
+ else
+ goto skip_ret;
+ }
+
+ if (b == 0xC3 || b == 0xCB || b == 0xC2 || b == 0xCA) {
+ uint64_t rbp = registers.getSP();
+ // old esp is ebp less return address
+ registers.setSP(rbp + 16);
+ // pop return address into eip
+ registers.setIP(addressSpace.get64(rbp + 8));
+
+ return UNW_STEP_SUCCESS;
+ }
+
+ skip_ret:
+
  uint64_t savedRegisters = registers.getRBP() - 8 * savedRegistersOffset;
  for (int i = 0; i < 5; ++i) {
  switch (savedRegistersLocations & 0x7) {
@@ -431,6 +475,118 @@ int CompactUnwinder_x86_64<A>::stepWithCompactEncodingFrameless(
  }
  }
  }
+
+ // Note that the order of these registers is so that
+ // registersSaved[0] is the one that will be pushed onto the stack last.
+ // Thus, if we want to walk this from the top, we need to go in reverse.
+ assert(regCount <= 6);
+
+ // check whether we are still in the prologue
+ uint64_t curAddr = functionStart;
+ if (regCount > 0) {
+ for (int8_t i = (int8_t)(regCount) - 1; i >= 0; --i) {
+ if (registers.getIP() == curAddr) {
+ // None of the registers have been modified yet, so we don't need to reload them
+ framelessUnwind(addressSpace, registers.getSP() + 8 * (regCount - (uint64_t)(i + 1)), registers);
+ return UNW_STEP_SUCCESS;
+ } else {
+ assert(curAddr < registers.getIP());
+ }
+
+
+ // pushq %rbp and pushq %rbx is 1 byte. Everything else 2
+ if ((UNWIND_X86_64_REG_RBP == registersSaved[i]) ||
+ (UNWIND_X86_64_REG_RBX == registersSaved[i]))
+ curAddr += 1;
+ else
+ curAddr += 2;
+ }
+ }
+ if (registers.getIP() == curAddr) {
+ // None of the registers have been modified yet, so we don't need to reload them
+ framelessUnwind(addressSpace, registers.getSP() + 8*regCount, registers);
+ return UNW_STEP_SUCCESS;
+ } else {
+ assert(curAddr < registers.getIP());
+ }
+
+
+ // And now for the epilogue
+ {
+ uint8_t i = 0;
+ uint64_t p = registers.getIP();
+ uint8_t b = 0;
+
+ while (true) {
+ b = addressSpace.get8(p++);
+ // This is a hack to detect VZEROUPPER but in between the popq's and ret
+ // It's not pretty but it works
+ if (b == 0xC5) {
+ if ((b = addressSpace.get8(p++)) == 0xF8 && (b = addressSpace.get8(p++)) == 0x77)
+ b = addressSpace.get8(p++);
+ else
+ break;
+ }
+ // popq %rbx popq %rbp
+ if (b == 0x5B || b == 0x5D) {
+ i++;
+ } else if (b == 0x41) {
+ b = addressSpace.get8(p++);
+ if (b == 0x5C || b == 0x5D || b == 0x5E || b == 0x5F)
+ i++;
+ else
+ break;
+ } else if (b == 0xC3 || b == 0xCB || b == 0xC2 || b == 0xCA) {
+ // i pop's haven't happened yet
+ uint64_t savedRegisters = registers.getSP() + 8 * i;
+ if (regCount > 0) {
+ for (int8_t j = (int8_t)(regCount) - 1; j >= (int8_t)(regCount) - i; --j) {
+ uint64_t addr = savedRegisters - 8 * (regCount - (uint64_t)(j));
+ switch (registersSaved[j]) {
+ case UNWIND_X86_64_REG_RBX:
+ registers.setRBX(addressSpace.get64(addr));
+ break;
+ case UNWIND_X86_64_REG_R12:
+ registers.setR12(addressSpace.get64(addr));
+ break;
+ case UNWIND_X86_64_REG_R13:
+ registers.setR13(addressSpace.get64(addr));
+ break;
+ case UNWIND_X86_64_REG_R14:
+ registers.setR14(addressSpace.get64(addr));
+ break;
+ case UNWIND_X86_64_REG_R15:
+ registers.setR15(addressSpace.get64(addr));
+ break;
+ case UNWIND_X86_64_REG_RBP:
+ registers.setRBP(addressSpace.get64(addr));
+ break;
+ default:
+ _LIBUNWIND_DEBUG_LOG("bad register for frameless, encoding=%08X for "
+ "function starting at 0x%llX",
+ encoding, functionStart);
+ _LIBUNWIND_ABORT("invalid compact unwind encoding");
+ }
+ }
+ }
+ framelessUnwind(addressSpace, savedRegisters, registers);
+ return UNW_STEP_SUCCESS;
+ } else {
+ break;
+ }
+ }
+ }
+
+ /*
+ 0x10fe2733a: 5b popq %rbx
+ 0x10fe2733b: 41 5c popq %r12
+ 0x10fe2733d: 41 5d popq %r13
+ 0x10fe2733f: 41 5e popq %r14
+ 0x10fe27341: 41 5f popq %r15
+ 0x10fe27343: 5d popq %rbp
+ */
+
+
  uint64_t savedRegisters = registers.getSP() + stackSize - 8 - 8 * regCount;
  for (uint32_t i = 0; i < regCount; ++i) {
  switch (registersSaved[i]) {

lld/cmake/modules/AddLLD.cmake

@@ -20,7 +20,7 @@ macro(add_lld_library name)
  ${export_to_lldtargets}
  LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
  ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}
- RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+ RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR})
 
  if (${ARG_SHARED} AND NOT CMAKE_CONFIGURATION_TYPES)
  add_llvm_install_targets(install-${name}
@@ -47,7 +47,7 @@ macro(add_lld_tool name)
  get_target_export_arg(${name} LLD export_to_lldtargets)
  install(TARGETS ${name}
  ${export_to_lldtargets}
- RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+ RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR}
  COMPONENT ${name})
 
  if(NOT CMAKE_CONFIGURATION_TYPES)

llvm/include/llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h

@@ -241,10 +241,16 @@ class BasicLayout {
  struct ContiguousPageBasedLayoutSizes {
  uint64_t StandardSegs = 0;
  uint64_t FinalizeSegs = 0;
-
  uint64_t total() const { return StandardSegs + FinalizeSegs; }
  };
 
+ struct SplitPageBasedLayoutSizes {
+ uint64_t TextSegs = 0;
+ uint64_t DataSegs = 0;
+ uint64_t FinalizeSegs = 0;
+ uint64_t total() const { return TextSegs + DataSegs + FinalizeSegs; }
+ };
+
 private:
  using SegmentMap = orc::AllocGroupSmallMap<Segment>;
 
@@ -266,6 +272,9 @@ class BasicLayout {
  Expected<ContiguousPageBasedLayoutSizes>
  getContiguousPageBasedLayoutSizes(uint64_t PageSize);
 
+ // Same as above but returns the segments split into text, data, and finalize
+ Expected<SplitPageBasedLayoutSizes>
+ getSplitPageBasedLayoutSizes(uint64_t PageSize);
  /// Returns an iterator over the segments of the layout.
  iterator_range<SegmentMap::iterator> segments() {
  return {Segments.begin(), Segments.end()};

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

@@ -25219,6 +25219,7 @@ bool DAGCombiner::SimplifySelectOps(SDNode *TheSelect, SDValue LHS,
  !TLI.isOperationLegalOrCustom(TheSelect->getOpcode(),
  LLD->getBasePtr().getValueType()))
  return false;
+ return false;
 
  // The loads must not depend on one another.
  if (LLD->isPredecessorOf(RLD) || RLD->isPredecessorOf(LLD))

llvm/lib/ExecutionEngine/JITLink/JITLinkMemoryManager.cpp

@@ -98,6 +98,31 @@ BasicLayout::getContiguousPageBasedLayoutSizes(uint64_t PageSize) {
  return SegsSizes;
 }
 
+Expected<BasicLayout::SplitPageBasedLayoutSizes>
+BasicLayout::getSplitPageBasedLayoutSizes(uint64_t PageSize) {
+ SplitPageBasedLayoutSizes SegsSizes;
+
+ for (auto &KV : segments()) {
+ auto &AG = KV.first;
+ auto &Seg = KV.second;
+
+ if (Seg.Alignment > PageSize)
+ return make_error<StringError>("Segment alignment greater than page size",
+ inconvertibleErrorCode());
+
+ uint64_t SegSize = alignTo(Seg.ContentSize + Seg.ZeroFillSize, PageSize);
+ if (AG.getMemDeallocPolicy() == orc::MemDeallocPolicy::Standard)
+ if ((AG.getMemProt() & orc::MemProt::Exec) != orc::MemProt::None) // Text
+ SegsSizes.TextSegs += SegSize;
+ else // Data
+ SegsSizes.DataSegs += SegSize;
+ else
+ SegsSizes.FinalizeSegs += SegSize;
+ }
+
+ return SegsSizes;
+}
+
 Error BasicLayout::apply() {
  for (auto &KV : Segments) {
  auto &Seg = KV.second;

llvm/lib/ExecutionEngine/Orc/MapperJITLinkMemoryManager.cpp

@@ -64,52 +64,69 @@ void MapperJITLinkMemoryManager::allocate(const JITLinkDylib *JD, LinkGraph &G,
  BasicLayout BL(G);
 
  // find required address space
- auto SegsSizes = BL.getContiguousPageBasedLayoutSizes(Mapper->getPageSize());
+ auto SegsSizes = BL.getSplitPageBasedLayoutSizes(Mapper->getPageSize());
+
  if (!SegsSizes) {
  OnAllocated(SegsSizes.takeError());
  return;
  }
 
  auto TotalSize = SegsSizes->total();
 
- auto CompleteAllocation = [this, &G, BL = std::move(BL),
+ auto CompleteAllocation = [this, &SegsSizes, &G, BL = std::move(BL),
  OnAllocated = std::move(OnAllocated)](
  Expected<ExecutorAddrRange> Result) mutable {
  if (!Result) {
  Mutex.unlock();
  return OnAllocated(Result.takeError());
  }
 
- auto NextSegAddr = Result->Start;
 
+ auto DataSegAddr = Result->Start;
+ ExecutorAddr TextSegAddr(alignDown(Result->End.getValue() - SegsSizes->TextSegs, Mapper->getPageSize()));
+ auto FinalizeSegAddr = Result->Start + alignTo(SegsSizes->DataSegs,Mapper->getPageSize());
+ auto FinalizeSegAddrInit = FinalizeSegAddr;
+ auto TextSegAddrInit = TextSegAddr;
+ assert((FinalizeSegAddr + SegsSizes->FinalizeSegs) < (TextSegAddr, Mapper->getPageSize()) && "Not enough memory in the slab");
  std::vector<MemoryMapper::AllocInfo::SegInfo> SegInfos;
 
  for (auto &KV : BL.segments()) {
  auto &AG = KV.first;
  auto &Seg = KV.second;
-
  auto TotalSize = Seg.ContentSize + Seg.ZeroFillSize;
 
- Seg.Addr = NextSegAddr;
- Seg.WorkingMem = Mapper->prepare(NextSegAddr, TotalSize);
+ ExecutorAddr *CurrAddr;
+ if (AG.getMemDeallocPolicy() == orc::MemDeallocPolicy::Standard) {
+ if ((AG.getMemProt() & orc::MemProt::Exec) != orc::MemProt::None) {
+ CurrAddr = &TextSegAddr;
+ } else {
+ CurrAddr = &DataSegAddr;
+ }
+ } else {
+ CurrAddr = &FinalizeSegAddr;
+ }
 
- NextSegAddr += alignTo(TotalSize, Mapper->getPageSize());
+ Seg.Addr = *CurrAddr;
+ Seg.WorkingMem = Mapper->prepare(*CurrAddr, TotalSize);
+ *CurrAddr += alignTo(TotalSize, Mapper->getPageSize());
 
  MemoryMapper::AllocInfo::SegInfo SI;
  SI.Offset = Seg.Addr - Result->Start;
  SI.ContentSize = Seg.ContentSize;
  SI.ZeroFillSize = Seg.ZeroFillSize;
  SI.AG = AG;
  SI.WorkingMem = Seg.WorkingMem;
-
  SegInfos.push_back(SI);
  }
+ assert(DataSegAddr < FinalizeSegAddrInit && "Data overwrote the finalize segment");
+ assert(FinalizeSegAddr < TextSegAddrInit && "Finalize overwrote the text segment");
+ assert(TextSegAddr < Result->End && "Text overwrote the end of the slab");
 
- UsedMemory.insert({Result->Start, NextSegAddr - Result->Start});
-
- if (NextSegAddr < Result->End) {
+ UsedMemory.insert({Result->Start, FinalizeSegAddr - Result->Start});
+ UsedMemory.insert({TextSegAddrInit, Result->End - TextSegAddrInit});
+ if (FinalizeSegAddr < TextSegAddrInit) {
  // Save the remaining memory for reuse in next allocation(s)
- AvailableMemory.insert(NextSegAddr, Result->End - 1, true);
+ AvailableMemory.insert(FinalizeSegAddr, TextSegAddrInit - 1, true);
  }
  Mutex.unlock();
 

llvm/lib/MC/MCObjectFileInfo.cpp

@@ -61,9 +61,10 @@ void MCObjectFileInfo::initMachOMCObjectFileInfo(const Triple &T) {
  MachO::S_ATTR_STRIP_STATIC_SYMS | MachO::S_ATTR_LIVE_SUPPORT,
  SectionKind::getReadOnly());
 
- if (T.isOSDarwin() &&
- (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32))
- SupportsCompactUnwindWithoutEHFrame = true;
+ // Disabled for now, since we need to emit EH Frames for stack unwinding in the JIT
+ // if (T.isOSDarwin() &&
+ // (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32))
+ // SupportsCompactUnwindWithoutEHFrame = true;
 
  switch (Ctx->emitDwarfUnwindInfo()) {
  case EmitDwarfUnwindType::Always: