gdb_api.h

Go to the documentation of this file.

/*******************************************************************\
 
Module: GDB Machine Interface API
 
Author: Malte Mues <mail.mues@gmail.com>
        Daniel Poetzl
 
\*******************************************************************/
 
 
#ifndef CPROVER_MEMORY_ANALYZER_GDB_API_H
#define CPROVER_MEMORY_ANALYZER_GDB_API_H
#include <unistd.h>
 
#include <algorithm>
#include <forward_list>
#include <map>
 
#include <util/exception_utils.h>
 
class gdb_apit
{
public:
  using commandst = std::forward_list<std::string>;
 
  struct memory_addresst
  {
    bool null_address;
    std::string address_string;
    memory_addresst() : null_address(true)
    {
    }
    explicit memory_addresst(const std::string &address_string)
      : null_address(address_string == "0x0"), address_string(address_string)
    {
    }
 
    bool is_null() const
    {
      return null_address;
    }
    bool operator<(const memory_addresst &other) const
    {
      return address_string < other.address_string;
    }
    std::string string() const
    {
      return address_string;
    }
  };
 
  explicit gdb_apit(
    const std::vector<std::string> &args, const bool log = false);
 
  ~gdb_apit();
 
  struct pointer_valuet
  {
    pointer_valuet(
      const std::string &address = "",
      const std::string &pointee = "",
      const std::string &character = "",
      const std::optional<std::string> &string = {},
      const bool valid = false)
      : address(address),
        pointee(pointee),
        character(character),
        string(string),
        valid(valid)
    {
    }
 
    memory_addresst address;
    std::string pointee;
    std::string character;
    std::optional<std::string> string;
 
    bool has_known_offset() const
    {
      return std::any_of(
        pointee.begin(), pointee.end(), [](char c) { return c == '+'; });
    }
 
    bool valid;
  };
 
  size_t query_malloc_size(const std::string &pointer_expr);
 
  void create_gdb_process();
 
  bool run_gdb_to_breakpoint(const std::string &breakpoint);
 
  void run_gdb_from_core(const std::string &corefile);
 
  std::optional<std::string> get_value(const std::string &expr);
 
  pointer_valuet get_memory(const std::string &expr);
 
  const commandst &get_command_log();
 
protected:
  // arguments passed to gdb, first argument is the command to execute
  std::vector<std::string> args;
 
  FILE *response_stream;
  FILE *command_stream;
 
  const bool log;
  commandst command_log;
 
  enum class gdb_statet
  {
    NOT_CREATED,
    CREATED,
    STOPPED // valid state, reached e.g. after breakpoint was hit
  };
 
  gdb_statet gdb_state;
 
  std::map<std::string, size_t> allocated_memory;
 
  typedef std::map<std::string, std::string> gdb_output_recordt;
  static gdb_output_recordt parse_gdb_output_record(const std::string &s);
 
  void write_to_gdb(const std::string &command);
 
  std::string read_next_line();
  std::string read_most_recent_line();
 
  std::string eval_expr(const std::string &expr);
 
  gdb_output_recordt
  get_most_recent_record(const std::string &tag, const bool must_exist = false);
 
  bool most_recent_line_has_tag(const std::string &tag);
  bool was_command_accepted();
  void check_command_accepted();
 
  void collect_malloc_calls();
 
  std::string get_value_from_record(
    const gdb_output_recordt &record,
    const std::string &value_name);
 
  bool hit_malloc_breakpoint(const gdb_output_recordt &stopped_record);
 
  std::string get_register_value(const gdb_output_recordt &record);
 
  static std::string r_opt(const std::string &regex);
 
  static std::string
  r_or(const std::string &regex_left, const std::string &regex_right);
 
  // regex group for hex memory address (part of the output of gdb when printing
  // a pointer), matches e.g. 0x601040 and extracts 0x601040
  const std::string r_hex_addr = R"((0x(?:0|[1-9a-f][0-9a-f]*)))";
 
  // regex group for identifier (optional part of the output of gdb when
  // printing a pointer), matches e.g. <abc> and extracts abc
  const std::string r_id = R"(<([^<>]+)>)";
 
  // regex group for octal encoded char (optional part of the output of gdb when
  // printing a pointer), matches e.g. \"\\003\" and extracts \\003
  const std::string r_char = R"(\\"(\\\\[0-7]{3})\\")";
 
  // regex group for string (optional part of the output of gdb when printing a
  // pointer), matches e.g. \"abc\" and extracts \"abc\"
  const std::string r_string = R"((\\".*\\"))";
 
  // name of malloc function
  const std::string malloc_name = "malloc";
};
 
class gdb_interaction_exceptiont : public cprover_exception_baset
{
public:
  explicit gdb_interaction_exceptiont(std::string reason)
    : cprover_exception_baset(std::move(reason))
  {
  }
};
 
#endif // CPROVER_MEMORY_ANALYZER_GDB_API_H