Update gdb api to return more information about pointed-to objects

This update the gdb api to return more information about pointers (via the
method get_memory() which returns an object of type pointer_valuet describing
the pointer and pointed-to data). Unit tests for the new functionality are
included.

Author: danpoe

src/memory-analyzer/gdb_api.cpp

@@ -25,6 +25,8 @@ Author: Malte Mues <[email protected]>
 #include <cstring>
 #include <regex>
 
+#include <iostream>
+
 #include "gdb_api.h"
 
 #include <goto-programs/goto_model.h>
@@ -358,32 +360,36 @@ std::string gdb_apit::eval_expr(const std::string &expr)
 /// \param expr an expression of pointer type (e.g., `&x` with `x` being of type
 ///   `int` or `p` with `p` being of type `int *`)
 /// \return memory address in hex format
-std::string gdb_apit::get_memory(const std::string &expr)
+gdb_apit::pointer_valuet gdb_apit::get_memory(const std::string &expr)
 {
   PRECONDITION(gdb_state == gdb_statet::STOPPED);
 
-  std::string mem;
-
-  // regex matching a hex memory address followed by an optional identifier in
-  // angle brackets (e.g., `0x601060 <x>`)
-  std::regex regex(R"(^(0x[1-9a-f][0-9a-f]*)( <.*>)?)");
+  std::string value = eval_expr(expr);
 
-  const std::string value = eval_expr(expr);
+  std::regex regex(
+    r_hex_addr + r_opt(' ' + r_id) + r_opt(' ' + r_or(r_char, r_string)));
 
   std::smatch result;
-  if(regex_match(value, result, regex))
-  {
-    // return hex address only
-    return result[1];
-  }
-  else
+  const bool b = regex_match(value, result, regex);
+  CHECK_RETURN(b);
+
+  optionalt<std::string> opt_string;
+  const std::string string = result[4];
+
+  if(!string.empty())
   {
-    throw gdb_interaction_exceptiont(
-      "value `" + value +
-      "` is not a memory address or has unrecognised format");
+    const std::size_t len = string.length();
+
+    INVARIANT(len >= 4, "");
+    INVARIANT(string[0] == '\\', "");
+    INVARIANT(string[1] == '"', "");
+    INVARIANT(string[len - 2] == '\\', "");
+    INVARIANT(string[len - 1] == '"', "");
+
+    opt_string = string.substr(2, len - 4);
   }
 
-  UNREACHABLE;
+  return pointer_valuet(result[1], result[2], result[3], opt_string);
 }
 
 /// Get value of the given value expression
@@ -398,25 +404,15 @@ std::string gdb_apit::get_value(const std::string &expr)
 
   const std::string value = eval_expr(expr);
 
+  // Get char value
   {
-    // get string from char pointer
-    const std::regex regex(R"(0x[1-9a-f][0-9a-f]* \\"(.*)\\")");
+    // matches e.g. 99 'c' and extracts c
+    std::regex regex(R"([^ ]+ '([^']+)')");
 
     std::smatch result;
-    if(regex_match(value, result, regex))
-    {
-      return result[1];
-    }
-  }
+    const bool b = regex_match(value, result, regex);
 
-  // this case will go away eventually, once client code has been refactored to
-  // use get_memory() instead
-  {
-    // get void pointer address
-    const std::regex regex(R"(0x[1-9a-f][0-9a-f]*)");
-
-    std::smatch result;
-    if(regex_match(value, result, regex))
+    if(b)
     {
       return result[1];
     }
@@ -500,4 +496,15 @@ void gdb_apit::check_command_accepted()
   CHECK_RETURN(was_accepted);
 }
 
+std::string gdb_apit::r_opt(const std::string &regex)
+{
+  return R"((?:)" + regex + R"()?)";
+}
+
+std::string
+gdb_apit::r_or(const std::string &regex_left, const std::string &regex_right)
+{
+  return R"((?:)" + regex_left + '|' + regex_right + R"())";
+}
+
 #endif

src/memory-analyzer/gdb_api.h

@@ -41,14 +41,31 @@ class gdb_apit
   explicit gdb_apit(const char *binary, const bool log = false);
   ~gdb_apit();
 
+  struct pointer_valuet
+  {
+    pointer_valuet(
+      const std::string &address = "",
+      const std::string &pointee = "",
+      const std::string &character = "",
+      const optionalt<std::string> &string = nullopt)
+      : address(address), pointee(pointee), character(character), string(string)
+    {
+    }
+
+    const std::string address;
+    const std::string pointee;
+    const std::string character;
+    const optionalt<std::string> string;
+  };
+
   void create_gdb_process();
   void terminate_gdb_process();
 
   bool run_gdb_to_breakpoint(const std::string &breakpoint);
   void run_gdb_from_core(const std::string &corefile);
 
   std::string get_value(const std::string &expr);
-  std::string get_memory(const std::string &expr);
+  pointer_valuet get_memory(const std::string &expr);
 
   const commandst &get_command_log();
 
@@ -86,6 +103,27 @@ class gdb_apit
   bool most_recent_line_has_tag(const std::string &tag);
   bool was_command_accepted();
   void check_command_accepted();
+
+  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"((\\".*\\"))";
 };
 
 class gdb_interaction_exceptiont : public cprover_exception_baset

unit/memory-analyzer/gdb_api.cpp

@@ -45,11 +45,14 @@ void compile_test_file()
 
 class gdb_api_testt : public gdb_apit
 {
+public:
   explicit gdb_api_testt(const char *binary) : gdb_apit(binary)
   {
   }
 
   friend void gdb_api_internals_test();
+
+  using gdb_apit::r_hex_addr;
 };
 
 void gdb_api_internals_test()
@@ -151,7 +154,10 @@ TEST_CASE("gdb api test", "[core][memory-analyzer]")
     }
   }
 
-  gdb_apit gdb_api("test");
+  gdb_api_testt gdb_api("test");
+
+  std::regex hex_addr(gdb_api.r_hex_addr);
+
   gdb_api.create_gdb_process();
 
   SECTION("breakpoint is hit")
@@ -172,24 +178,73 @@ TEST_CASE("gdb api test", "[core][memory-analyzer]")
       gdb_api.run_gdb_to_breakpoint("checkpoint3"), gdb_interaction_exceptiont);
   }
 
-  SECTION("query memory")
+  SECTION("query variables, primitive types")
   {
     const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
     REQUIRE(r);
 
     REQUIRE(gdb_api.get_value("x") == "8");
-    REQUIRE(gdb_api.get_value("s") == "abc");
+    REQUIRE(gdb_api.get_value("y") == "2.5");
+    REQUIRE(gdb_api.get_value("z") == "c");
+  }
+
+  SECTION("query pointers")
+  {
+    const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
+    REQUIRE(r);
+
+    {
+      auto value = gdb_api.get_memory("s");
+      REQUIRE(std::regex_match(value.address, hex_addr));
+      REQUIRE(value.pointee.empty());
+      REQUIRE(value.character.empty());
+      REQUIRE(*value.string == "abc");
+    }
+
+    {
+      auto value = gdb_api.get_memory("p");
+      REQUIRE(std::regex_match(value.address, hex_addr));
+      REQUIRE(value.pointee == "x");
+      REQUIRE(value.character.empty());
+      REQUIRE(!value.string);
+    }
+
+    {
+      auto value = gdb_api.get_memory("vp");
+      REQUIRE(std::regex_match(value.address, hex_addr));
+      REQUIRE(value.pointee == "x");
+      REQUIRE(value.character.empty());
+      REQUIRE(!value.string);
+    }
 
-    const std::regex regex(R"(0x[1-9a-f][0-9a-f]*)");
+    {
+      auto value = gdb_api.get_memory("np");
+      REQUIRE(value.address == "0x0");
+      REQUIRE(value.pointee.empty());
+      REQUIRE(value.character.empty());
+      REQUIRE(!value.string);
+    }
 
     {
-      std::string address = gdb_api.get_memory("p");
-      REQUIRE(std::regex_match(address, regex));
+      auto value = gdb_api.get_memory("vp_string");
+      REQUIRE(std::regex_match(value.address, hex_addr));
+      REQUIRE(value.pointee.empty());
+      REQUIRE(value.character.empty());
+      REQUIRE(!value.string);
     }
+  }
+
+  SECTION("query expressions")
+  {
+    const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
+    REQUIRE(r);
 
     {
-      std::string address = gdb_api.get_memory("vp");
-      REQUIRE(std::regex_match(address, regex));
+      auto value = gdb_api.get_memory("&x");
+      REQUIRE(std::regex_match(value.address, hex_addr));
+      REQUIRE(value.pointee == "x");
+      REQUIRE(value.character.empty());
+      REQUIRE(!value.string);
     }
   }
 

unit/memory-analyzer/test.c

@@ -1,7 +1,12 @@
 int x;
+float y;
+char z;
+
 char *s = "abc";
 int *p;
 void *vp;
+int *np = 0;
+void *vp_string;
 
 void checkpoint()
 {
@@ -18,8 +23,12 @@ void func()
 int main()
 {
   x = 8;
+  y = 2.5;
+  z = 'c';
+
   p = &x;
   vp = (void *)&x;
+  vp_string = s;
 
   checkpoint();