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 a way to determine the size of a function. The command is:

 nm -S <object_file_name>

This will return the sizes of each function inside the object file. Consult the manual pages in the GNU using 'man nm' to gather more information on this.

Answer 2

You can get this information from the linker if you are using a custom linker script. Add a linker section just for the given function, with linker symbols on either side:

mysec_start = .;
*(.mysection)
mysec_end = .;

Then you can specifically assign the function to that section. The difference between the symbols is the length of the function:

#include <stdio.h>

int i;

 __attribute__((noinline, section(".mysection"))) void test_func (void)
{
    i++;
}

int main (void)
{
    extern unsigned char mysec_start[];
    extern unsigned char mysec_end[];

    printf ("Func len: %lu\n", mysec_end - mysec_start);
    test_func ();

    return 0;
}

This example is for GCC, but any C toolchain should have a way to specify which section to assign a function to. I would check the results against the assembly listing to verify that it's working the way you want it to.

Answer 3

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

Answer 4

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 5

Executables (at least ones which have debug info stripped) doesn't store function lengths in any way. So there's no possibility to parse this info in runtime by self. If you have to manipulate with functions, you should do something with your objects in linking phase or by accessing them as files from your executable. For example, you may tell linker to link symbol tables as ordinary data section into the executable, assign them some name, and parse when program runs. But remember, this would be specific to your linker and object format.

Also note, that function layout is also platform specific and there are some things that make the term "function length" unclear:

1. Functions may have store used constants in code sections directly after function code and access them using PC-relative addressing (ARM compilers do this).
2. Functions may have "prologs" and "epilogs" which may may be common to several functions and thus lie outside main body.
3. Function code may inline other function code

They all may count or not count in function length.

Also function may be completely inlined by compiler, so it loose its body.

Answer 6

A fully worked out solution without linker or dirty platform dependent tricks:

#include <stdio.h>

int i;

 __attribute__((noinline, section("mysec"))) void test_func (void)
{
    i++;
}

int main (void)
{
    extern char __start_mysec[];
    extern char __stop_mysec[];

    printf ("Func len: %lu\n", __stop_mysec - __start_mysec);
    test_func ();

    return 0;
}

That's what you get when you read FazJaxton's answer with jakobbotsch's comment

Answer 7

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 8

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.

Answer 9

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 10

There's no facility defined within the C language itself to return the length of a function; there are simply too many variables involved (compiler, target instruction set, object file/executable file format, optimization settings, debug settings, etc.). The very same source code may result in functions of different sizes for different systems.

C simply doesn't provide any sort of reflection capability to support this kind of information (although individual compilers may supply extensions, such as the Codewarrior example cited by sskuce). If you need to know how many bytes your function takes up in memory, then you'll have to examine the generated object or executable file directly.

sizeof func won't work because the expression func is being treated as a pointer to the function, so you're getting the size of a pointer value, not the function itself.

Answer 11

There is no standard way of doing it either in C or C++. There might naturally exist implementation/platform-specific ways of doiung it, but I am not aware of any

Answer 12

size_t try_get_func_size_x86(void* pfn, bool check_prev_opcode = true, size_t max_opcodes_runout = 10000)
{
    const unsigned char* op = (const unsigned char*)pfn;
    
    for(int i = 0; i < max_opcodes_runout; i++, op++)
    {
        size_t sz_at = (size_t)(op - (const unsigned char*)pfn) + 1;
        
        switch(*op)
        {
            case 0xC3: // ret Opcode
            case 0xC2: // ret x Opcode
            
            if(!check_prev_opcode)
                return sz_at;
                
            switch(*(op-1)) // Checking Previous Opcode
            {
                case 0x5D: //  pop    ebp
                case 0x5B: //  pop    ebx
                case 0x5E: //  pop    esi
                case 0x5F: //  pop    edi
                case 0xC9: //  leave
                    return sz_at;
            }
        }
    }

    return 0;
}

Answer 13

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.