www.digitalmars.com         C & C++   DMDScript  

D - syntactic sugar for asm functions

reply "Pavel Minayev" <evilone omen.ru> writes:
I remember I've raised this topic long ago, but it wasn't much discussed
and I've thought it's time to raise it again since D now has inline
asm.

What about allowing function body to be a single asm statement?

    extern(C) uint crc32(void* data, int len) asm
    {
        // assembler goes here
    }

This is a very nice feature Borland Pascal implementations have,
it makes the code somewhat neater compared to:

    extern(C) uint crc32(void* data, int len)
    {
        asm
        {
            // assembler goes here
        }
    }

Not a big change anyhow... what do you think of it?
Feb 27 2002
next sibling parent "DigitalMars" <gedumer bcpl.net> writes:
Actually... I prefer the 2nd form and think it is much more obvious as to
intent.

Gary.

Pavel Minayev <evilone omen.ru> wrote in message
news:a5ietg$p0l$1 digitaldaemon.com...
 I remember I've raised this topic long ago, but it wasn't much discussed
 and I've thought it's time to raise it again since D now has inline
 asm.

 What about allowing function body to be a single asm statement?

     extern(C) uint crc32(void* data, int len) asm
     {
         // assembler goes here
     }

 This is a very nice feature Borland Pascal implementations have,
 it makes the code somewhat neater compared to:

     extern(C) uint crc32(void* data, int len)
     {
         asm
         {
             // assembler goes here
         }
     }

 Not a big change anyhow... what do you think of it?

Feb 27 2002
prev sibling parent reply "Walter" <walter digitalmars.com> writes:
"Pavel Minayev" <evilone omen.ru> wrote in message
news:a5ietg$p0l$1 digitaldaemon.com...
 What about allowing function body to be a single asm statement?
     extern(C) uint crc32(void* data, int len) asm
     {
         // assembler goes here
     }
 This is a very nice feature Borland Pascal implementations have,
 it makes the code somewhat neater compared to:
     extern(C) uint crc32(void* data, int len)
     {
         asm
         {
             // assembler goes here
         }
     }
 Not a big change anyhow... what do you think of it?

I think the second one is better because I see an attribute as part of the interface a function presents to the world, and how it's implemented is an internal issue. In the C world, there's that declspec(naked) attribute which is just in the wrong place. Hence, in D, the naked pseudo-op appears inside the AsmStatement.
Feb 27 2002
parent reply "Pavel Minayev" <evilone omen.ru> writes:
"Walter" <walter digitalmars.com> wrote in message
news:a5j6os$14dc$1 digitaldaemon.com...

 I think the second one is better because I see an attribute as part of the
 interface a function presents to the world, and how it's implemented is an
 internal issue. In the C world, there's that declspec(naked) attribute

 is just in the wrong place. Hence, in D, the naked pseudo-op appears

 the AsmStatement.

Was I speaking of naked p-op in asm blocks? No! Let it be as it is now. What I want is to have a clear way to identify that the whole function is written in assembler. There are some reasons for it other than just size of code: 1) It eliminates a nasty "missing return" bug: even though you have a RET inside your asm block, you have to add one just to stop compiler from complaining... I wonder if it gets optimized away BTW? extern(Windows) int foo(int n) { asm { enter 0, 0; mov EAX, [EBP+8]; mul EAX; leave; ret 4; } return 0; // stupid! } 2) It makes it possible for the compiler to check which calling convention is used for the function, and stop with an error if it is the default extern(D) (since it's implementation- defined, and thus shouldn't be used with assembler code). 3) It clearly states that an implicit naked pseudoop should be applied to the function.
Feb 27 2002
parent reply "Walter" <walter digitalmars.com> writes:
"Pavel Minayev" <evilone omen.ru> wrote in message
news:a5jaq0$16du$1 digitaldaemon.com...
 "Walter" <walter digitalmars.com> wrote in message
 news:a5j6os$14dc$1 digitaldaemon.com...
 I think the second one is better because I see an attribute as part of


 interface a function presents to the world, and how it's implemented is


 internal issue. In the C world, there's that declspec(naked) attribute

 is just in the wrong place. Hence, in D, the naked pseudo-op appears

 the AsmStatement.


True, but it is relevant. Read on...
 Let it be as it
 is now. What I want is to have a clear way to identify that the
 whole function is written in assembler.

"naked" serves that purpose.
 There are some reasons
 for it other than just size of code:
 1) It eliminates a nasty "missing return" bug: even though
    you have a RET inside your asm block, you have to add one
    just to stop compiler from complaining... I wonder if it
    gets optimized away BTW?

         extern(Windows) int foo(int n)
         {
             asm
             {
                 enter 0, 0;
                 mov EAX, [EBP+8];
                 mul EAX;
                 leave;
                 ret 4;
             }
             return 0;    // stupid!
         }

Yes, that is stupid. Using inline asm should prevent any messages about missing return bugs. extern(Windows) int foo(int n) { asm { naked; enter 0, 0; mov EAX, n[EBP]; mul EAX; leave; ret 4; } }
 2) It makes it possible for the compiler to check which calling
    convention is used for the function, and stop with an error
    if it is the default extern(D) (since it's implementation-
    defined, and thus shouldn't be used with assembler code).

The presumption is that if you use naked inline asm, you know what you're doing and accept the risk that calling conventions differ/change. To be more forgiving of calling convention changes, do not use naked.
 3) It clearly states that an implicit naked pseudoop should
    be applied to the function.

Yes, it's an alternate way of doing that, but I don't see what it adds that's worth the special case in the grammar.
Feb 27 2002
parent reply "Pavel Minayev" <evilone omen.ru> writes:
"Walter" <walter digitalmars.com> wrote in message
news:a5jc7h$171k$1 digitaldaemon.com...

 Let it be as it
 is now. What I want is to have a clear way to identify that the
 whole function is written in assembler.

"naked" serves that purpose.

I thought it means that programmer is responsible for prolog/epilog code, nothing more... so you could write: extern(Windows) int foo(int n) { asm { enter 0, 0; } n = (n + 2) * 3 / 4; asm { mov EAX, [EBP+8] leave ret } }
 Yes, that is stupid. Using inline asm should prevent any messages about
 missing return bugs.

Either this, or check for RET in asm blocks... but that's not very portable. So it's better to assume that this smart guy who wrote that knows what he's doing. =)
 The presumption is that if you use naked inline asm, you know what you're
 doing and accept the risk that calling conventions differ/change. To be

 forgiving of calling convention changes, do not use naked.

Using asm with extern(D) doesn't make sence at all, because the convention is not specified, and, in general, may vary from function to function (for optimization reasons). So it should be prohibited, IMO.
 3) It clearly states that an implicit naked pseudoop should
    be applied to the function.

Yes, it's an alternate way of doing that, but I don't see what it adds that's worth the special case in the grammar.

1 less level in the indentation =)
Feb 27 2002
parent "Walter" <walter digitalmars.com> writes:
"Pavel Minayev" <evilone omen.ru> wrote in message
news:a5jhsb$19i2$1 digitaldaemon.com...
 "Walter" <walter digitalmars.com> wrote in message
 news:a5jc7h$171k$1 digitaldaemon.com...
 Let it be as it
 is now. What I want is to have a clear way to identify that the
 whole function is written in assembler.


prolog/epilog code, nothing more... so you could write: extern(Windows) int foo(int n) { asm { enter 0, 0; } n = (n + 2) * 3 / 4; asm { mov EAX, [EBP+8] leave ret } }

Yes, you're correct, but I think you'll also see that naked serves the purpose of indicating the whole thing is in assembly, too.
 Yes, that is stupid. Using inline asm should prevent any messages about
 missing return bugs.

very portable. So it's better to assume that this smart guy who wrote that knows what he's doing. =)

There are many ways to return using asm, not just with a RET, so the assumption is the programmer knows what he's doing.
Feb 27 2002