bug.h

Go to the documentation of this file.

//
// bug.h
//
// Copyright (C) 1996 Limit Point Systems, Inc.
//
// Author: Curtis Janssen <cljanss@limitpt.com>
// Maintainer: LPS
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// The SC Toolkit is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//
 
#ifndef TTG_UTIL_MISC_BUG_H_
#define TTG_UTIL_MISC_BUG_H_
 
#include <cassert>
#include <memory>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <vector>
 
#include <pthread.h>
#if __APPLE__
#include <mach/mach.h>
#endif
 
namespace ttg {
  namespace detail {
 
    class MemoryWatchpoint_x86_64 {
     public:
      // x86 debugging registers are described in see
      // https://www.intel.com/content/www/us/en/architecture-and-technology/64-ia-32-architectures-software-developer-system-programming-manual-325384.html
      enum DebugRegister { kDR0 = 0, kDR1 = 1, kDR2 = 2, kDR3 = 3 };
 
      enum Size {
        kByte = 0,      // 1 byte  - 00
        kHalfWord = 1,  // 2 bytes - 01
        kWord = 3,      // 4 bytes - 11
                        //        kDoubleWord = 2,  // 8 bytes - 10  NOT SUPPORTED BY SOME CHIPS!
        kSizeMask = 3   // mask      11
      };
 
      enum BreakState {
        kDisabled = 0,         // disabled   - 00
        kEnabledLocally = 1,   // task local - 01
        kEnabledGlobally = 2,  // global     - 10
        kBreakStateMask = 3    // mask         11
      };
 
      enum Condition {
        kWhenExecuted = 0,       // on execution     - 00
        kWhenWritten = 1,        // on write         - 01
        kWhenWrittenOrRead = 3,  // on read or write - 11
        kConditionMask = 3       // mask               11
      };
 
      class Pool {
       public:
        static constexpr const size_t nwatchpoints_per_thread = 4;
 
        ~Pool() = default;
 
        static void initialize_instance(const std::vector<const pthread_t *> &threads) {
          get_instance() = std::shared_ptr<Pool>(new Pool(threads));
        }
 
        static std::shared_ptr<Pool> instance() {
          auto result = get_instance();
          assert(result && "Pool::instance() called but Pool::initialize_instance() had not been called");
          return result;
        }
 
        Pool &set(void *addr, Size size, Condition cond, const pthread_t *thread) {
          const auto it = pool_.find(thread);
          assert(it != pool_.end());
          // make sure there is no watchpoint for this address already
          for (auto &watchpt_ptr : it->second) {
            if (watchpt_ptr && watchpt_ptr->address() == addr) return *this;
          }
          // now create a watchpoint
          for (auto dr = 0; dr != nwatchpoints_per_thread; ++dr) {
            auto &watchpt_ptr = it->second[dr];
            if (!watchpt_ptr) {
              watchpt_ptr =
                  std::make_shared<MemoryWatchpoint_x86_64>(addr, size, cond, static_cast<DebugRegister>(dr), thread);
              return *this;
            }
          }
          return *this;
        }
 
        MemoryWatchpoint_x86_64 *find(void *addr, const pthread_t *thread) {
          const auto it = pool_.find(thread);
          assert(it != pool_.end());
          for (auto &watchpt_ptr : it->second) {
            if (watchpt_ptr && watchpt_ptr->address() == addr) return watchpt_ptr.get();
          }
          return nullptr;
        }
 
        Pool &clear(void *addr, const pthread_t *thread) {
          const auto it = pool_.find(thread);
          assert(it != pool_.end());
          for (auto &watchpt_ptr : it->second) {
            if (watchpt_ptr && watchpt_ptr->address() == addr) {
              watchpt_ptr.reset();
              return *this;
            }
          }
          return *this;
        }
 
       private:
        std::unordered_map<const pthread_t *, std::vector<std::shared_ptr<MemoryWatchpoint_x86_64>>> pool_;
 
        explicit Pool(const std::vector<const pthread_t *> &threads) {
          for (const auto &thread : threads) {
            assert(thread != nullptr);
            pool_[thread].resize(nwatchpoints_per_thread);
          }
        }
 
        static std::shared_ptr<Pool> &get_instance() {
          static std::shared_ptr<Pool> instance_;
          return instance_;
        }
      };
 
      MemoryWatchpoint_x86_64(void *addr, Size size, Condition cond, DebugRegister dr, const pthread_t *thread)
          : addr_(addr), size_(size), cond_(cond), dr_(dr), thread_(thread) {
        init(true);
      }
 
      ~MemoryWatchpoint_x86_64() { init(false); }
 
      void *address() const { return addr_; }
      Size size() const { return size_; }
      Condition condition() const { return cond_; }
      DebugRegister debug_register() const { return dr_; }
 
     private:
      void *addr_;
      Size size_;
      Condition cond_;
      DebugRegister dr_;
      const pthread_t *thread_;
 
      inline uint64_t MakeFlags(DebugRegister reg, BreakState state, Condition cond, Size size) {
        // N.B. each register takes 2 bits in DR7
        return (state | cond << 16 | size << 24) << (2 * reg);
      }
 
      inline uint64_t MakeMask(DebugRegister reg) { return MakeFlags(reg, kBreakStateMask, kConditionMask, kSizeMask); }
 
      friend class MemoryWatchPool;
 
      void init(bool create) {
#if defined(__APPLE__) && defined(__x86_64__)
        x86_debug_state dr;
        mach_msg_type_number_t dr_count = x86_DEBUG_STATE_COUNT;
 
        mach_port_t target_mach_thread = pthread_mach_thread_np(*thread_);
 
        kern_return_t rc =
            thread_get_state(target_mach_thread, x86_DEBUG_STATE, reinterpret_cast<thread_state_t>(&dr), &dr_count);
 
        if (create && rc != KERN_SUCCESS)
          throw std::runtime_error("MemoryWatchpoint_x86_64::MemoryWatchpoint_x86_64(): thread_get_state failed");
 
        switch (dr_) {
          case kDR0:
            dr.uds.ds64.__dr0 = reinterpret_cast<uint64_t>(addr_);
            break;
          case kDR1:
            dr.uds.ds64.__dr1 = reinterpret_cast<uint64_t>(addr_);
            break;
          case kDR2:
            dr.uds.ds64.__dr2 = reinterpret_cast<uint64_t>(addr_);
            break;
          case kDR3:
            dr.uds.ds64.__dr3 = reinterpret_cast<uint64_t>(addr_);
            break;
        }
 
        dr.uds.ds64.__dr7 &= ~MakeMask(dr_);
 
        dr.uds.ds64.__dr7 |= MakeFlags(dr_, create ? kEnabledLocally : kDisabled, cond_, size_);
 
        rc = thread_set_state(target_mach_thread, x86_DEBUG_STATE, reinterpret_cast<thread_state_t>(&dr), dr_count);
 
        if (create && rc != KERN_SUCCESS)
          throw std::runtime_error("MemoryWatchpoint_x86_64::MemoryWatchpoint_x86_64(): thread_set_state failed");
#endif  // defined(__APPLE__) && defined(__x86_64__)
      }
    };
 
  }  // namespace detail
 
  void initialize_fpe();
 
  class Debugger {
   protected:
    std::string prefix_;
    std::string exec_;
    std::string cmd_;
    volatile int debugger_ready_;
 
    bool debug_;
    bool traceback_;
    bool exit_on_signal_;
    bool sleep_;
    bool wait_for_debugger_;
    bool handle_sigint_;
    int *mysigs_;
 
    void init();
 
    static std::shared_ptr<Debugger> default_debugger_;
 
    static void __traceback(const std::string &prefix, const char *reason = nullptr);
 
   public:
    explicit Debugger(const char *exec = nullptr);
    virtual ~Debugger();
 
    virtual void debug(const char *reason);
    virtual void traceback(const char *reason);
    virtual void set_debug_on_signal(int);
    virtual void set_traceback_on_signal(int);
    virtual void set_exit_on_signal(int);
    virtual void set_wait_for_debugger(int);
 
    virtual void handle(int sig);
    virtual void release(int sig);
    virtual void handle_defaults();
 
    virtual void set_prefix(const char *p);
    virtual void set_prefix(int p);
 
    virtual void set_cmd(const char *);
    virtual void default_cmd();
    virtual void set_exec(const char *);
 
    virtual void got_signal(int sig);
 
    static void set_default_debugger(const std::shared_ptr<Debugger> &);
    static std::shared_ptr<Debugger> default_debugger();
 
   private:
    void resolve_cmd_alias();
  };
 
}  // namespace ttg
 
namespace ttg {
  void launch_debugger(int rank, const char *exec_name, const char *cmd);
 
  void launch_lldb(int rank = 0, const char *exec_name = "");
  void launch_gdb(int rank = 0, const char *exec_name = "");
 
}  // namespace ttg
 
#endif  // TTG_UTIL_MISC_BUG_H_
 
// Local Variables:
// mode: c++
// c-file-style: "CLJ"
// End: