Import LLVM 10.0.0 release including clang, lld and lldb.

ok hackroom
tested by plenty

1 files changed, 512 insertions, 0 deletions

diff --git a/gnu/llvm/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp b/gnu/llvm/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp
new file mode 100644
index 00000000000..6d03bd534f3
--- /dev/null
+++ b/gnu/llvm/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp
@@ -0,0 +1,512 @@
+//===-- StopInfoMachException.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
+//
+//===----------------------------------------------------------------------===//
+
+#include "StopInfoMachException.h"
+
+
+#if defined(__APPLE__)
+// Needed for the EXC_RESOURCE interpretation macros
+#include <kern/exc_resource.h>
+#endif
+
+#include "lldb/Breakpoint/Watchpoint.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Target/DynamicLoader.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Target/ThreadPlan.h"
+#include "lldb/Target/UnixSignals.h"
+#include "lldb/Utility/StreamString.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+const char *StopInfoMachException::GetDescription() {
+  if (!m_description.empty())
+    return m_description.c_str();
+  if (GetValue() == eStopReasonInvalid)
+    return "invalid stop reason!";
+
+  ExecutionContext exe_ctx(m_thread_wp.lock());
+  Target *target = exe_ctx.GetTargetPtr();
+  const llvm::Triple::ArchType cpu =
+      target ? target->GetArchitecture().GetMachine()
+             : llvm::Triple::UnknownArch;
+
+  const char *exc_desc = nullptr;
+  const char *code_label = "code";
+  const char *code_desc = nullptr;
+  const char *subcode_label = "subcode";
+  const char *subcode_desc = nullptr;
+
+#if defined(__APPLE__)
+  char code_desc_buf[32];
+  char subcode_desc_buf[32];
+#endif
+
+  switch (m_value) {
+  case 1: // EXC_BAD_ACCESS
+    exc_desc = "EXC_BAD_ACCESS";
+    subcode_label = "address";
+    switch (cpu) {
+    case llvm::Triple::x86:
+    case llvm::Triple::x86_64:
+      switch (m_exc_code) {
+      case 0xd:
+        code_desc = "EXC_I386_GPFLT";
+        m_exc_data_count = 1;
+        break;
+      }
+      break;
+    case llvm::Triple::arm:
+    case llvm::Triple::thumb:
+      switch (m_exc_code) {
+      case 0x101:
+        code_desc = "EXC_ARM_DA_ALIGN";
+        break;
+      case 0x102:
+        code_desc = "EXC_ARM_DA_DEBUG";
+        break;
+      }
+      break;
+
+    default:
+      break;
+    }
+    break;
+
+  case 2: // EXC_BAD_INSTRUCTION
+    exc_desc = "EXC_BAD_INSTRUCTION";
+    switch (cpu) {
+    case llvm::Triple::x86:
+    case llvm::Triple::x86_64:
+      if (m_exc_code == 1)
+        code_desc = "EXC_I386_INVOP";
+      break;
+
+    case llvm::Triple::arm:
+    case llvm::Triple::thumb:
+      if (m_exc_code == 1)
+        code_desc = "EXC_ARM_UNDEFINED";
+      break;
+
+    default:
+      break;
+    }
+    break;
+
+  case 3: // EXC_ARITHMETIC
+    exc_desc = "EXC_ARITHMETIC";
+    switch (cpu) {
+    case llvm::Triple::x86:
+    case llvm::Triple::x86_64:
+      switch (m_exc_code) {
+      case 1:
+        code_desc = "EXC_I386_DIV";
+        break;
+      case 2:
+        code_desc = "EXC_I386_INTO";
+        break;
+      case 3:
+        code_desc = "EXC_I386_NOEXT";
+        break;
+      case 4:
+        code_desc = "EXC_I386_EXTOVR";
+        break;
+      case 5:
+        code_desc = "EXC_I386_EXTERR";
+        break;
+      case 6:
+        code_desc = "EXC_I386_EMERR";
+        break;
+      case 7:
+        code_desc = "EXC_I386_BOUND";
+        break;
+      case 8:
+        code_desc = "EXC_I386_SSEEXTERR";
+        break;
+      }
+      break;
+
+    default:
+      break;
+    }
+    break;
+
+  case 4: // EXC_EMULATION
+    exc_desc = "EXC_EMULATION";
+    break;
+
+  case 5: // EXC_SOFTWARE
+    exc_desc = "EXC_SOFTWARE";
+    if (m_exc_code == 0x10003) {
+      subcode_desc = "EXC_SOFT_SIGNAL";
+      subcode_label = "signo";
+    }
+    break;
+
+  case 6: // EXC_BREAKPOINT
+  {
+    exc_desc = "EXC_BREAKPOINT";
+    switch (cpu) {
+    case llvm::Triple::x86:
+    case llvm::Triple::x86_64:
+      switch (m_exc_code) {
+      case 1:
+        code_desc = "EXC_I386_SGL";
+        break;
+      case 2:
+        code_desc = "EXC_I386_BPT";
+        break;
+      }
+      break;
+
+    case llvm::Triple::arm:
+    case llvm::Triple::thumb:
+      switch (m_exc_code) {
+      case 0x101:
+        code_desc = "EXC_ARM_DA_ALIGN";
+        break;
+      case 0x102:
+        code_desc = "EXC_ARM_DA_DEBUG";
+        break;
+      case 1:
+        code_desc = "EXC_ARM_BREAKPOINT";
+        break;
+      // FIXME temporary workaround, exc_code 0 does not really mean
+      // EXC_ARM_BREAKPOINT
+      case 0:
+        code_desc = "EXC_ARM_BREAKPOINT";
+        break;
+      }
+      break;
+
+    default:
+      break;
+    }
+  } break;
+
+  case 7:
+    exc_desc = "EXC_SYSCALL";
+    break;
+
+  case 8:
+    exc_desc = "EXC_MACH_SYSCALL";
+    break;
+
+  case 9:
+    exc_desc = "EXC_RPC_ALERT";
+    break;
+
+  case 10:
+    exc_desc = "EXC_CRASH";
+    break;
+  case 11:
+    exc_desc = "EXC_RESOURCE";
+#if defined(__APPLE__)
+    {
+      int resource_type = EXC_RESOURCE_DECODE_RESOURCE_TYPE(m_exc_code);
+
+      code_label = "limit";
+      code_desc = code_desc_buf;
+      subcode_label = "observed";
+      subcode_desc = subcode_desc_buf;
+
+      switch (resource_type) {
+      case RESOURCE_TYPE_CPU:
+        exc_desc = "EXC_RESOURCE RESOURCE_TYPE_CPU";
+        snprintf(code_desc_buf, sizeof(code_desc_buf), "%d%%",
+                 (int)EXC_RESOURCE_CPUMONITOR_DECODE_PERCENTAGE(m_exc_code));
+        snprintf(subcode_desc_buf, sizeof(subcode_desc_buf), "%d%%",
+                 (int)EXC_RESOURCE_CPUMONITOR_DECODE_PERCENTAGE_OBSERVED(
+                     m_exc_subcode));
+        break;
+      case RESOURCE_TYPE_WAKEUPS:
+        exc_desc = "EXC_RESOURCE RESOURCE_TYPE_WAKEUPS";
+        snprintf(
+            code_desc_buf, sizeof(code_desc_buf), "%d w/s",
+            (int)EXC_RESOURCE_CPUMONITOR_DECODE_WAKEUPS_PERMITTED(m_exc_code));
+        snprintf(subcode_desc_buf, sizeof(subcode_desc_buf), "%d w/s",
+                 (int)EXC_RESOURCE_CPUMONITOR_DECODE_WAKEUPS_OBSERVED(
+                     m_exc_subcode));
+        break;
+      case RESOURCE_TYPE_MEMORY:
+        exc_desc = "EXC_RESOURCE RESOURCE_TYPE_MEMORY";
+        snprintf(code_desc_buf, sizeof(code_desc_buf), "%d MB",
+                 (int)EXC_RESOURCE_HWM_DECODE_LIMIT(m_exc_code));
+        subcode_desc = nullptr;
+        subcode_label = "unused";
+        break;
+#if defined(RESOURCE_TYPE_IO)
+      // RESOURCE_TYPE_IO is introduced in macOS SDK 10.12.
+      case RESOURCE_TYPE_IO:
+        exc_desc = "EXC_RESOURCE RESOURCE_TYPE_IO";
+        snprintf(code_desc_buf, sizeof(code_desc_buf), "%d MB",
+                 (int)EXC_RESOURCE_IO_DECODE_LIMIT(m_exc_code));
+        snprintf(subcode_desc_buf, sizeof(subcode_desc_buf), "%d MB",
+                 (int)EXC_RESOURCE_IO_OBSERVED(m_exc_subcode));
+        ;
+        break;
+#endif
+      }
+    }
+#endif
+    break;
+  case 12:
+    exc_desc = "EXC_GUARD";
+    break;
+  }
+
+  StreamString strm;
+
+  if (exc_desc)
+    strm.PutCString(exc_desc);
+  else
+    strm.Printf("EXC_??? (%" PRIu64 ")", m_value);
+
+  if (m_exc_data_count >= 1) {
+    if (code_desc)
+      strm.Printf(" (%s=%s", code_label, code_desc);
+    else
+      strm.Printf(" (%s=%" PRIu64, code_label, m_exc_code);
+  }
+
+  if (m_exc_data_count >= 2) {
+    if (subcode_desc)
+      strm.Printf(", %s=%s", subcode_label, subcode_desc);
+    else
+      strm.Printf(", %s=0x%" PRIx64, subcode_label, m_exc_subcode);
+  }
+
+  if (m_exc_data_count > 0)
+    strm.PutChar(')');
+
+  m_description = strm.GetString();
+  return m_description.c_str();
+}
+
+StopInfoSP StopInfoMachException::CreateStopReasonWithMachException(
+    Thread &thread, uint32_t exc_type, uint32_t exc_data_count,
+    uint64_t exc_code, uint64_t exc_sub_code, uint64_t exc_sub_sub_code,
+    bool pc_already_adjusted, bool adjust_pc_if_needed) {
+  if (exc_type == 0)
+    return StopInfoSP();
+
+  uint32_t pc_decrement = 0;
+  ExecutionContext exe_ctx(thread.shared_from_this());
+  Target *target = exe_ctx.GetTargetPtr();
+  const llvm::Triple::ArchType cpu =
+      target ? target->GetArchitecture().GetMachine()
+             : llvm::Triple::UnknownArch;
+
+  switch (exc_type) {
+  case 1: // EXC_BAD_ACCESS
+  case 2: // EXC_BAD_INSTRUCTION
+  case 3: // EXC_ARITHMETIC
+  case 4: // EXC_EMULATION
+    break;
+
+  case 5:                    // EXC_SOFTWARE
+    if (exc_code == 0x10003) // EXC_SOFT_SIGNAL
+    {
+      if (exc_sub_code == 5) {
+        // On MacOSX, a SIGTRAP can signify that a process has called exec,
+        // so we should check with our dynamic loader to verify.
+        ProcessSP process_sp(thread.GetProcess());
+        if (process_sp) {
+          DynamicLoader *dynamic_loader = process_sp->GetDynamicLoader();
+          if (dynamic_loader && dynamic_loader->ProcessDidExec()) {
+            // The program was re-exec'ed
+            return StopInfo::CreateStopReasonWithExec(thread);
+          }
+        }
+      }
+      return StopInfo::CreateStopReasonWithSignal(thread, exc_sub_code);
+    }
+    break;
+
+  case 6: // EXC_BREAKPOINT
+  {
+    bool is_actual_breakpoint = false;
+    bool is_trace_if_actual_breakpoint_missing = false;
+    switch (cpu) {
+    case llvm::Triple::x86:
+    case llvm::Triple::x86_64:
+      if (exc_code == 1) // EXC_I386_SGL
+      {
+        if (!exc_sub_code) {
+          // This looks like a plain trap.
+          // Have to check if there is a breakpoint here as well.  When you
+          // single-step onto a trap, the single step stops you not to trap.
+          // Since we also do that check below, let's just use that logic.
+          is_actual_breakpoint = true;
+          is_trace_if_actual_breakpoint_missing = true;
+        } else {
+
+          // It's a watchpoint, then.
+          // The exc_sub_code indicates the data break address.
+          lldb::WatchpointSP wp_sp;
+          if (target)
+            wp_sp = target->GetWatchpointList().FindByAddress(
+                (lldb::addr_t)exc_sub_code);
+          if (wp_sp && wp_sp->IsEnabled()) {
+            // Debugserver may piggyback the hardware index of the fired
+            // watchpoint in the exception data. Set the hardware index if
+            // that's the case.
+            if (exc_data_count >= 3)
+              wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
+            return StopInfo::CreateStopReasonWithWatchpointID(thread,
+                                                              wp_sp->GetID());
+          }
+        }
+      } else if (exc_code == 2 || // EXC_I386_BPT
+                 exc_code == 3)   // EXC_I386_BPTFLT
+      {
+        // KDP returns EXC_I386_BPTFLT for trace breakpoints
+        if (exc_code == 3)
+          is_trace_if_actual_breakpoint_missing = true;
+
+        is_actual_breakpoint = true;
+        if (!pc_already_adjusted)
+          pc_decrement = 1;
+      }
+      break;
+
+    case llvm::Triple::arm:
+    case llvm::Triple::thumb:
+      if (exc_code == 0x102) // EXC_ARM_DA_DEBUG
+      {
+        // It's a watchpoint, then, if the exc_sub_code indicates a
+        // known/enabled data break address from our watchpoint list.
+        lldb::WatchpointSP wp_sp;
+        if (target)
+          wp_sp = target->GetWatchpointList().FindByAddress(
+              (lldb::addr_t)exc_sub_code);
+        if (wp_sp && wp_sp->IsEnabled()) {
+          // Debugserver may piggyback the hardware index of the fired
+          // watchpoint in the exception data. Set the hardware index if
+          // that's the case.
+          if (exc_data_count >= 3)
+            wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
+          return StopInfo::CreateStopReasonWithWatchpointID(thread,
+                                                            wp_sp->GetID());
+        } else {
+          is_actual_breakpoint = true;
+          is_trace_if_actual_breakpoint_missing = true;
+        }
+      } else if (exc_code == 1) // EXC_ARM_BREAKPOINT
+      {
+        is_actual_breakpoint = true;
+        is_trace_if_actual_breakpoint_missing = true;
+      } else if (exc_code == 0) // FIXME not EXC_ARM_BREAKPOINT but a kernel
+                                // is currently returning this so accept it
+                                // as indicating a breakpoint until the
+                                // kernel is fixed
+      {
+        is_actual_breakpoint = true;
+        is_trace_if_actual_breakpoint_missing = true;
+      }
+      break;
+
+    case llvm::Triple::aarch64_32:
+    case llvm::Triple::aarch64: {
+      if (exc_code == 1 && exc_sub_code == 0) // EXC_ARM_BREAKPOINT
+      {
+        // This is hit when we single instruction step aka MDSCR_EL1 SS bit 0
+        // is set
+        is_actual_breakpoint = false;
+        is_trace_if_actual_breakpoint_missing = true;
+      }
+      if (exc_code == 0x102) // EXC_ARM_DA_DEBUG
+      {
+        // It's a watchpoint, then, if the exc_sub_code indicates a
+        // known/enabled data break address from our watchpoint list.
+        lldb::WatchpointSP wp_sp;
+        if (target)
+          wp_sp = target->GetWatchpointList().FindByAddress(
+              (lldb::addr_t)exc_sub_code);
+        if (wp_sp && wp_sp->IsEnabled()) {
+          // Debugserver may piggyback the hardware index of the fired
+          // watchpoint in the exception data. Set the hardware index if
+          // that's the case.
+          if (exc_data_count >= 3)
+            wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
+          return StopInfo::CreateStopReasonWithWatchpointID(thread,
+                                                            wp_sp->GetID());
+        }
+        // EXC_ARM_DA_DEBUG seems to be reused for EXC_BREAKPOINT as well as
+        // EXC_BAD_ACCESS
+        if (thread.GetTemporaryResumeState() == eStateStepping)
+          return StopInfo::CreateStopReasonToTrace(thread);
+      }
+      // It looks like exc_sub_code has the 4 bytes of the instruction that
+      // triggered the exception, i.e. our breakpoint opcode
+      is_actual_breakpoint = exc_code == 1;
+      break;
+    }
+
+    default:
+      break;
+    }
+
+    if (is_actual_breakpoint) {
+      RegisterContextSP reg_ctx_sp(thread.GetRegisterContext());
+      addr_t pc = reg_ctx_sp->GetPC() - pc_decrement;
+
+      ProcessSP process_sp(thread.CalculateProcess());
+
+      lldb::BreakpointSiteSP bp_site_sp;
+      if (process_sp)
+        bp_site_sp = process_sp->GetBreakpointSiteList().FindByAddress(pc);
+      if (bp_site_sp && bp_site_sp->IsEnabled()) {
+        // Update the PC if we were asked to do so, but only do so if we find
+        // a breakpoint that we know about cause this could be a trap
+        // instruction in the code
+        if (pc_decrement > 0 && adjust_pc_if_needed)
+          reg_ctx_sp->SetPC(pc);
+
+        // If the breakpoint is for this thread, then we'll report the hit,
+        // but if it is for another thread, we can just report no reason.  We
+        // don't need to worry about stepping over the breakpoint here, that
+        // will be taken care of when the thread resumes and notices that
+        // there's a breakpoint under the pc. If we have an operating system
+        // plug-in, we might have set a thread specific breakpoint using the
+        // operating system thread ID, so we can't make any assumptions about
+        // the thread ID so we must always report the breakpoint regardless
+        // of the thread.
+        if (bp_site_sp->ValidForThisThread(&thread) ||
+            thread.GetProcess()->GetOperatingSystem() != nullptr)
+          return StopInfo::CreateStopReasonWithBreakpointSiteID(
+              thread, bp_site_sp->GetID());
+        else if (is_trace_if_actual_breakpoint_missing)
+          return StopInfo::CreateStopReasonToTrace(thread);
+        else
+          return StopInfoSP();
+      }
+
+      // Don't call this a trace if we weren't single stepping this thread.
+      if (is_trace_if_actual_breakpoint_missing &&
+          thread.GetTemporaryResumeState() == eStateStepping) {
+        return StopInfo::CreateStopReasonToTrace(thread);
+      }
+    }
+  } break;
+
+  case 7:  // EXC_SYSCALL
+  case 8:  // EXC_MACH_SYSCALL
+  case 9:  // EXC_RPC_ALERT
+  case 10: // EXC_CRASH
+    break;
+  }
+
+  return StopInfoSP(new StopInfoMachException(thread, exc_type, exc_data_count,
+                                              exc_code, exc_sub_code));
+}