Bug 8903 – Bad code for enum array members

struct A { immutable int arr[8] = [1, 2, 3, 4, 5, 6, 7, 8]; } struct B { enum int arr[8] = [1, 2, 3, 4, 5, 6, 7, 8]; } void test_a(int n) { auto a = A(); auto b = a.arr[n]; } /* 0000000000416c68 <_D4test6test_aFiZv>: 416c68: 55 push rbp 416c69: 48 8b ec mov rbp,rsp 416c6c: 48 83 ec 20 sub rsp,0x20 416c70: 89 7d f8 mov DWORD PTR [rbp-0x8],edi 416c73: c6 45 f0 00 mov BYTE PTR [rbp-0x10],0x0 416c77: 48 63 45 f8 movsxd rax,DWORD PTR [rbp-0x8] 416c7b: 48 83 f8 08 cmp rax,0x8 416c7f: 48 89 45 e8 mov QWORD PTR [rbp-0x18],rax 416c83: 72 0a jb 416c8f <_D4test6test_aFiZv+0x27> 416c85: bf 10 00 00 00 mov edi,0x10 416c8a: e8 a1 00 00 00 call 416d30 <_D4test7__arrayZ> 416c8f: 48 8b 4d e8 mov rcx,QWORD PTR [rbp-0x18] 416c93: 8b 14 8d f0 41 63 00 mov edx,DWORD PTR [rcx*4+0x6341f0] 416c9a: c9 leave 416c9b: c3 ret */ void test_b(int n) { auto a = B(); auto b = a.arr[n]; } /* 0000000000416c9c <_D4test6test_bFiZv>: 416c9c: 55 push rbp 416c9d: 48 8b ec mov rbp,rsp 416ca0: 48 83 ec 20 sub rsp,0x20 416ca4: 89 7d f8 mov DWORD PTR [rbp-0x8],edi 416ca7: c6 45 f0 00 mov BYTE PTR [rbp-0x10],0x0 416cab: 48 63 45 f8 movsxd rax,DWORD PTR [rbp-0x8] 416caf: 48 b9 08 00 00 00 00 movabs rcx,0x8 416cb6: 00 00 00 416cb9: 48 3b c1 cmp rax,rcx 416cbc: 48 89 45 e8 mov QWORD PTR [rbp-0x18],rax 416cc0: 72 0a jb 416ccc <_D4test6test_bFiZv+0x30> 416cc2: bf 16 00 00 00 mov edi,0x16 416cc7: e8 64 00 00 00 call 416d30 <_D4test7__arrayZ> 416ccc: 48 be 08 00 00 00 00 movabs rsi,0x8 416cd3: 00 00 00 416cd6: 48 bf 60 43 63 00 00 movabs rdi,0x634360 416cdd: 00 00 00 416ce0: e8 1b 23 00 00 call 419000 <_d_arrayliteralTX> 416ce5: c7 00 01 00 00 00 mov DWORD PTR [rax],0x1 416ceb: ba 02 00 00 00 mov edx,0x2 416cf0: 89 50 04 mov DWORD PTR [rax+0x4],edx 416cf3: c7 40 08 03 00 00 00 mov DWORD PTR [rax+0x8],0x3 416cfa: c7 40 0c 04 00 00 00 mov DWORD PTR [rax+0xc],0x4 416d01: c7 40 10 05 00 00 00 mov DWORD PTR [rax+0x10],0x5 416d08: c7 40 14 06 00 00 00 mov DWORD PTR [rax+0x14],0x6 416d0f: c7 40 18 07 00 00 00 mov DWORD PTR [rax+0x18],0x7 416d16: c7 40 1c 08 00 00 00 mov DWORD PTR [rax+0x1c],0x8 416d1d: 48 8b 4d e8 mov rcx,QWORD PTR [rbp-0x18] 416d21: 8b 04 88 mov eax,DWORD PTR [rax+rcx*4] 416d24: c9 leave 416d25: c3 ret 416d26: 90 nop 416d27: 90 nop */ void main() { } It makes no sense to me for the enum array to cause re-allocation when instantiated. I know that enum arrays are problematic entities to begin with, but while they are allowed to exist, they shouldn't generate horrible code like that.

This is not wrong-code, this is a performance issue. *** This issue has been marked as a duplicate of issue 2356 ***

No, it is not. Issue 2356 does not affect the array in struct A. The bug here is the difference between A and B and not how badly B is implemented. Both cases (or should) involve static array literal initialization, with the bug being that B does not use it.

I don't think the code should compile. 'enum' should be declaring a manifest constant, it shouldn't be possible to index it at run time. The whole point of these enum constants was that they shouldn't appear in the executable! If you want it to appear in the executable, use can use immutable or const. This is a duplicate of another bug, I forget which one though.

It looks a little like issue 9953, but it isn't. Because int[8] is a static array, the array literal is a value type and it is valid to store in an enum. There is no special casing for static array typed array literals, but there should be. They should be created on the stack, then indexed. https://github.com/D-Programming-Language/dmd/pull/2870

Commits pushed to master at https://github.com/D-Programming-Language/dmd https://github.com/D-Programming-Language/dmd/commit/56ddd223f9f2b5b0c7c8c1f9bb0938af70284bfe Fix Issue 8903 - Bad code for enum array members https://github.com/D-Programming-Language/dmd/commit/5e937c3c6331890801eaaaf33e32e3e0b32067cc Merge pull request #2870 from yebblies/issue8903 Issue 8903 - Bad code for enum array members

Allocation is now gone: _D5testx6test_bFiZv PROC NEAR ; COMDEF _D5testx6test_bFiZv push ebp ; 0000 _ 55 mov ebp, esp ; 0001 _ 8B. EC sub esp, 52 ; 0003 _ 83. EC, 34 push ebx ; 0006 _ 53 push esi ; 0007 _ 56 mov dword ptr [ebp-4H], eax ; 0008 _ 89. 45, FC mov byte ptr [ebp-34H], 0 ; 000B _ C6. 45, CC, 00 cmp eax, 8 ; 000F _ 83. F8, 08 jc ?_004 ; 0012 _ 72, 0A mov eax, 19 ; 0014 _ B8, 00000013 call _D5testx7__arrayZ ; 0019 _ E8, 00000000(rel) ?_004: mov dword ptr [ebp-24H], 1 ; 001E _ C7. 45, DC, 00000001 mov ecx, 2 ; 0025 _ B9, 00000002 mov dword ptr [ebp-20H], ecx ; 002A _ 89. 4D, E0 mov dword ptr [ebp-1CH], 3 ; 002D _ C7. 45, E4, 00000003 mov dword ptr [ebp-18H], 4 ; 0034 _ C7. 45, E8, 00000004 mov dword ptr [ebp-14H], 5 ; 003B _ C7. 45, EC, 00000005 mov dword ptr [ebp-10H], 6 ; 0042 _ C7. 45, F0, 00000006 mov dword ptr [ebp-0CH], 7 ; 0049 _ C7. 45, F4, 00000007 mov dword ptr [ebp-8H], 8 ; 0050 _ C7. 45, F8, 00000008 lea edx, [ebp-24H] ; 0057 _ 8D. 55, DC mov ebx, dword ptr [ebp-4H] ; 005A _ 8B. 5D, FC mov esi, dword ptr [edx+ebx*4] ; 005D _ 8B. 34 9A pop esi ; 0060 _ 5E pop ebx ; 0061 _ 5B leave ; 0062 _ C9 ret ; 0063 _ C3 _D5testx6test_bFiZv ENDP

The bug fix will also improve generated code in following case: void foo(int[3] sa) {} void main() { foo([1,2,3]); } // array literal is typed as static array, so // it won't be allocated on heap.

Commits pushed to 2.065 at https://github.com/D-Programming-Language/dmd https://github.com/D-Programming-Language/dmd/commit/56ddd223f9f2b5b0c7c8c1f9bb0938af70284bfe Fix Issue 8903 - Bad code for enum array members https://github.com/D-Programming-Language/dmd/commit/5e937c3c6331890801eaaaf33e32e3e0b32067cc Merge pull request #2870 from yebblies/issue8903