lib/Support/Unix/Memory.inc

   1 //===- Unix/Memory.cpp - Generic UNIX System Configuration ------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines some functions for various memory management utilities.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "Unix.h"
  14 #include "llvm/Config/config.h"
  15 #include "llvm/Support/DataTypes.h"
  16 #include "llvm/Support/ErrorHandling.h"
  17 #include "llvm/Support/Process.h"
  18
  19 #ifdef HAVE_SYS_MMAN_H
  20 #include <sys/mman.h>
  21 #endif
  22
  23 #ifdef __APPLE__
  24 #include <mach/mach.h>
  25 #endif
  26
  27 #ifdef __Fuchsia__
  28 #include <zircon/syscalls.h>
  29 #endif
  30
  31 #if defined(__mips__)
  32 #  if defined(__OpenBSD__)
  33 #    include <mips64/sysarch.h>
  34 #  elif !defined(__FreeBSD__)
  35 #    include <sys/cachectl.h>
  36 #  endif
  37 #endif
  38
  39 #if defined(__APPLE__)
  40 extern "C" void sys_icache_invalidate(const void *Addr, size_t len);
  41 #else
  42 extern "C" void __clear_cache(void *, void*);
  43 #endif
  44
  45 namespace {
  46
  47 int getPosixProtectionFlags(unsigned Flags) {
  48   switch (Flags) {
  49   case llvm::sys::Memory::MF_READ:
  50     return PROT_READ;
  51   case llvm::sys::Memory::MF_WRITE:
  52     return PROT_WRITE;
  53   case llvm::sys::Memory::MF_READ|llvm::sys::Memory::MF_WRITE:
  54     return PROT_READ | PROT_WRITE;
  55   case llvm::sys::Memory::MF_READ|llvm::sys::Memory::MF_EXEC:
  56     return PROT_READ | PROT_EXEC;
  57   case llvm::sys::Memory::MF_READ | llvm::sys::Memory::MF_WRITE |
  58       llvm::sys::Memory::MF_EXEC:
  59     return PROT_READ | PROT_WRITE | PROT_EXEC;
  60   case llvm::sys::Memory::MF_EXEC:
  61 #if defined(__FreeBSD__)
  62     // On PowerPC, having an executable page that has no read permission
  63     // can have unintended consequences.  The function InvalidateInstruction-
  64     // Cache uses instructions dcbf and icbi, both of which are treated by
  65     // the processor as loads.  If the page has no read permissions,
  66     // executing these instructions will result in a segmentation fault.
  67     // Somehow, this problem is not present on Linux, but it does happen
  68     // on FreeBSD.
  69     return PROT_READ | PROT_EXEC;
  70 #else
  71     return PROT_EXEC;
  72 #endif
  73   default:
  74     llvm_unreachable("Illegal memory protection flag specified!");
  75   }
  76   // Provide a default return value as required by some compilers.
  77   return PROT_NONE;
  78 }
  79
  80 } // anonymous namespace
  81
  82 namespace llvm {
  83 namespace sys {
  84
  85 MemoryBlock
  86 Memory::allocateMappedMemory(size_t NumBytes,
  87                              const MemoryBlock *const NearBlock,
  88                              unsigned PFlags,
  89                              std::error_code &EC) {
  90   EC = std::error_code();
  91   if (NumBytes == 0)
  92     return MemoryBlock();
  93
  94   int fd = -1;
  95
  96   int MMFlags = MAP_PRIVATE |
  97 #ifdef MAP_ANONYMOUS
  98   MAP_ANONYMOUS
  99 #else
 100   MAP_ANON
 101 #endif
 102   ; // Ends statement above
 103
 104   int Protect = getPosixProtectionFlags(PFlags);
 105
 106 #if defined(__NetBSD__) && defined(PROT_MPROTECT)
 107   Protect |= PROT_MPROTECT(PROT_READ | PROT_WRITE | PROT_EXEC);
 108 #endif
 109
 110   // Use any near hint and the page size to set a page-aligned starting address
 111   uintptr_t Start = NearBlock ? reinterpret_cast<uintptr_t>(NearBlock->base()) +
 112                                       NearBlock->size() : 0;
 113   static const size_t PageSize = Process::getPageSize();
 114   if (Start && Start % PageSize)
 115     Start += PageSize - Start % PageSize;
 116
 117   void *Addr = ::mmap(reinterpret_cast<void *>(Start), NumBytes, Protect,
 118                       MMFlags, fd, 0);
 119   if (Addr == MAP_FAILED) {
 120     if (NearBlock) //Try again without a near hint
 121       return allocateMappedMemory(NumBytes, nullptr, PFlags, EC);
 122
 123     EC = std::error_code(errno, std::generic_category());
 124     return MemoryBlock();
 125   }
 126
 127   MemoryBlock Result;
 128   Result.Address = Addr;
 129   Result.Size = NumBytes;
 130
 131   // Rely on protectMappedMemory to invalidate instruction cache.
 132   if (PFlags & MF_EXEC) {
 133     EC = Memory::protectMappedMemory (Result, PFlags);
 134     if (EC != std::error_code())
 135       return MemoryBlock();
 136   }
 137
 138   return Result;
 139 }
 140
 141 std::error_code
 142 Memory::releaseMappedMemory(MemoryBlock &M) {
 143   if (M.Address == nullptr || M.Size == 0)
 144     return std::error_code();
 145
 146   if (0 != ::munmap(M.Address, M.Size))
 147     return std::error_code(errno, std::generic_category());
 148
 149   M.Address = nullptr;
 150   M.Size = 0;
 151
 152   return std::error_code();
 153 }
 154
 155 std::error_code
 156 Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
 157   static const size_t PageSize = Process::getPageSize();
 158   if (M.Address == nullptr || M.Size == 0)
 159     return std::error_code();
 160
 161   if (!Flags)
 162     return std::error_code(EINVAL, std::generic_category());
 163
 164   int Protect = getPosixProtectionFlags(Flags);
 165   uintptr_t Start = alignAddr((uint8_t *)M.Address - PageSize + 1, PageSize);
 166   uintptr_t End = alignAddr((uint8_t *)M.Address + M.Size, PageSize);
 167
 168   bool InvalidateCache = (Flags & MF_EXEC);
 169
 170 #if defined(__arm__) || defined(__aarch64__)
 171   // Certain ARM implementations treat icache clear instruction as a memory read,
 172   // and CPU segfaults on trying to clear cache on !PROT_READ page.  Therefore we need
 173   // to temporarily add PROT_READ for the sake of flushing the instruction caches.
 174   if (InvalidateCache && !(Protect & PROT_READ)) {
 175     int Result = ::mprotect((void *)Start, End - Start, Protect | PROT_READ);
 176     if (Result != 0)
 177       return std::error_code(errno, std::generic_category());
 178
 179     Memory::InvalidateInstructionCache(M.Address, M.Size);
 180     InvalidateCache = false;
 181   }
 182 #endif
 183
 184   int Result = ::mprotect((void *)Start, End - Start, Protect);
 185
 186   if (Result != 0)
 187     return std::error_code(errno, std::generic_category());
 188
 189   if (InvalidateCache)
 190     Memory::InvalidateInstructionCache(M.Address, M.Size);
 191
 192   return std::error_code();
 193 }
 194
 195 /// InvalidateInstructionCache - Before the JIT can run a block of code
 196 /// that has been emitted it must invalidate the instruction cache on some
 197 /// platforms.
 198 void Memory::InvalidateInstructionCache(const void *Addr,
 199                                         size_t Len) {
 200
 201 // icache invalidation for PPC and ARM.
 202 #if defined(__APPLE__)
 203
 204 #  if (defined(__POWERPC__) || defined (__ppc__) || \
 205        defined(_POWER) || defined(_ARCH_PPC) || defined(__arm__) || \
 206        defined(__arm64__))
 207   sys_icache_invalidate(const_cast<void *>(Addr), Len);
 208 #  endif
 209
 210 #elif defined(__Fuchsia__)
 211
 212   zx_status_t Status = zx_cache_flush(Addr, Len, ZX_CACHE_FLUSH_INSN);
 213   assert(Status == ZX_OK && "cannot invalidate instruction cache");
 214
 215 #else
 216
 217 #  if (defined(__POWERPC__) || defined (__ppc__) || \
 218        defined(_POWER) || defined(_ARCH_PPC)) && defined(__GNUC__)
 219   const size_t LineSize = 32;
 220
 221   const intptr_t Mask = ~(LineSize - 1);
 222   const intptr_t StartLine = ((intptr_t) Addr) & Mask;
 223   const intptr_t EndLine = ((intptr_t) Addr + Len + LineSize - 1) & Mask;
 224
 225   for (intptr_t Line = StartLine; Line < EndLine; Line += LineSize)
 226     asm volatile("dcbf 0, %0" : : "r"(Line));
 227   asm volatile("sync");
 228
 229   for (intptr_t Line = StartLine; Line < EndLine; Line += LineSize)
 230     asm volatile("icbi 0, %0" : : "r"(Line));
 231   asm volatile("isync");
 232 #  elif (defined(__arm__) || defined(__aarch64__) || defined(__mips__)) && \
 233         defined(__GNUC__)
 234   // FIXME: Can we safely always call this for __GNUC__ everywhere?
 235   const char *Start = static_cast<const char *>(Addr);
 236   const char *End = Start + Len;
 237   __clear_cache(const_cast<char *>(Start), const_cast<char *>(End));
 238 #  endif
 239
 240 #endif  // end apple
 241
 242   ValgrindDiscardTranslations(Addr, Len);
 243 }
 244
 245 } // namespace sys
 246 } // namespace llvm