contrib/llvm-project/lldb/source/API/SBUnixSignals.cpp

   1 //===-- SBUnixSignals.cpp -------------------------------------------------===//
   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 #include "SBReproducerPrivate.h"
  10 #include "lldb/Target/Platform.h"
  11 #include "lldb/Target/Process.h"
  12 #include "lldb/Target/UnixSignals.h"
  13 #include "lldb/lldb-defines.h"
  14
  15 #include "lldb/API/SBUnixSignals.h"
  16
  17 using namespace lldb;
  18 using namespace lldb_private;
  19
  20 SBUnixSignals::SBUnixSignals() {
  21   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBUnixSignals);
  22 }
  23
  24 SBUnixSignals::SBUnixSignals(const SBUnixSignals &rhs)
  25     : m_opaque_wp(rhs.m_opaque_wp) {
  26   LLDB_RECORD_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &), rhs);
  27 }
  28
  29 SBUnixSignals::SBUnixSignals(ProcessSP &process_sp)
  30     : m_opaque_wp(process_sp ? process_sp->GetUnixSignals() : nullptr) {}
  31
  32 SBUnixSignals::SBUnixSignals(PlatformSP &platform_sp)
  33     : m_opaque_wp(platform_sp ? platform_sp->GetUnixSignals() : nullptr) {}
  34
  35 const SBUnixSignals &SBUnixSignals::operator=(const SBUnixSignals &rhs) {
  36   LLDB_RECORD_METHOD(const lldb::SBUnixSignals &,
  37                      SBUnixSignals, operator=,(const lldb::SBUnixSignals &),
  38                      rhs);
  39
  40   if (this != &rhs)
  41     m_opaque_wp = rhs.m_opaque_wp;
  42   return LLDB_RECORD_RESULT(*this);
  43 }
  44
  45 SBUnixSignals::~SBUnixSignals() = default;
  46
  47 UnixSignalsSP SBUnixSignals::GetSP() const { return m_opaque_wp.lock(); }
  48
  49 void SBUnixSignals::SetSP(const UnixSignalsSP &signals_sp) {
  50   m_opaque_wp = signals_sp;
  51 }
  52
  53 void SBUnixSignals::Clear() {
  54   LLDB_RECORD_METHOD_NO_ARGS(void, SBUnixSignals, Clear);
  55
  56   m_opaque_wp.reset();
  57 }
  58
  59 bool SBUnixSignals::IsValid() const {
  60   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, IsValid);
  61   return this->operator bool();
  62 }
  63 SBUnixSignals::operator bool() const {
  64   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, operator bool);
  65
  66   return static_cast<bool>(GetSP());
  67 }
  68
  69 const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
  70   LLDB_RECORD_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
  71                            (int32_t), signo);
  72
  73   if (auto signals_sp = GetSP())
  74     return signals_sp->GetSignalAsCString(signo);
  75
  76   return nullptr;
  77 }
  78
  79 int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
  80   LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
  81                            (const char *), name);
  82
  83   if (auto signals_sp = GetSP())
  84     return signals_sp->GetSignalNumberFromName(name);
  85
  86   return LLDB_INVALID_SIGNAL_NUMBER;
  87 }
  88
  89 bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
  90   LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, (int32_t),
  91                            signo);
  92
  93   if (auto signals_sp = GetSP())
  94     return signals_sp->GetShouldSuppress(signo);
  95
  96   return false;
  97 }
  98
  99 bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
 100   LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool),
 101                      signo, value);
 102
 103   auto signals_sp = GetSP();
 104
 105   if (signals_sp)
 106     return signals_sp->SetShouldSuppress(signo, value);
 107
 108   return false;
 109 }
 110
 111 bool SBUnixSignals::GetShouldStop(int32_t signo) const {
 112   LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t),
 113                            signo);
 114
 115   if (auto signals_sp = GetSP())
 116     return signals_sp->GetShouldStop(signo);
 117
 118   return false;
 119 }
 120
 121 bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
 122   LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo,
 123                      value);
 124
 125   auto signals_sp = GetSP();
 126
 127   if (signals_sp)
 128     return signals_sp->SetShouldStop(signo, value);
 129
 130   return false;
 131 }
 132
 133 bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
 134   LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t),
 135                            signo);
 136
 137   if (auto signals_sp = GetSP())
 138     return signals_sp->GetShouldNotify(signo);
 139
 140   return false;
 141 }
 142
 143 bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
 144   LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool),
 145                      signo, value);
 146
 147   auto signals_sp = GetSP();
 148
 149   if (signals_sp)
 150     return signals_sp->SetShouldNotify(signo, value);
 151
 152   return false;
 153 }
 154
 155 int32_t SBUnixSignals::GetNumSignals() const {
 156   LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals);
 157
 158   if (auto signals_sp = GetSP())
 159     return signals_sp->GetNumSignals();
 160
 161   return -1;
 162 }
 163
 164 int32_t SBUnixSignals::GetSignalAtIndex(int32_t index) const {
 165   LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, (int32_t),
 166                            index);
 167
 168   if (auto signals_sp = GetSP())
 169     return signals_sp->GetSignalAtIndex(index);
 170
 171   return LLDB_INVALID_SIGNAL_NUMBER;
 172 }
 173
 174 namespace lldb_private {
 175 namespace repro {
 176
 177 template <>
 178 void RegisterMethods<SBUnixSignals>(Registry &R) {
 179   LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, ());
 180   LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &));
 181   LLDB_REGISTER_METHOD(
 182       const lldb::SBUnixSignals &,
 183       SBUnixSignals, operator=,(const lldb::SBUnixSignals &));
 184   LLDB_REGISTER_METHOD(void, SBUnixSignals, Clear, ());
 185   LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, IsValid, ());
 186   LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, operator bool, ());
 187   LLDB_REGISTER_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
 188                              (int32_t));
 189   LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
 190                              (const char *));
 191   LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress,
 192                              (int32_t));
 193   LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldSuppress,
 194                        (int32_t, bool));
 195   LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t));
 196   LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool));
 197   LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t));
 198   LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool));
 199   LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetNumSignals, ());
 200   LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex,
 201                              (int32_t));
 202 }
 203
 204 }
 205 }