How to override standard printf defined in gcc library

[RahulJain83 <jain dot nsit at gmail dot com>]

Hi,

I am Rahul. We have a complete software written out (with n other shared
libraries maintained by various other teams). The shared libraries are
loaded at run time by the main executable depending upon what feature user
wants to run. All across our code, we are using printf and fprintf to print
messages on the screen for the user. Now, we are adding a Graphical
interface to our software and require that all such messages are displayed
in a separate window inside that Graphical interface (whenever user is
running in Graphical mode, else messages should be printed to screen only).
For this, we need to overload printf and fprintf in our code. We have a
combination of C and C++ code, as well as due to vast code base distributed
across teams, it is not possible to replace printf/fprintf in all the code
with some other function. So, what we did, we defined our own printf and
fprintf functions that look something as follows -

extern "C" int fprintf (FILE *__restrict __stream,
       __const char *__restrict __format, ...)
{
   va_list args;

   va_start(args,__format);

   int return_status = 0;
   if (is_gui && (__stream == stdout || __stream == stderr)) {
       return_status = showMessageInGui(NULL, __format, args);
   }
   else {
       return_status = vfprintf(__stream, __format, args);
   }

   va_end(args);
   return return_status;
}
 

Above function is defined in main executable (where our main() lies). So,
above definition is loaded before fprintf from gcc library is loaded. I
guess, no fprintf should be picked from libgcc now.
Above code works fine for following fprintf calls (that pass variable
argument list to fprintf) -

fprintf (stdout,"This is a variable argument message - %s\n", "Rahul Jain");

However, for following fprintf call (that is not taking any variable
arguments), it seems fprintf from libgcc is getting picked up as then print
comes on the screen instead of our Graphical interface window -

fprintf (stdout,"This is a variable argument message - Rahul Jain\n");

I am not sure why this is happening. Is fprintf implemented as macro, such
that it is working for case1 and not for case2. Can anybody help.

If we look at the way by which the loader resolves various symbols on
loading an application, it does something as follows -

1. Load symbols defined and already binded in the executable
2. Load the shared library on which the application depends and then resolve
the still undefined symbols in the application.

In my case, loader finds that fprintf/printf are already defined in my
executable, so it should not lookup for this function while loading gcc
shared library.

It seems to be the case as in case#1 (with variable argument list given to
fprintf my own version is getting called). This does not happens for case #2
however.

I have also narrowed down that this issue comes with gcc 4.2.4 and not with
gcc 3.4.2.

You can easily reproduce this issue by creating a printf.c and defining your
version of fprintf in it and calling it from main (defined in main.c)

Does anyone know if any changes made between gcc 342 and gcc 424 that might
be causing this issue, and if there is any workaround to it by some build
time flags.

I would be really greateful if someone can help me and reply as soon as
possible, we have a hight priority delivery item and is very critical...
Really appreciate your help guys. Once again, thanks guys for your replies.
-- 
View this message in context: http://www.nabble.com/How-to-override-standard-printf-defined-in-gcc-library-tp26083189p26083189.html
Sent from the gcc - Help mailing list archive at Nabble.com.