CODEWITHSUNDEEP
ccompiler-optimization
Marcos
Marcos

Reputation: 117

C function that only returns input parameter

For reasons out of my control, I have to implement this function in my C code:

double simple_round(double u)
{
    return u;
}

When this function is called, is it ignored by the compiler, or does the call take place anyway? For instance:

int y;
double u = 3.3;

y = (int)simple_round(u*5.5); //line1
y = (int)u*5.5;               //line2

Will both lines of code take the same time to be executed, or will the first one take longer?

Upvotes: 3

Views: 123

Answers (3)

phuclv
phuclv

Reputation: 41794

When this function is called, is it ignored by the compiler, or does the call take place anyway?

It depends. If the function definition is in the same *.c file as the places where it's called then the compiler most probably automatically inlines it, because it has some criteria to inline very simple functions or functions that are called only once. Of course you have to specify a high enough optimization level

But if the function definition is in another compilation unit then the compiler can't help unless you use link-time optimization (LTO). That's because in C each *.c file is a separate compilation unit and will be compiled to a separate object (*.o) file and compilers don't know the body of functions in other compilation units. Only at the link stage the unresolved identifiers are filled with their info from the other compilation units

In this case the generated code in a *.c file calls a function that you can change in another *.c file then there are many more reliable solutions

  1. The most correct method is to fix the generator. Provide evidences to show that the function the generated code calls is terrible and fix it

  2. In case you really have no way to fix the generator then one possible way is to remove the generated *.c file from the compilation list (i.e. don't compile it into *.o anymore) and include it in your own *.c file

    #define simple_round(x) (x)
#include "generated.c"
#undef simple_round

    Now simple_round() calls in generated.c will be replaced with nothing

Upvotes: 2

Fe2O3
Fe2O3

Reputation: 8344

If the 'generated' code has to be compiled anyway, perhaps you can 'kludge' a macro, Macro, that redefines the call to the 'inefficient' rounding function made by that code.

Here's a notion (all in one file). Perhaps the #define can be 'shimmed in' (and documented!) into the makefile entry for that single source file.

int fnc1( int x ) { return 5 * x; }

void main( void ) {
    printf( "%d\n", fnc1( 5 ) );

#define fnc1(x) (x)

    printf( "%d\n", fnc1( 7 ) );
}

Output:

25
7

Upvotes: 2

Stack Exchange Broke The Law
Stack Exchange Broke The Law

Reputation: 58868

Because the function is defined in a different C file from where it's used, if you don't use link-time optimization, when the compiler calls the function call it won't know what the function does, so it will have to actually compile the function call. The function will probably just have two instructions: copy the argument to the return value, then return.

The extra function call may or may not slow down the program, depending on the type of CPU and what else the CPU is doing (the other instructions nearby)

It will also force the compiler to consider that it might be calling a very complicated function that overwrites lots of registers (whichever ones are allowed to be overwritten by a function call); this will make the register allocation worse in the function that calls it, perhaps making that function longer and making it need to do more memory accesses.

Upvotes: 2

Related Questions