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.