Remove LLVM 8.0.1 files.

1 files changed, 0 insertions, 164 deletions

diff --git a/gnu/llvm/lib/Support/Windows/Memory.inc b/gnu/llvm/lib/Support/Windows/Memory.inc
deleted file mode 100644
index 318e65aaa9e..00000000000
--- a/gnu/llvm/lib/Support/Windows/Memory.inc
+++ /dev/null
@@ -1,164 +0,0 @@
-//===- Win32/Memory.cpp - Win32 Memory Implementation -----------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides the Win32 specific implementation of various Memory
-// management utilities
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Support/DataTypes.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/Process.h"
-#include "llvm/Support/WindowsError.h"
-
-// The Windows.h header must be the last one included.
-#include "WindowsSupport.h"
-
-namespace {
-
-DWORD getWindowsProtectionFlags(unsigned Flags) {
-  switch (Flags) {
-  // Contrary to what you might expect, the Windows page protection flags
-  // are not a bitwise combination of RWX values
-  case llvm::sys::Memory::MF_READ:
-    return PAGE_READONLY;
-  case llvm::sys::Memory::MF_WRITE:
-    // Note: PAGE_WRITE is not supported by VirtualProtect
-    return PAGE_READWRITE;
-  case llvm::sys::Memory::MF_READ|llvm::sys::Memory::MF_WRITE:
-    return PAGE_READWRITE;
-  case llvm::sys::Memory::MF_READ|llvm::sys::Memory::MF_EXEC:
-    return PAGE_EXECUTE_READ;
-  case llvm::sys::Memory::MF_READ |
-         llvm::sys::Memory::MF_WRITE |
-         llvm::sys::Memory::MF_EXEC:
-    return PAGE_EXECUTE_READWRITE;
-  case llvm::sys::Memory::MF_EXEC:
-    return PAGE_EXECUTE;
-  default:
-    llvm_unreachable("Illegal memory protection flag specified!");
-  }
-  // Provide a default return value as required by some compilers.
-  return PAGE_NOACCESS;
-}
-
-size_t getAllocationGranularity() {
-  SYSTEM_INFO  Info;
-  ::GetSystemInfo(&Info);
-  if (Info.dwPageSize > Info.dwAllocationGranularity)
-    return Info.dwPageSize;
-  else
-    return Info.dwAllocationGranularity;
-}
-
-} // namespace
-
-namespace llvm {
-namespace sys {
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only Win32 specific code
-//===          and must not be UNIX code
-//===----------------------------------------------------------------------===//
-
-MemoryBlock Memory::allocateMappedMemory(size_t NumBytes,
-                                         const MemoryBlock *const NearBlock,
-                                         unsigned Flags,
-                                         std::error_code &EC) {
-  EC = std::error_code();
-  if (NumBytes == 0)
-    return MemoryBlock();
-
-  // While we'd be happy to allocate single pages, the Windows allocation
-  // granularity may be larger than a single page (in practice, it is 64K)
-  // so mapping less than that will create an unreachable fragment of memory.
-  // Avoid using one-time initialization of static locals here, since they
-  // aren't thread safe with MSVC.
-  static volatile size_t GranularityCached;
-  size_t Granularity = GranularityCached;
-  if (Granularity == 0) {
-    Granularity = getAllocationGranularity();
-    GranularityCached = Granularity;
-  }
-
-  const size_t NumBlocks = (NumBytes+Granularity-1)/Granularity;
-
-  uintptr_t Start = NearBlock ? reinterpret_cast<uintptr_t>(NearBlock->base()) +
-                                NearBlock->size()
-                           : 0;
-
-  // If the requested address is not aligned to the allocation granularity,
-  // round up to get beyond NearBlock. VirtualAlloc would have rounded down.
-  if (Start && Start % Granularity != 0)
-    Start += Granularity - Start % Granularity;
-
-  DWORD Protect = getWindowsProtectionFlags(Flags);
-
-  void *PA = ::VirtualAlloc(reinterpret_cast<void*>(Start),
-                            NumBlocks*Granularity,
-                            MEM_RESERVE | MEM_COMMIT, Protect);
-  if (PA == NULL) {
-    if (NearBlock) {
-      // Try again without the NearBlock hint
-      return allocateMappedMemory(NumBytes, NULL, Flags, EC);
-    }
-    EC = mapWindowsError(::GetLastError());
-    return MemoryBlock();
-  }
-
-  MemoryBlock Result;
-  Result.Address = PA;
-  Result.Size = NumBlocks*Granularity;
-
-  if (Flags & MF_EXEC)
-    Memory::InvalidateInstructionCache(Result.Address, Result.Size);
-
-  return Result;
-}
-
-  std::error_code Memory::releaseMappedMemory(MemoryBlock &M) {
-  if (M.Address == 0 || M.Size == 0)
-    return std::error_code();
-
-  if (!VirtualFree(M.Address, 0, MEM_RELEASE))
-    return mapWindowsError(::GetLastError());
-
-  M.Address = 0;
-  M.Size = 0;
-
-  return std::error_code();
-}
-
-  std::error_code Memory::protectMappedMemory(const MemoryBlock &M,
-                                       unsigned Flags) {
-  if (M.Address == 0 || M.Size == 0)
-    return std::error_code();
-
-  DWORD Protect = getWindowsProtectionFlags(Flags);
-
-  DWORD OldFlags;
-  if (!VirtualProtect(M.Address, M.Size, Protect, &OldFlags))
-    return mapWindowsError(::GetLastError());
-
-  if (Flags & MF_EXEC)
-    Memory::InvalidateInstructionCache(M.Address, M.Size);
-
-  return std::error_code();
-}
-
-/// InvalidateInstructionCache - Before the JIT can run a block of code
-/// that has been emitted it must invalidate the instruction cache on some
-/// platforms.
-void Memory::InvalidateInstructionCache(
-    const void *Addr, size_t Len) {
-  FlushInstructionCache(GetCurrentProcess(), Addr, Len);
-}
-
-} // namespace sys
-} // namespace llvm