Simen kjaeraas:
> Essentially, mark the switch as final, and cover every option.
> Likely, the optimizer does that for you if you cover every option but
> don't mark the switch as final.
This is true in theory, and I remember Walter liking this optimization. But in
practice I don't know if DMD performs this optimization already, so you need to
take a look at the produced asm to be sure.
--------------------------------
This is a little test, D2 code:
enum E { e1, e2, e3 }
int foo1(E e) {
switch (e) {
case E.e1: return 1;
case E.e2: return 2;
case E.e3: return 3;
default: assert(0);
}
}
int foo2(E e) {
switch (e) {
case E.e1: return 1;
case E.e2: return 2;
default: return 3;
}
}
int foo3(E e) {
final switch (e) {
case E.e1: return 1;
case E.e2: return 2;
case E.e3: return 3;
}
}
void main() {}
_D5test4foo1FE5test31EZi
push EAX
test EAX,EAX
je L11
cmp EAX,1
je L18
cmp EAX,2
je L1F
jmp short L26
L11: pop ECX
mov EAX,1
ret
L18: pop ECX
mov EAX,2
ret
L1F: pop ECX
mov EAX,3
ret
L26: hlt
_D5test4foo2FE5test31EZi
push EAX
test EAX,EAX
je LC
cmp EAX,1
je L13
jmp short L1A
LC: pop ECX
mov EAX,1
ret
L13: pop ECX
mov EAX,2
ret
L1A: pop ECX
mov EAX,3
ret
_D5test4foo3FE5test31EZi
push EAX
test EAX,EAX
je L11
cmp EAX,1
je L18
cmp EAX,2
je L1F
jmp short L26
L11: pop ECX
mov EAX,1
ret
L18: pop ECX
mov EAX,2
ret
L1F: pop ECX
mov EAX,3
ret
L26: pop EAX
ret
--------------------------------
Some C code compiled with GCC 4.5.1:
typedef enum { e1, e2, e3 } E;
int foo2(E e) {
switch (e) {
case e1: return 1;
case e2: return 2;
default: return 3;
}
}
int foo3(E e) {
switch (e) {
case e1: return 1;
case e2: return 2;
case e3: return 3;
}
}
int foo4(E e) {
static void *array[] = { &&E1, &&E2, &&E3 };
goto *array[e];
E1: return 1;
E2: return 2;
E3: return 3;
}
int main() {
return 0;
}
_foo2:
movl 4(%esp), %edx
movl $3, %eax
cmpl $1, %edx
jbe L5
rep
ret
.p2align 4,,7
L5:
movl _CSWTCH.1(,%edx,4), %eax
ret
.p2align 4,,15
_foo3:
movl 4(%esp), %edx
cmpl $1, %edx
je L11
movl $1, %eax
jb L6
cmpl $2, %edx
je L13
.p2align 4,,3
rep
ret
.p2align 4,,7
L11:
movl $2, %eax
L6:
.p2align 4,,3
rep
ret
.p2align 4,,7
L13:
movb $3, %al
ret
_foo4:
movl 4(%esp), %eax
jmp *_array.1639(,%eax,4)
.p2align 4,,7
L15:
movl $1, %eax
ret
.p2align 4,,7
L17:
movl $2, %eax
ret
.p2align 4,,7
L18:
movl $3, %eax
ret
--------------------------------
> My forays into the inline asm idea proved fruitless, but there may yet be
> ways.
In D+DMD inline asm kills inlining, so you may use inline asm only if you need
to do lot of computations.
In LDC there are pragma(allow_inline) and asm expressions that some most of
this problem.
Going back to the OP problem: in D there are no computed gotos, that are useful
if you want to write very fast interpreters and other things. But keep in mind
that DMD supports normal gotos from and in inlined asm (LLVM-LDC doesn't
supports this well), plus naked asm, this gives you some possibilities.
An option on Linux is to write the interpreter core using GNU C (that has
computed gotos) and then link the core to the D code compiled with DMD/GDC.
It's strange how something as basic, old and necessary as a switch, to create a
basic but fast interpreter, is so hard to compile well for compilers :-)
Bye,
bearophile
