Function set_parameter_string

src/backward.h:2887–2996

Types are resolved from right to left: we get the variable name first and then all specifiers (like const or pointer) in a chain of DW_AT_type DIEs. Call this function recursively until we get a complete type string.

    // DIEs. Call this function recursively until we get a complete type
    // string.
    static void set_parameter_string(dwarf_fileobject& fobj, Dwarf_Die die, type_context_t& context)
    {
        char* name;
        Dwarf_Error error = DW_DLE_NE;

        // typedefs contain also the base type, so we skip it and only
        // print the typedef name
        if (!context.is_typedef) {
            if (dwarf_diename(die, &name, &error) == DW_DLV_OK) {
                if (!context.text.empty()) {
                    context.text.insert(0, " ");
                }
                context.text.insert(0, std::string(name));
                dwarf_dealloc(fobj.dwarf_handle.get(), name, DW_DLA_STRING);
            }
        }
        else {
            context.is_typedef = false;
            context.has_type = true;
            if (context.is_const) {
                context.text.insert(0, "const ");
                context.is_const = false;
            }
        }

        bool next_type_is_const = false;
        bool is_keyword = true;

        Dwarf_Half tag = 0;
        Dwarf_Bool has_attr = 0;
        if (dwarf_tag(die, &tag, &error) == DW_DLV_OK) {
            switch (tag) {
                case DW_TAG_structure_type:
                case DW_TAG_union_type:
                case DW_TAG_class_type:
                case DW_TAG_enumeration_type:
                    context.has_type = true;
                    if (dwarf_hasattr(die, DW_AT_signature, &has_attr, &error) == DW_DLV_OK) {
                        // If we have a signature it means the type is defined
                        // in .debug_types, so we need to load the DIE pointed
                        // at by the signature and resolve it
                        if (has_attr) {
                            std::string type = get_type_by_signature(fobj.dwarf_handle.get(), die);
                            if (context.is_const)
                                type.insert(0, "const ");

                            if (!context.text.empty())
                                context.text.insert(0, " ");
                            context.text.insert(0, type);
                        }

                        // Treat enums like typedefs, and skip printing its
                        // base type
                        context.is_typedef = (tag == DW_TAG_enumeration_type);
                    }
                    break;
                case DW_TAG_const_type:
                    next_type_is_const = true;