Import LLVM 10.0.0 release including clang, lld and lldb.

ok hackroom
tested by plenty

1 files changed, 296 insertions, 0 deletions

diff --git a/gnu/llvm/lldb/tools/debugserver/source/MacOSX/MachVMMemory.cpp b/gnu/llvm/lldb/tools/debugserver/source/MacOSX/MachVMMemory.cpp
new file mode 100644
index 00000000000..2b039c7b16c
--- /dev/null
+++ b/gnu/llvm/lldb/tools/debugserver/source/MacOSX/MachVMMemory.cpp
@@ -0,0 +1,296 @@
+//===-- MachVMMemory.cpp ----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  Created by Greg Clayton on 6/26/07.
+//
+//===----------------------------------------------------------------------===//
+
+#include "MachVMMemory.h"
+#include "DNBLog.h"
+#include "MachVMRegion.h"
+#include <dlfcn.h>
+#include <mach/mach_vm.h>
+#include <mach/shared_region.h>
+#include <sys/sysctl.h>
+
+#if defined(WITH_FBS) || defined(WITH_BKS)
+extern "C" {
+#import <System/sys/kern_memorystatus.h>
+}
+#endif
+
+static const vm_size_t kInvalidPageSize = ~0;
+
+MachVMMemory::MachVMMemory() : m_page_size(kInvalidPageSize), m_err(0) {}
+
+MachVMMemory::~MachVMMemory() {}
+
+nub_size_t MachVMMemory::PageSize(task_t task) {
+  if (m_page_size == kInvalidPageSize) {
+#if defined(TASK_VM_INFO) && TASK_VM_INFO >= 22
+    if (task != TASK_NULL) {
+      kern_return_t kr;
+      mach_msg_type_number_t info_count = TASK_VM_INFO_COUNT;
+      task_vm_info_data_t vm_info;
+      kr = task_info(task, TASK_VM_INFO, (task_info_t)&vm_info, &info_count);
+      if (kr == KERN_SUCCESS) {
+        DNBLogThreadedIf(
+            LOG_TASK,
+            "MachVMMemory::PageSize task_info returned page size of 0x%x",
+            (int)vm_info.page_size);
+        m_page_size = vm_info.page_size;
+        return m_page_size;
+      } else {
+        DNBLogThreadedIf(LOG_TASK, "MachVMMemory::PageSize task_info call "
+                                   "failed to get page size, TASK_VM_INFO %d, "
+                                   "TASK_VM_INFO_COUNT %d, kern return %d",
+                         TASK_VM_INFO, TASK_VM_INFO_COUNT, kr);
+      }
+    }
+#endif
+    m_err = ::host_page_size(::mach_host_self(), &m_page_size);
+    if (m_err.Fail())
+      m_page_size = 0;
+  }
+  return m_page_size;
+}
+
+nub_size_t MachVMMemory::MaxBytesLeftInPage(task_t task, nub_addr_t addr,
+                                            nub_size_t count) {
+  const nub_size_t page_size = PageSize(task);
+  if (page_size > 0) {
+    nub_size_t page_offset = (addr % page_size);
+    nub_size_t bytes_left_in_page = page_size - page_offset;
+    if (count > bytes_left_in_page)
+      count = bytes_left_in_page;
+  }
+  return count;
+}
+
+nub_bool_t MachVMMemory::GetMemoryRegionInfo(task_t task, nub_addr_t address,
+                                             DNBRegionInfo *region_info) {
+  MachVMRegion vmRegion(task);
+
+  if (vmRegion.GetRegionForAddress(address)) {
+    region_info->addr = vmRegion.StartAddress();
+    region_info->size = vmRegion.GetByteSize();
+    region_info->permissions = vmRegion.GetDNBPermissions();
+  } else {
+    region_info->addr = address;
+    region_info->size = 0;
+    if (vmRegion.GetError().Success()) {
+      // vmRegion.GetRegionForAddress() return false, indicating that "address"
+      // wasn't in a valid region, but the "vmRegion" info was successfully
+      // read from the task which means the info describes the next valid
+      // region from which we can infer the size of this invalid region
+      mach_vm_address_t start_addr = vmRegion.StartAddress();
+      if (address < start_addr)
+        region_info->size = start_addr - address;
+    }
+    // If we can't get any info about the size from the next region it means
+    // we asked about an address that was past all mappings, so the size
+    // of this region will take up all remaining address space.
+    if (region_info->size == 0)
+      region_info->size = INVALID_NUB_ADDRESS - region_info->addr;
+
+    // Not readable, writeable or executable
+    region_info->permissions = 0;
+  }
+  return true;
+}
+
+static uint64_t GetPhysicalMemory() {
+  // This doesn't change often at all. No need to poll each time.
+  static uint64_t physical_memory = 0;
+  static bool calculated = false;
+  if (calculated)
+    return physical_memory;
+
+  size_t len = sizeof(physical_memory);
+  sysctlbyname("hw.memsize", &physical_memory, &len, NULL, 0);
+
+  calculated = true;
+  return physical_memory;
+}
+
+nub_bool_t MachVMMemory::GetMemoryProfile(
+    DNBProfileDataScanType scanType, task_t task, struct task_basic_info ti,
+    cpu_type_t cputype, nub_process_t pid, vm_statistics64_data_t &vminfo,
+    uint64_t &physical_memory, uint64_t &anonymous,
+    uint64_t &phys_footprint, uint64_t &memory_cap)
+{
+  if (scanType & eProfileHostMemory)
+    physical_memory = GetPhysicalMemory();
+
+  if (scanType & eProfileMemory) {
+    static mach_port_t localHost = mach_host_self();
+    mach_msg_type_number_t count = HOST_VM_INFO64_COUNT;
+    host_statistics64(localHost, HOST_VM_INFO64, (host_info64_t)&vminfo,
+                      &count);
+    
+    kern_return_t kr;
+    mach_msg_type_number_t info_count;
+    task_vm_info_data_t vm_info;
+
+    info_count = TASK_VM_INFO_COUNT;
+    kr = task_info(task, TASK_VM_INFO_PURGEABLE, (task_info_t)&vm_info, &info_count);
+    if (kr == KERN_SUCCESS) {
+      if (scanType & eProfileMemoryAnonymous) {
+        anonymous = vm_info.internal + vm_info.compressed - vm_info.purgeable_volatile_pmap;
+      }
+
+      phys_footprint = vm_info.phys_footprint;
+    }
+  }
+
+#if defined(WITH_FBS) || defined(WITH_BKS)
+  if (scanType & eProfileMemoryCap) {
+    memorystatus_memlimit_properties_t memlimit_properties;
+    memset(&memlimit_properties, 0, sizeof(memlimit_properties));
+    if (memorystatus_control(MEMORYSTATUS_CMD_GET_MEMLIMIT_PROPERTIES, pid, 0, &memlimit_properties, sizeof(memlimit_properties)) == 0) {
+        memory_cap = memlimit_properties.memlimit_active;
+    }
+  }
+#endif
+
+  return true;
+}
+
+nub_size_t MachVMMemory::Read(task_t task, nub_addr_t address, void *data,
+                              nub_size_t data_count) {
+  if (data == NULL || data_count == 0)
+    return 0;
+
+  nub_size_t total_bytes_read = 0;
+  nub_addr_t curr_addr = address;
+  uint8_t *curr_data = (uint8_t *)data;
+  while (total_bytes_read < data_count) {
+    mach_vm_size_t curr_size =
+        MaxBytesLeftInPage(task, curr_addr, data_count - total_bytes_read);
+    mach_msg_type_number_t curr_bytes_read = 0;
+    vm_offset_t vm_memory = 0;
+    m_err = ::mach_vm_read(task, curr_addr, curr_size, &vm_memory,
+                           &curr_bytes_read);
+
+    if (DNBLogCheckLogBit(LOG_MEMORY))
+      m_err.LogThreaded("::mach_vm_read ( task = 0x%4.4x, addr = 0x%8.8llx, "
+                        "size = %llu, data => %8.8p, dataCnt => %i )",
+                        task, (uint64_t)curr_addr, (uint64_t)curr_size,
+                        vm_memory, curr_bytes_read);
+
+    if (m_err.Success()) {
+      if (curr_bytes_read != curr_size) {
+        if (DNBLogCheckLogBit(LOG_MEMORY))
+          m_err.LogThreaded(
+              "::mach_vm_read ( task = 0x%4.4x, addr = 0x%8.8llx, size = %llu, "
+              "data => %8.8p, dataCnt=>%i ) only read %u of %llu bytes",
+              task, (uint64_t)curr_addr, (uint64_t)curr_size, vm_memory,
+              curr_bytes_read, curr_bytes_read, (uint64_t)curr_size);
+      }
+      ::memcpy(curr_data, (void *)vm_memory, curr_bytes_read);
+      ::vm_deallocate(mach_task_self(), vm_memory, curr_bytes_read);
+      total_bytes_read += curr_bytes_read;
+      curr_addr += curr_bytes_read;
+      curr_data += curr_bytes_read;
+    } else {
+      break;
+    }
+  }
+  return total_bytes_read;
+}
+
+nub_size_t MachVMMemory::Write(task_t task, nub_addr_t address,
+                               const void *data, nub_size_t data_count) {
+  MachVMRegion vmRegion(task);
+
+  nub_size_t total_bytes_written = 0;
+  nub_addr_t curr_addr = address;
+  const uint8_t *curr_data = (const uint8_t *)data;
+
+  while (total_bytes_written < data_count) {
+    if (vmRegion.GetRegionForAddress(curr_addr)) {
+      mach_vm_size_t curr_data_count = data_count - total_bytes_written;
+      mach_vm_size_t region_bytes_left = vmRegion.BytesRemaining(curr_addr);
+      if (region_bytes_left == 0) {
+        break;
+      }
+      if (curr_data_count > region_bytes_left)
+        curr_data_count = region_bytes_left;
+
+      if (vmRegion.SetProtections(curr_addr, curr_data_count,
+                                  VM_PROT_READ | VM_PROT_WRITE)) {
+        nub_size_t bytes_written =
+            WriteRegion(task, curr_addr, curr_data, curr_data_count);
+        if (bytes_written <= 0) {
+          // Status should have already be posted by WriteRegion...
+          break;
+        } else {
+          total_bytes_written += bytes_written;
+          curr_addr += bytes_written;
+          curr_data += bytes_written;
+        }
+      } else {
+        DNBLogThreadedIf(
+            LOG_MEMORY_PROTECTIONS, "Failed to set read/write protections on "
+                                    "region for address: [0x%8.8llx-0x%8.8llx)",
+            (uint64_t)curr_addr, (uint64_t)(curr_addr + curr_data_count));
+        break;
+      }
+    } else {
+      DNBLogThreadedIf(LOG_MEMORY_PROTECTIONS,
+                       "Failed to get region for address: 0x%8.8llx",
+                       (uint64_t)address);
+      break;
+    }
+  }
+
+  return total_bytes_written;
+}
+
+nub_size_t MachVMMemory::WriteRegion(task_t task, const nub_addr_t address,
+                                     const void *data,
+                                     const nub_size_t data_count) {
+  if (data == NULL || data_count == 0)
+    return 0;
+
+  nub_size_t total_bytes_written = 0;
+  nub_addr_t curr_addr = address;
+  const uint8_t *curr_data = (const uint8_t *)data;
+  while (total_bytes_written < data_count) {
+    mach_msg_type_number_t curr_data_count =
+        static_cast<mach_msg_type_number_t>(MaxBytesLeftInPage(
+            task, curr_addr, data_count - total_bytes_written));
+    m_err =
+        ::mach_vm_write(task, curr_addr, (pointer_t)curr_data, curr_data_count);
+    if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail())
+      m_err.LogThreaded("::mach_vm_write ( task = 0x%4.4x, addr = 0x%8.8llx, "
+                        "data = %8.8p, dataCnt = %u )",
+                        task, (uint64_t)curr_addr, curr_data, curr_data_count);
+
+#if !defined(__i386__) && !defined(__x86_64__)
+    vm_machine_attribute_val_t mattr_value = MATTR_VAL_CACHE_FLUSH;
+
+    m_err = ::vm_machine_attribute(task, curr_addr, curr_data_count,
+                                   MATTR_CACHE, &mattr_value);
+    if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail())
+      m_err.LogThreaded("::vm_machine_attribute ( task = 0x%4.4x, addr = "
+                        "0x%8.8llx, size = %u, attr = MATTR_CACHE, mattr_value "
+                        "=> MATTR_VAL_CACHE_FLUSH )",
+                        task, (uint64_t)curr_addr, curr_data_count);
+#endif
+
+    if (m_err.Success()) {
+      total_bytes_written += curr_data_count;
+      curr_addr += curr_data_count;
+      curr_data += curr_data_count;
+    } else {
+      break;
+    }
+  }
+  return total_bytes_written;
+}