gcc -finline-functions behaviour?

Question

I'm using gcc with the -finline-functions optimization for release builds. In order to combat code bloat because I work on an embedded system I want to say don't inline particular functions. The obvious way to do this would be through function attributes ie attribute(noinline). The problem is this doesn't seem to work when I switch on the global -finline-functions optimisation which is part of the -O3 switch.

It also has something to do with it being templated as a non templated version of the same function doesn't get inlined which is as expected.

Has anybody any idea of how to control inlining when this global switch is on?

Here's the code:

#include <cstdlib>
#include <iostream>

using namespace std;

class Base
{
public:

    template<typename _Type_>
    static _Type_ fooT( _Type_ x, _Type_ y ) __attribute__ (( noinline ));
};

template<typename _Type_>
_Type_ Base::fooT( _Type_ x, _Type_ y )
{
    asm("");
    return x + y;
}


int main(int argc, char *argv[])
{
    int test = Base::fooT( 1, 2 );
    printf( "test = %d\n", test );

    system("PAUSE");
    return EXIT_SUCCESS;
}

Answer 1

The docs for GCC's noinline say:

This function attribute prevents a function from being considered for inlining. If the function does not have side-effects, there are optimizations other than inlining that causes function calls to be optimized away, although the function call is live. To keep such calls from being optimized away, put

     asm ("");

(see Extended Asm) in the called function, to serve as a special side-effect

I think that what might be happening to you is that since the Base::fooT<> function has no side-effects, GCC is invoking the unspecified other optimizations mentioned above.

Answer 2

Try putting the noinline attribute after the static and before the definition like so:

   template<typename _Type_>
    static __attribute__ (( noinline )) _Type_ fooT( _Type_ x, _Type_ y );

This worked for me and seems to work for others too, see: How can I tell gcc not to inline a function?

For some reason it doesn't work putting the noinline attribute after the function or by putting the asm("") in the function body despite what the gcc documentation says.

Answer 3

Little old thread but worth answering. If nothing above works for you there is always simple workaround. You must hide implementation from translation unit where you want to use such a method by putting it in another cpp file.

EDIT

In GCC >= 4.5 there is an attribute noclone which supersede noinline in way of specializing the function.