what is the difference between a label and a function in assembly

Question

have been following an assembly tutorial on youtube here through AT&T syntax. I have just learned about declaring(if that's the correct term here) a function with the .type directive, such as:

.type MyFunction, @function

Now I can define my function like:

MyFunction:
    <code here>

And subsequently call it whenever:

call MyFunction

I know that previous to this in the tutorials, we were simply creating a label that was attached to some code:

MyLabel:
    <code here>

which could then be called like this:

call MyLabel

So my questions are:

What exactly is the difference between a function declared with .type, and and 'function' declared simply with a label? When should one be used over the other, or does it matter?

Answer 1

Here's what the binutils docs say about the .type directive (assuming you are using the GNU assembler):

This directive is used to set the type of a symbol.

...

For ELF targets, the .type directive is used like this:

.type name , type description

According to the docs on Symbol Type:

The type attribute of a symbol contains relocation (section) information, any flag settings indicating that a symbol is external, and (optionally), other information for linkers and debuggers. The exact format depends on the object-code output format in use.

.type MyFunction, @function marks the label MyFunction (which is a symbol) as a function for the linker or debugger.

When writing pure assembly files by hand, this is unnecessary. Here's an example of a file in which an itoa function is called. As you can see, there are no directives preceding the label.

In summary, labels can be marked as functions, but to executing code, it's just a jump target either way.

Answer 2

As far as the CPU is concerned, there is no difference. Many assemblers don't require you to declare .type MyFunction, @function at all; rather, you just put MyFunction wherever you want and then call MyFunction to go there.

Labels are a feature of assemblers that makes them much better to use than what people did before they existed (i.e. putting in the bytes with a hex editor.) A code label like

MyFunction:
nop
ret

is effectively a constant pointer to the instruction directly below it, in this case the nop. Based on how much code is in your file, and where it is, the label MyFunction equals some number, but it's much easier to let the assembler manage that for us.

Imagine if we had no labels. We'd have to remember what address MyFunction is at, and every time we change our program we'd have to manually update all the jmp and call statements with the correct destination. Sounds terrible, doesn't it?

Relative branches are handled differently, but the end result is the same. For something like this:

MyFunction:
add eax,ebx
jne MyFunction

The MyFunction in jne MyFunction isn't encoded as a constant address, but is a signed offset that gets added to/subtracted from %rip in order to make it equal to whatever the memory location corresponding to MyFunction is.

EDIT: On x86 jmp and call are also relative as in the above example, but this is not the case for all architectures.

Answer 3

I think whatever assembly you use the point is the return command. Whatever name for "return" in you assembler is used. Calling a function differs from branching in the fact that some context data (status register with N, C, V bits, program counter) are pushed/stored into stack. When the return command is executed the data from stack are restored. It is needed for ability to remain program execution from the address just after your function call.