Determining if a FUNCTION_DECL node is a C++ template specialization

[Joe Doyle <joe at tanner-doyle dot net>]

Hello,

I'm writing a plugin to print out the GENERIC tree of a C++ source file.

Here's the source code to be translated:

////////////
template <typename T>
struct S
{
    void f()
    {
    }
};


template <>
struct S<int>
{
    void f()
    {
    }
};


void g()
{
    S<float> v;
    v.f();

    S<int> u;
    u.f();
}
//////////


Here's the output of the plugin:

::S::f test_plugin2.cpp:14                           <-------- want to
see ::S<int>::f here
   parm_decl is unhandled NO LOC
   statement_list is unhandled NO LOC
::g test_plugin2.cpp:20
   bind_expr test_plugin2.cpp:26
      var_decl is unhandled NO LOC
      statement_list is unhandled NO LOC
      block is unhandled NO LOC
::S<_unexpected_real_type>::f test_plugin2.cpp:4  <---- plugin prints
S<float>::f, as expected
   parm_decl is unhandled NO LOC
   template_info is unhandled NO LOC
   statement_list is unhandled NO LOC


I've guessed at which tree fields would indicate if a node is a
specialized template definition, but have had no luck
(DECL_USE_TEMPLATE, DECL_TEMPLATE_PARM_P, DECL_ABSTRACT_ORIGIN,
DECL_TEMPLATE_INSTANTIATED).

Any advice on how to properly print the template parameters of a
specialized template would be much appreciated.

Thanks,
Joe



$ gcc48 --version

gcc48 (GCC) 4.8.1
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ g++48 --std=c++11 -O0 -ggdb -I`g++48
-print-file-name=plugin`/include -fPIC -shared plugin4.cpp -o
plugin4.so
In file included from
/opt/gcc-4.8.1/usr/local/bin/../lib/gcc/x86_64-unknown-linux-gnu/4.8.1/plugin/include/tm.h:28:0,
                 from plugin4.cpp:15:
/opt/gcc-4.8.1/usr/local/bin/../lib/gcc/x86_64-unknown-linux-gnu/4.8.1/plugin/include/config/elfos.h:102:21:
warning: invalid suffix on literal; C++11 requires a space between
literal and identifier [-Wliteral-suffix]
    fprintf ((FILE), "%s"HOST_WIDE_INT_PRINT_UNSIGNED"\n",\
                     ^
/opt/gcc-4.8.1/usr/local/bin/../lib/gcc/x86_64-unknown-linux-gnu/4.8.1/plugin/include/config/elfos.h:170:24:
warning: invalid suffix on literal; C++11 requires a space between
literal and identifier [-Wliteral-suffix]
       fprintf ((FILE), ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n",  \
                        ^
In file included from
/opt/gcc-4.8.1/usr/local/bin/../lib/gcc/x86_64-unknown-linux-gnu/4.8.1/plugin/include/tm.h:42:0,
                 from plugin4.cpp:15:
/opt/gcc-4.8.1/usr/local/bin/../lib/gcc/x86_64-unknown-linux-gnu/4.8.1/plugin/include/defaults.h:126:24:
warning: invalid suffix on literal; C++11 requires a space between
literal and identifier [-Wliteral-suffix]
       fprintf ((FILE), ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n",  \
                        ^
$ g++48 -S -fplugin=./plugin4.so test_plugin2.cpp
::S::f test_plugin2.cpp:14
   parm_decl is unhandled NO LOC
   statement_list is unhandled NO LOC
::g test_plugin2.cpp:20
   bind_expr test_plugin2.cpp:26
      var_decl is unhandled NO LOC
      statement_list is unhandled NO LOC
      block is unhandled NO LOC
::S<_unexpected_real_type>::f test_plugin2.cpp:4
   parm_decl is unhandled NO LOC
   template_info is unhandled NO LOC
   statement_list is unhandled NO LOC



////// plugin4.cpp

#include <stdlib.h>
#include <gmp.h>

#include <cstdlib>

#include "gcc-plugin.h"

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "intl.h"

#include "tm.h"

#include "cp/cp-tree.h"
#include "c-family/c-common.h"
#include "c-family/c-pragma.h"
#include "diagnostic.h"
#include "tree-iterator.h"

#include <iostream>
#include <sstream>
#include <string>

int plugin_is_GPL_compatible;


const char* indent_spaces =
    "                                                                       "
    "                                                                       "
    "                                                                       "
    "                                                                       "
    "                                                                       "
    "                                                                       "
    "                                                                       "
    "                                                                       "
    "                                                                       "
    "                                                                       "
    "                                                                       "
    ;

int indent_cnt = 3;

std::string expr_loc (tree decl)
{
    if (EXPR_HAS_LOCATION(decl))
    {
        std::ostringstream ostr;
        ostr << EXPR_FILENAME(decl) << ':' << EXPR_LINENO(decl);
        return ostr.str();
    }

    return "NO LOC";
}


tree build_scope_string (tree scope, std::string& s)
{
    if (TREE_CODE(scope) == RECORD_TYPE ||
        TREE_CODE(scope) == ENUMERAL_TYPE)
    {
        if (TYPE_NAME (scope))
            scope = TYPE_NAME (scope);
        //tmp_scope = TYPE_CANONICAL(scope);
        else
            scope = TYPE_NAME (TYPE_CANONICAL(scope));
        // if (tmp_scope)
        //     scope
    }
    tree id = 0;
    if (scope)
        id = DECL_NAME (scope);

    const char* id_ptr = (id != 0 ? IDENTIFIER_POINTER (id) : "<unnamed>");
    id_ptr = id_ptr ? id_ptr : "<nullptr>";

    int name_len = strlen (id_ptr);
    while (name_len > 0 && id_ptr[name_len-1] == ' ') --name_len;

    // namespaces.push_back (id_ptr);

    std::string tmp = "::";
    tmp += std::string (id_ptr, name_len);
    tmp += s;
    s.swap (tmp);

    return scope;
}


std::string
decl_scope (tree decl)
{
    std::string s;

    for (tree scope (CP_DECL_CONTEXT (decl));
         scope != global_namespace && scope;
         scope = CP_DECL_CONTEXT (scope))
    {
        scope = build_scope_string (scope, s);
        if (!scope)
            break;
    }

    return s;
}


std::string
type_scope (tree decl)
{
    std::string s;

    for (tree scope (CP_TYPE_CONTEXT (decl));
         scope != global_namespace && scope;
         scope = CP_TYPE_CONTEXT (scope))
    {
        scope = build_scope_string (scope, s);
        if (!scope)
            break;
    }

    return s;
}


void print_type (tree type, std::ostream& ostr);


void
print_decl (tree decl, std::ostream& ostr)
{
    // int tc (TREE_CODE (decl));
    tree id (DECL_NAME (decl));
    const char* name (id ? IDENTIFIER_POINTER (id) : "<unnamed>");

    if (!name) name = "null_name";

    std::string scope_name = decl_scope (decl);
    ostr << scope_name;

    if (DECL_LANG_SPECIFIC(decl) && DECL_TEMPLATE_INFO(decl))
    {
        tree ti = DECL_TEMPLATE_INFO(decl);
        ostr << '<';
        bool first = true;
        tree tparm = TI_ARGS(ti);
        while (tparm != 0)
        {
            for (int i = 0; i < TREE_VEC_LENGTH(tparm); ++i)
            {
                if (!first)
                    ostr << ',';

                first = false;
                print_type (TREE_VEC_ELT (tparm, i), ostr);
            }

            tparm = TREE_CHAIN (tparm);
        }
        ostr << '>';
    }

    ostr << "::" << name;
}


void print_type (tree type, std::ostream& ostr)
{
    if (TREE_CODE (type) == POINTER_TYPE)
    {
        print_type (TREE_TYPE(type), ostr);
        ostr << '*';
    }
    else if (TREE_CODE (type) == REFERENCE_TYPE)
    {
        print_type (TREE_TYPE(type), ostr);
        ostr << '&';
    }
    else if (RECORD_OR_UNION_TYPE_P (type))
    {
        tree type_name = TYPE_NAME (type);
        if (!type_name)
        {
            ostr << "_NULL_type_name_";
        }
        else if (TREE_CODE(type_name) == TYPE_DECL)
        {
            print_decl (type_name, ostr);
        }
        else if (TREE_CODE(type_name) == IDENTIFIER_NODE)
        {
            ostr << type_scope (type) << "::";

            const char* name (type_name ? IDENTIFIER_POINTER (type_name) :
                              "<unnamed>");
            if (!name) name = "null_name";
            int name_len = strlen (name);
            while (name_len > 0 && name[name_len-1] == ' ') --name_len;
            ostr.write (name, name_len);
        }
    }
    else if (TREE_CODE(type) == INTEGER_TYPE)
    {
        ostr << "_int_" << TYPE_MIN_VALUE(type) << '_' << TYPE_PRECISION(type);
    }
    else
    {
        int tc (TREE_CODE (type));
        ostr << "_unexpected_" << tree_code_name[tc];
    }
}


void print_tree (tree decl, int level)
{
    if (!decl)
        return;

    if (TREE_CODE(decl) == FUNCTION_DECL)
    {
        // std::cout.write (indent_spaces, indent_cnt * level);
        // std::cout << "decl_use_template " << (DECL_USE_TEMPLATE(decl))
        //           << std::endl;
        // std::cout.write (indent_spaces, indent_cnt * level);
        // std::cout << "decl_templ_parm_p " << (DECL_TEMPLATE_PARM_P(decl))
        //           << std::endl;
        // std::cout.write (indent_spaces, indent_cnt * level);
        // std::cout << "decl_abstract_origin "
        //           << (DECL_ABSTRACT_ORIGIN(decl))
        //           << std::endl;
        // std::cout.write (indent_spaces, indent_cnt * level);
        // std::cout << "decl_template_instantiated "
        //           << (DECL_TEMPLATE_INSTANTIATED(decl))
        //           << std::endl;
        // std::cout.write (indent_spaces, indent_cnt * level);
        print_decl (decl, std::cout);
        std::cout << " " << DECL_SOURCE_FILE (decl) << ":"
                  << DECL_SOURCE_LINE (decl) << std::endl;
        for (tree parm = DECL_ARGUMENTS(decl);
             parm != 0; parm = TREE_CHAIN (parm))
        {
            print_tree (parm, level+1);
        }
        if (DECL_TEMPLATE_INFO(decl))
        {
            print_tree (DECL_TEMPLATE_INFO(decl), level+1);
        }

        if (DECL_SAVED_TREE(decl))
        {
            // print_decl (decl, std::cout);

            // std::cout << ' ' << DECL_SOURCE_FILE (decl) << ':'
            //           << DECL_SOURCE_LINE (decl);

            // std::cout << std::endl;

            tree init_stmt = DECL_SAVED_TREE(decl);
            print_tree (init_stmt, level+1);
        }
        return;
    }

    if (EXPRESSION_CLASS_P(decl) ||
        UNARY_CLASS_P(decl) ||
        VL_EXP_CLASS_P(decl) ||
        EXPRESSION_CLASS_P(decl) ||
        REFERENCE_CLASS_P(decl))
    {
        std::cout.write (indent_spaces, indent_cnt * level);
        std::cout << tree_code_name[TREE_CODE(decl)] << ' '
                  << expr_loc(decl) << std::endl;

        for (int i = 0; i < TREE_OPERAND_LENGTH(decl); ++i)
        {
            tree operand = TREE_OPERAND (decl, i);
            print_tree (operand, level+1);
        }
        return;
    }

    std::cout.write (indent_spaces, indent_cnt * level);
    std::cout << tree_code_name[TREE_CODE(decl)] << " is unhandled "
              << expr_loc(decl) << std::endl;

    return;
}

extern "C" void
gate_callback (void* arg1, void* arg2)
{
    // If there were errors during compilation,
    // let GCC handle the exit.
    //
    if (errorcount || sorrycount)
        return;

    tree tree_arg = (tree) arg1;
    print_tree (tree_arg, 0);
}


extern "C" int
plugin_init (plugin_name_args* info,
             plugin_gcc_version* ver)
{
    // Disable assembly output.
    //
    asm_file_name = HOST_BIT_BUCKET;

    // Register callbacks.
    //
    register_callback (info->base_name,
                       //PLUGIN_OVERRIDE_GATE,
                       PLUGIN_PRE_GENERICIZE,
                       &gate_callback,
                       0);
    return 0;
}