Get address of label?

[Heywood Floyd]

Thank you bearophile and Simen for your replies! Very helpful! 
I'll keep looking into it...

BR
/HF



bearophile Wrote:

> 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