Csdrhrt

I'm working on a project using nlohmann's json C++ implementation.

How can one easily explore nlohmann's JSON keys/vals in GDB ?

I tried to use this STL gdb wrapping since it provides helpers to explore STL structures that lohmann's JSON lib is using.
But I don't find it convenient.

Here is a simple use case:

json foo;

foo["flex"] = 0.2;

foo["awesome_str"] = "bleh";

foo["nested"] = {{"bar", "barz"}}; 

What I would like to have in GDB:

(gdb) p foo

{

    "flex" : 0.2,

    "awesome_str": "bleh",

    "nested": etc.

}

Current behavior

(gdb) p foo

$1 = {

  m_type = nlohmann::detail::value_t::object, 

  m_value = {

    object = 0x129ccdd0, 

    array = 0x129ccdd0, 

    string = 0x129ccdd0, 

    boolean = 208, 

    number_integer = 312266192, 

    number_unsigned = 312266192, 

    number_float = 1.5427999782486669e-315

  }

}

(gdb) p foo.at("flex")

Cannot evaluate function -- may be inlined // I suppose it depends on my compilation process. But I guess it does not invalidate the question.

(gdb) p *foo.m_value.object

$2 = {

  _M_t = {

    _M_impl = {

      <std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer> > > >> = {

        <__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer> > > >> = {<No data fields>}, <No data fields>}, 

      <std::_Rb_tree_key_compare<std::less<void> >> = {

        _M_key_compare = {<No data fields>}

      }, 

      <std::_Rb_tree_header> = {

        _M_header = {

          _M_color = std::_S_red, 

          _M_parent = 0x4d72d0, 

          _M_left = 0x4d7210, 

          _M_right = 0x4d7270

        }, 

        _M_node_count = 5

      }, <No data fields>}

  }

}

I found my own answer reading further the GDB capabilities and stack overflow questions concerning print of std::string.
The short path is the best option for now.

Short path

I simply defined a gdb command as follows:

# this is a gdb script

# can be loaded from gdb using

# source my_script.txt (or. gdb or whatever you like)

define pjson

# use the lohmann's builtin dump method, ident 4 and use space separator

printf "%sn", $arg0.dump(4, ' ', true).c_str()

end

# configure command helper (text displayed when typing 'help pjson' in gdb)

document pjson

Prints a lohmann's JSON C++ variable as a human-readable JSON string

end

Using it in gdb:

(gdb) source my_custom_script.gdb

(gdb) pjson foo

{

    "flex" : 0.2,

    "awesome_str": "bleh",

    "nested": {

        "bar": "barz"

    }

}

Over the top (but not working for me)

The other way is to define a GDB pretty printer in python and make it tightly associated to your project (autoloading stuff activated). See this link for an in-depth approach.

Basically, when in gdb you would type:

(gdb) p foo

and GDB will automagically test for foo's type and invoke the associated pretty printer if any. That would end-up in the same result. The main difference is that it is done using the well-known print command and more importantly, be effective even if there is no inferior process to call methods from (thanks Employed Russian for the precision). The person debugging would not have to learn a new command (like the pjson defined in the short answer).

Below, some GDB doc extract + a python code attempt that does not work.

Quoting:

A pretty-printer consists of two parts: a lookup function to detect if the type is supported, and the printer itself.

Here is an example showing how a std::string printer might be written. See Pretty Printing API, for details on the API this class must provide.

class StdStringPrinter(object):

    "Print a std::string"



    def __init__(self, val):

        self.val = val



    def to_string(self):

        return self.val['_M_dataplus']['_M_p']



    def display_hint(self):

        return 'string'

Still quoting for the sake of completness:

And here is an example showing how a lookup function for the printer example above might be written.

def str_lookup_function(val):

    lookup_tag = val.type.tag

    if lookup_tag == None:

        return None

    regex = re.compile("^std::basic_string<char,.*>$")

    if regex.match(lookup_tag):

        return StdStringPrinter(val)

    return None

I tried to implement it this way. However, I have a 100% failure rate with the following code, with cryptic GDB error messages (see below the code sample)

Nota: it relies on the trick provided here that is supposed to allow a C++ class method call within GDB, bypassing the Value.Type check (object methods can be found and their value.Type would be gdb.TYPE_CODE_METHOD, but gdb python won't consider them callable. Only gdb.TYPE_CODE_FUNC are callable. So, parse_and_evalacts as an hack to perform actual method call).

import gdb

import re



class StdStringPrinter(object):

    """Print a std::string"""

    def __init__(self, val):

        self.val = val

    def to_string(self):

        eval_string = "(*("+str(self.val.type)+"*)("+str(self.val.address)+")).c_str()" # works 50% of the time ...

        return gdb.parse_and_eval(eval_string)

    def display_hint(self):

        return 'string'



class LohmannJSONPrinter(object):

    """Print a nlohmann::json"""

    def __init__(self, val):

        self.val = val

    def to_string(self):



        # workaround from here:

        # https://stackoverflow.com/a/22798055/7237062

        # "(*("+str(self.val.type)+"*)("+str(self.val.address)+")).method()"

        eval_string = '(*('+str(self.val.type)+'*)('+str(self.val.address)+')).dump(4, " ", true)'

        return gdb.parse_and_eval(eval_string) # fails 100% of the time

    def display_hint(self):

        return self.val.type



def build_pretty_printer():

    pp = gdb.printing.RegexpCollectionPrettyPrinter("foo")

    json = r"nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer>"

    pp.add_printer('nlohmann::json', json, LohmannJSONPrinter)

    return pp



# executed at autoload gdb.printing.register_pretty_printer(gdb.current_objfile(),

                                     build_pretty_printer())

Errors:

Cannot insert breakpoint -18. // or any negative value

Cannot access memory at address 0x111a2180 // appears to be a fixed value at each execution

Python Exception <class 'gdb.error'> Command aborted.

or

$2 = Python Exception <class 'gdb.error'> Attempt to take address of value not located in memory.:

Edit 2019-march-24 : add precision given by employed russian.