__declspec(naked) and function body size

__declspec(naked) and function body size

[Ilyes Gouta]

Hi,

I'd like to do the following thing under Linux using GCC.

/* __declspec(naked) is Microsoft's C compiler specific. */

__declspec(naked) int function1()
{
	/* dummy stub dumped by the JIT. */

	int a = 0, b = 1;
	int c = a + b;

	return (c);
}
__declspec(naked) void end_function1() {}

unsigned char t[256];

void main()
{
	/* I'd like to do the following, i.e copying code around. */
	memcpy(t, function1, end_function1 - function1);
}

Is it possible using GCC? If yes, could you please tell me how?

Best regards,
Ilyes Gouta.

Re: __declspec(naked) and function body size

[Brian Dessent]

Ilyes Gouta wrote:

> Is it possible using GCC? If yes, could you please tell me how?

There is __attribute__((naked)) but it's not supported for x86.  I think
the feeling is that gcc should be able to detect when a prologue is not
necessary on its own and just not emit it, and that forcably disabling
the prologue just results in horribly broken code if the function
happens to require a spill.  See also
<http://gcc.gnu.org/ml/gcc/2004-02/threads.html#00939>.

Brian

Re: __declspec(naked) and function body size

[Ilyes Gouta]

Hi,

Thank you for your reply!

Is it possible to get the size of a function, i.e the number of bytes generated by the compiler between the prologue and 
the final routine's ret instruction, so that it would be available through a 'sizeof' like operator for the other code?

It would be possible to do,

int a = sizeof(some_function);

I'm not expecting the standard sizeof to do that, but I'm looking for possibly another operator or some proprietary GCC 
extensions. I'm writing a JIT for my simplified C language and I'd like to copy template code around and patch it when 
necessary (and not only emitting opcode by opcode in the code buffers).

BR,
Ilyes Gouta.

Brian Dessent wrote:
> Ilyes Gouta wrote:
> 
>> Is it possible using GCC? If yes, could you please tell me how?
> 
> There is __attribute__((naked)) but it's not supported for x86.  I think
> the feeling is that gcc should be able to detect when a prologue is not
> necessary on its own and just not emit it, and that forcably disabling
> the prologue just results in horribly broken code if the function
> happens to require a spill.  See also
> <http://gcc.gnu.org/ml/gcc/2004-02/threads.html#00939>.
> 
> Brian
> 

Re: __declspec(naked) and function body size

[Brian Dessent]

Ilyes Gouta wrote:

> Is it possible to get the size of a function, i.e the number of bytes generated by the compiler between the prologue and
> the final routine's ret instruction, so that it would be available through a 'sizeof' like operator for the other code?

You can do this at the assembler level:

int foo()
{
  int a = 0, b = 1;
  int c = a + b;

  return (c);
}

asm(".set foo_size, .-foo");
extern unsigned foo_size;                

int main()
{
  unsigned char buf[512];

  memcpy (buf, foo, foo_size);
}

There are two problems with this:

1. In unit-at-a-time mode (which is enabled by default when optimizing)
the compiler does not guarantee that functions and top-level asm
statements are emitted in the same order as specified in the input
source.  Since this technique requires that the asm() come immediately
after the function it refers to, this will break.  So you have to use
-fno-unit-at-a-time (for gcc < 4.2.0) or preferably
-fno-toplevel-reorder (for gcc >= 4.2.0) unless you use -O0.

2. The asm has to be adjusted if you want it to work on
leading-underscore targets.  For example on win32 you'd need to use
something like asm(".set _foo_size, .-_foo") instead.  I suppose you
could abstract this away with some macro junk:

#define ASMNAME(cname)          ASMNAME2 (__USER_LABEL_PREFIX__, cname)
#define ASMNAME2(prefix, cname) STRING (prefix) cname
#define STRING(x)               #x

// ...

asm(".set " ASMNAME("foo_size") ", .-" ASMNAME("foo"));
extern unsigned foo_size;

Brian

Re: __declspec(naked) and function body size

[Ilyes Gouta]

Hi,

Thank you so much, Brian, for your help.
I'm going to try this out and see if it fits my requirements.

BR,
Ilyes Gouta.

Brian Dessent wrote:
> Ilyes Gouta wrote:
> 
>> Is it possible to get the size of a function, i.e the number of bytes generated by the compiler between the prologue and
>> the final routine's ret instruction, so that it would be available through a 'sizeof' like operator for the other code?
> 
> You can do this at the assembler level:
> 
> int foo()
> {
>   int a = 0, b = 1;
>   int c = a + b;
> 
>   return (c);
> }
> 
> asm(".set foo_size, .-foo");
> extern unsigned foo_size;                
> 
> int main()
> {
>   unsigned char buf[512];
> 
>   memcpy (buf, foo, foo_size);
> }
> 
> There are two problems with this:
> 
> 1. In unit-at-a-time mode (which is enabled by default when optimizing)
> the compiler does not guarantee that functions and top-level asm
> statements are emitted in the same order as specified in the input
> source.  Since this technique requires that the asm() come immediately
> after the function it refers to, this will break.  So you have to use
> -fno-unit-at-a-time (for gcc < 4.2.0) or preferably
> -fno-toplevel-reorder (for gcc >= 4.2.0) unless you use -O0.
> 
> 2. The asm has to be adjusted if you want it to work on
> leading-underscore targets.  For example on win32 you'd need to use
> something like asm(".set _foo_size, .-_foo") instead.  I suppose you
> could abstract this away with some macro junk:
> 
> #define ASMNAME(cname)          ASMNAME2 (__USER_LABEL_PREFIX__, cname)
> #define ASMNAME2(prefix, cname) STRING (prefix) cname
> #define STRING(x)               #x
> 
> // ...
> 
> asm(".set " ASMNAME("foo_size") ", .-" ASMNAME("foo"));
> extern unsigned foo_size;
> 
> Brian
>