D Design Could Be Improved

[John Demme]

Aleksey S. Skidan wrote:

> The inline assembler seems to be a weak point in the language design.
> I do like the GCC inline assembler and can't understand the reasons
> why not to use it. The current implementation of D's inline assembler
> is IMNHO not good.
> Let's consider the following example:
> asm{ di 2+3; }
> The code won't ever be compiled. Just because the assembler consider 2+3
> not to be a constant expression. But it certainly is (it depends on 2
> constants). The other ugly thing is Intel syntax. There's a lot of
> software written in AT&T syntax. I guess both the Intel and AT&T syntaxes
> must be available. The weakness of current inline assembler makes the
> language (i mean D) not fitable for system programming.
> I noticed that there's no ability to name a symbol in a way like that:
> void foo() asm("bar"); Please, note that this kind of naming is very handy
> for embeded systems and a lot of stuff like that. Yep, there's extern(C)
> but why does it underscore? There must be a switch that turns underscoring
> off. The next disappointment is that one can't specify where to put a
> symbol. I mean one can't say to put "foo" into .some_section instead of
> .text section. I do agree with the point that bit fields are BAD things.
> But the bit array you introduced isn't better. You must at least specify
> the way the bit array is stored in the memory: is it BE LE or what. The
> next thing about them is that they don't really save the memory. I mean
> that the bit[8] blah; is 32 bits long. But then the better way to write
> the same thing is: enum{ B0, B1, ..., B7 }; char blah;
> 
> My best regards, Aleksey.


http://digitalmars.com/d/iasm.html
Specifies the this document only describes the x86 implementation of the
inline assembler.  I would suggest it go further and specify that it only
describes DMD's x86 implementation.  Since D is designed to be
cross-platform, anything at the assembly or linking level should be
implementation specific, IMO.  This way, D compilers (even ones with x86
targets) can use whatever asm syntax they like.

Another thought would be implementation-defined attributes.  In C, I've seen
stuff like "__inline__" and "__attribute(something(params))".  It might be
wise for the D spec to define something like "attribute(attr(params))" so
that an embedded D compiler could use:
attribute(section(.bootloader)) void initSerial() {}

-- 
~John Demme
me at teqdruid.com
http://www.teqdruid.com/