• Kublai Makaan (44/44) Jul 08 2004 I think it would be cool if the D inline Assembler would include an asse...
• C. Sauls (17/34) Jul 09 2004 You can do this already, using the version statement. Consider:

Kublai Makaan <Kublai_member pathlink.com> writes:

I think it would be cool if the D inline Assembler would include an assember tag
or definition.  This would allow for different inline assemblers to be included
in a D source code tree or file.  The assembly source code would be more
portable.  Optionally a source code file could be compiled for x86 and Motorola
68K and 88k AMD 29K and Powerpc depending on the platform value at compilation
time. Also optionally the code could be cross compiled for multiple platforms
under D.  There could also be optional inline assemblers to support different
architectures and platforms. 

So if the compiler was hosted under the Motorola 68000 it would compile the
inline assembler for 68k.  If the compiler was under x86 it would compile that
code and if it was under the AMD 29k it would compile that code.  This is
strictly optional.  A cross compile option would build for all three.

This would mean that the compiler could selectively compile assembler code if it
is native and hosted on a particular cpu or platform.  Also having an inline
assembler type for D would be very advantageous over just an Asm inline block.

A D example would show the assembler type:

import std.c.stdio;
int main() {
static bit[] a = [ 0, 0, 0, 0,/**/, 0, 0, 0, 1,
1, 1, 0, 1,/**/, 1, 1, 0, 0 ];
bit[] b = a[1..9];
for (uint i = 0; i < a.length; i++) {
printf("a[%d] = %d\n", i, a[i]);
}
for (uint i = 0; i < b.length; i++) {
printf("b[%d] = %d\n", i, b[i]);
}
return 0;
}

// this is the assembler code for the AMD 29k
Asm asm_type_29K
{

// AMD 29k assembler code goes here
}

// If the cpu is 68K compile this
Asm asm_type_68K
{
// Motorola 68k assembler code goes here
}
// If the cpu is x86 compile this
Asm asm_type_x86
{
// Intel x86 assembler code goes here
}

"C. Sauls" <ibisbasenji yahoo.com> writes:

Kublai Makaan wrote:
 // this is the assembler code for the AMD 29k
 Asm asm_type_29K
 {
 
 // AMD 29k assembler code goes here
 }
 
 // If the cpu is 68K compile this
 Asm asm_type_68K
 {
 // Motorola 68k assembler code goes here
 }
 // If the cpu is x86 compile this
 Asm asm_type_x86
 {
 // Intel x86 assembler code goes here
 }

You can do this already, using the version statement.  Consider:

version (X86) asm {
   ...
}
version (AMD64) asm {
   ...
}
version (StrongARM) asm {
   ...
}
version (SPARC) asm {
   ...
}

And so forth.

-Chris S.
-Invironz