G++ Modification Question

[Brendon Costa <bcosta at avdat dot com dot au>]

Hi all,

   A while ago I attempted to make a modification to gcc 4.0 before it 
was released. I attempted to create a modification that would allow me 
to document all exceptions that are eithre thrown directly by a 
function/method or that could propagate through a function/method. I ran 
into a few problems along the way and this email is to ask a few 
questions about gcc internals and better ways of coding in gcc so that I 
can re-write this module to work correctly. (Sorry it is so long)

The modification I made to the C++ front end would parse the 
global_namespace tree in the function cp_parser_translation_unit (found 
in cp/parser.c) and create a database that maps a function/method to all 
calls it made to other functions/methods and also a list of all 
exceptions thrown directly by it. This database file was appended to for 
each run of g++ and so after compiling a whole project the database 
would(Should) contain the details for all methods in that project. I 
then wrote a post-processing tool that went through the database and 
generated a list of all exceptions that could propagate through a 
particular function/method and also a seperate list of all exceptions 
that would be thrown directly by the method.

In concept it worked, but my implementation of the tree parser did not 
always work... A simple problem was that if I was to compile a small 
file like:

---main.cpp---
void Function1();
void Function2();

int main()
{
   Function1();
   return 0;
}

void Function1()
{
   throw 1;
}

void Function2()
{
   throw 2;
}

------------


Then the database would contain the information as expected for 
Function1() but not for Function2(). The parser would come across a 
definition for funciton 2 but there was no function body segment in the 
tree for me to process and find out if it threw exceptions or called 
other functions. This problem also seemed to occurr for all library 
files I compiled. Is this some optimisation done by gcc and is there 
another place where I can get access to a global tree that represents 
ALL source code that has been parsed?


Also I was wondering if I was parsing the best tree for this problem. 
The tree I was parsing was the tree found in the variable:

   global_namespace

in the file:

   cp/parser.c

in the function:

   static bool cp_parser_translation_unit(cp_parser* parser)

just after the call to:

   finish_translation_unit();

Another problem with the method I was using is that some of the tree 
nodes that I expected to find in the tree were not avaliable, it was as 
if they had already been translated to more primitive node types. For 
example I did not see any tree nodes of type:

         EH_SPEC_BLOCK
         TRY_BLOCK
         THROW_EXPR
         EH_FILTER_EXPR
         CATCH_EXPR

(Note I could be wrong about some of those expressions. I do however 
remember that instead of getting a THROW_EXPR I had to search for calls 
to the __cxa_throw() function to know when an exception was thrown. I 
cant remember how I handled the try/catch blocks though I did).


I would like to re-write this code at some point and I am looking for 
some pointers on ways of doing things better/differently. In particular 
I would like to know if the method I was using as described above is 
fine, or if there is a better tree to parse to get the information I 
need or a better place to process the tree from.

If anyone is able to help me or even point me to the place where I can 
get more help on this then I would greatly appreciate it.

I feel that a tool which enables me to see what exceptions can possibly 
propagate through what methods could be very useful. It could also warn 
of exceptions that could possibly propagate through methods whose 
exception specification block do not support it. I was also looking at 
modifying doxygen to automatically import this data into its 
documentation, but that is another topic.

Thanks,
Brendon.