How to get the length of a function in bytes?

Question

I want to know the length of C function (written by me) at runtime. Any method to get it? It seems sizeof doesn\'t work here.

Answer 1

There is no way in standard C to get the amount of memory occupied by a function.

Answer 2

I have just came up with a solution for the exact same problem but the code i have written is platform depended.

The idea behind, putting known opcodes at the end of the function and searching for them from start while counting bytes we have skipped. Here is the medium link which i have explained with some code https://medium.com/@gurhanpolat/calculate-c-function-size-x64-x86-c1f49921aa1a

Answer 3

Just subtract the address of your function from the address of the next function. But note it may not work on your system, so use it only if you are 100% sure:

#include <stdint.h>

int function() {
    return 0;
}

int function_end() {
    return 0;
}

int main(void) {
    intptr_t size = (intptr_t) function_end - (intptr_t) function;
}

Answer 4

You can find the length of your C function by subtracting the addresses of functions. Let me provide you an example

int function1()
    {
    } 

int function2()
{
    int a,b;    //just defining some variable for increasing the memory size
    printf("This function would take more memory than earlier function i.e function01 ");
}

int main()
{
    printf("Printing the address of function01 %p\n",function01);
    printf("Printing the address of function02 %p\n",function02);
    printf("Printing the address of main %p\n",main);
    return 0;
}

Hope you would get your answer after compiling it. After compiling you will able to see the difference in size of function01 and function2.

Note : Normally there is 16bytes diff between one function and other.

Answer 5

In e.g. Codewarrior, you can place labels around a function, e.g.

label1:
void someFunc()
{
    /* code goes here. */
}
label2:

and then calculate the size like (int)(label2-label1), but this is obviously very compiler dependent. Depending on your system and compiler, you may have to hack linker scripts, etc.

Answer 6

The start of the function is the function pointer, you already know that.

The problem is to find the end, but that can be done this way:

#include <time.h>

int foo(void)
{
   int i = 0;
   ++i + time(0); // time(0) is to prevent optimizer from just doing: return 1;
   return i;
}

int main(int argc, char *argv[])
{
   return (int)((long)main - (long)foo);
}

It works here because the program has ONLY TWO functions so if the code is re-ordered (main implemented before foo) then you will get an irrelevant (negative) calculation, letting you know that it did not work this way but that it WOULD work if you move the foo() code into main() - just substract the main() size you got with the initial negative reply.

If the result is positive, then it will be correct -if no padding is done (yes, some compilers happily inflate the code, either for alignment or for other, less obvious reasons).

The ending (int)(long) cast is for portability between 32-bit and 64-bit code (function pointers will be longer on a 64-bit platform).

This is faily portable and should work reasonably well.