[Windows] Does Clang support SME Intrinsics on Windows now ?

[scout-zeng]

I want find out whether the Clang support SME Intrinsics on windows.

[AaronBallman]

I believe so: https://godbolt.org/z/W86KEGd8d

CC @sdesmalen-arm for confirmation

[efriedma-quic]

It only partially works. You can generate code in simple cases, but unwinding isn't aware of streaming mode, and the runtime routines (implemented in compiler-rt) are broken.

CC @mstorsjo @pmsjt

[mstorsjo]

Also, it's unclear whether Windows, on the kernel level, supports SME yet; there are no flags for IsProcessorFeaturePresent for checking for support for SME - only SVE (and subfeatures of SVE).

[pmsjt]

We are still working on adding support for SME in Windows. As of now, I think we only need 1 unwind opcode - the one used to persist the previous VL - the (in)famous Register 46.

https://github.com/ARM-software/abi-aa/blob/main/aadwarf64/aadwarf64.rst#dwarf-register-names

Which reminds me (and I probably should open an LLVM issue on this):

LLVM is not saving VL when switching SM. I see that GCC does it, but not CLANG. At least last time I checked.

If you compile this [1] code, GCC you can see it will spill VL and annotate [2] in the prolog it as Register 46, but CLANG won't spill it or annotate it.

[1]

#include <arm_sve.h>
#include <alloca.h>
#include <stdio.h>
#include <string.h>

volatile unsigned char g_buff_size = 0x21;
char hlstr[] = "hello";


extern "C"
svint8_t M2(svint8_t x, svint8_t y, bool z) __arm_streaming_compatible
{
    char * buff = (char *)alloca(g_buff_size);
    memcpy(buff, hlstr, sizeof(hlstr));
    puts(buff);
    buff[0x19] = 0x23;
    return z ? x : y;
}

[2]

	cntd	x16
	str	x16, [sp, 32]
	.cfi_offset 46, -16

[sdesmalen-arm]

LLVM is not saving VL when switching SM. I see that GCC does it, but not CLANG. At least last time I checked.

Clang stores the VL in the prologue of the function (although it prints the directive as using 'vg' iso register '46'), see e.g. https://godbolt.org/z/1e9f68odo

  cntd    x9
  str     x9, [sp, #1104]
  ...
  .cfi_offset vg, -16

If the target has SME, but no SVE, it will generate a call to __arm_get_current_vg instead of emitting a cntd (which would not be valid if not in streaming-SVE mode)

[pmsjt]

Clang stores the VL in the prologue of the function (although it prints the directive as using 'vg' iso register '46'),

With the version I have, CLANG was not spilling it at all, so this was probably fixed in the meantime. Thanks for confirming @sdesmalen-arm .

Just for reference, this was the listing I was getting out of CLANG [1]

Back to Windows, I'll most likely pick one of the 4 reserved encodings in save_preg to mark where vg is spilled but that isn't set in stone yet. You can assume this will be decided in the near future.

As for the ABI, Windows will follow Arm's ABI for the most part. There will be some additional Windows-specific considerations for SEH, but CLANG still doesn't support it anyways.

Basic SME support (enabling the state and context-manage it, adding the extended state to CONTEXT for APIs, dispatching the state in APCs and exceptions...) is likely to come soon in canary builds. Then we'll need to add the helper APIs to the CRT and the unwinder support, like the vg spillage and dormant trapped state for SEH.

[1]

	.text
	.file	"svefn.cpp"
	.globl	M2                              // -- Begin function M2
	.p2align	4
	.type	M2,@function
	.variant_pcs	M2
M2:                                     // @M2
	.cfi_startproc
// %bb.0:
	stp	x29, x30, [sp, #-48]!           // 16-byte Folded Spill
	.cfi_def_cfa_offset 48
	stp	x28, x21, [sp, #16]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #32]             // 16-byte Folded Spill
	mov	x29, sp
	.cfi_def_cfa w29, 48
	.cfi_offset w19, -8
	.cfi_offset w20, -16
	.cfi_offset w21, -24
	.cfi_offset w28, -32
	.cfi_offset w30, -40
	.cfi_offset w29, -48
	addvl	sp, sp, #-18
	str	p15, [sp, #4, mul vl]           // 2-byte Folded Spill
	str	p14, [sp, #5, mul vl]           // 2-byte Folded Spill
	str	p13, [sp, #6, mul vl]           // 2-byte Folded Spill
	str	p12, [sp, #7, mul vl]           // 2-byte Folded Spill
	str	p11, [sp, #8, mul vl]           // 2-byte Folded Spill
	str	p10, [sp, #9, mul vl]           // 2-byte Folded Spill
	str	p9, [sp, #10, mul vl]           // 2-byte Folded Spill
	str	p8, [sp, #11, mul vl]           // 2-byte Folded Spill
	str	p7, [sp, #12, mul vl]           // 2-byte Folded Spill
	str	p6, [sp, #13, mul vl]           // 2-byte Folded Spill
	str	p5, [sp, #14, mul vl]           // 2-byte Folded Spill
	str	p4, [sp, #15, mul vl]           // 2-byte Folded Spill
	str	z23, [sp, #2, mul vl]           // 16-byte Folded Spill
	str	z22, [sp, #3, mul vl]           // 16-byte Folded Spill
	str	z21, [sp, #4, mul vl]           // 16-byte Folded Spill
	str	z20, [sp, #5, mul vl]           // 16-byte Folded Spill
	str	z19, [sp, #6, mul vl]           // 16-byte Folded Spill
	str	z18, [sp, #7, mul vl]           // 16-byte Folded Spill
	str	z17, [sp, #8, mul vl]           // 16-byte Folded Spill
	str	z16, [sp, #9, mul vl]           // 16-byte Folded Spill
	str	z15, [sp, #10, mul vl]          // 16-byte Folded Spill
	str	z14, [sp, #11, mul vl]          // 16-byte Folded Spill
	str	z13, [sp, #12, mul vl]          // 16-byte Folded Spill
	str	z12, [sp, #13, mul vl]          // 16-byte Folded Spill
	str	z11, [sp, #14, mul vl]          // 16-byte Folded Spill
	str	z10, [sp, #15, mul vl]          // 16-byte Folded Spill
	str	z9, [sp, #16, mul vl]           // 16-byte Folded Spill
	str	z8, [sp, #17, mul vl]           // 16-byte Folded Spill
	.cfi_escape 0x10, 0x48, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x78, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d8  @ cfa - 48 - 8 * VG
	.cfi_escape 0x10, 0x49, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x70, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d9  @ cfa - 48 - 16 * VG
	.cfi_escape 0x10, 0x4a, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x68, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d10  @ cfa - 48 - 24 * VG
	.cfi_escape 0x10, 0x4b, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x60, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d11  @ cfa - 48 - 32 * VG
	.cfi_escape 0x10, 0x4c, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x58, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d12  @ cfa - 48 - 40 * VG
	.cfi_escape 0x10, 0x4d, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x50, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d13  @ cfa - 48 - 48 * VG
	.cfi_escape 0x10, 0x4e, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x48, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d14  @ cfa - 48 - 56 * VG
	.cfi_escape 0x10, 0x4f, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x40, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d15  @ cfa - 48 - 64 * VG
	addvl	sp, sp, #-2
	str	z1, [x29, #-19, mul vl]         // 16-byte Folded Spill
	str	z0, [x29, #-20, mul vl]         // 16-byte Folded Spill
	adrp	x8, g_buff_size
	mov	x9, sp
	mov	w20, w0
	mov	x19, sp
	ldrb	w8, [x8, :lo12:g_buff_size]
	add	w8, w8, #15
	and	x8, x8, #0x1f0
	sub	x8, x9, x8
	mov	sp, x8
	adrp	x9, hlstr
	add	x9, x9, :lo12:hlstr
	ldr	w10, [x9]
	ldrh	w9, [x9, #4]
	str	w10, [x8]
	strh	w9, [x8, #4]
	bl	__arm_sme_state
	and	x21, x0, #0x1
	tbz	w21, #0, .LBB0_2
// %bb.1:
	smstop	sm
.LBB0_2:
	mov	x0, x8
	bl	puts
	tbz	w21, #0, .LBB0_4
// %bb.3:
	smstart	sm
.LBB0_4:
	ldr	z0, [x29, #-19, mul vl]         // 16-byte Folded Reload
	ldr	z1, [x29, #-20, mul vl]         // 16-byte Folded Reload
	sbfx	x8, x20, #0, #1
	whilelo	p0.b, xzr, x8
	mov	z0.b, p0/m, z1.b
	addvl	sp, x29, #-18
	ldr	p15, [sp, #4, mul vl]           // 2-byte Folded Reload
	ldr	p14, [sp, #5, mul vl]           // 2-byte Folded Reload
	ldr	z23, [sp, #2, mul vl]           // 16-byte Folded Reload
	ldr	z22, [sp, #3, mul vl]           // 16-byte Folded Reload
	ldr	p13, [sp, #6, mul vl]           // 2-byte Folded Reload
	ldr	p12, [sp, #7, mul vl]           // 2-byte Folded Reload
	ldr	p11, [sp, #8, mul vl]           // 2-byte Folded Reload
	ldr	z21, [sp, #4, mul vl]           // 16-byte Folded Reload
	ldr	p10, [sp, #9, mul vl]           // 2-byte Folded Reload
	ldr	p9, [sp, #10, mul vl]           // 2-byte Folded Reload
	ldr	z20, [sp, #5, mul vl]           // 16-byte Folded Reload
	ldr	p8, [sp, #11, mul vl]           // 2-byte Folded Reload
	ldr	p7, [sp, #12, mul vl]           // 2-byte Folded Reload
	ldr	z19, [sp, #6, mul vl]           // 16-byte Folded Reload
	ldr	p6, [sp, #13, mul vl]           // 2-byte Folded Reload
	ldr	p5, [sp, #14, mul vl]           // 2-byte Folded Reload
	ldr	z18, [sp, #7, mul vl]           // 16-byte Folded Reload
	ldr	p4, [sp, #15, mul vl]           // 2-byte Folded Reload
	ldr	z17, [sp, #8, mul vl]           // 16-byte Folded Reload
	ldr	z16, [sp, #9, mul vl]           // 16-byte Folded Reload
	ldr	z15, [sp, #10, mul vl]          // 16-byte Folded Reload
	ldr	z14, [sp, #11, mul vl]          // 16-byte Folded Reload
	ldr	z13, [sp, #12, mul vl]          // 16-byte Folded Reload
	ldr	z12, [sp, #13, mul vl]          // 16-byte Folded Reload
	ldr	z11, [sp, #14, mul vl]          // 16-byte Folded Reload
	ldr	z10, [sp, #15, mul vl]          // 16-byte Folded Reload
	ldr	z9, [sp, #16, mul vl]           // 16-byte Folded Reload
	ldr	z8, [sp, #17, mul vl]           // 16-byte Folded Reload
	.cfi_restore z8
	.cfi_restore z9
	.cfi_restore z10
	.cfi_restore z11
	.cfi_restore z12
	.cfi_restore z13
	.cfi_restore z14
	.cfi_restore z15
	mov	sp, x29
	.cfi_def_cfa wsp, 48
	ldp	x20, x19, [sp, #32]             // 16-byte Folded Reload
	ldp	x28, x21, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #48             // 16-byte Folded Reload
	.cfi_def_cfa_offset 0
	.cfi_restore w19
	.cfi_restore w20
	.cfi_restore w21
	.cfi_restore w28
	.cfi_restore w30
	.cfi_restore w29
	ret
.Lfunc_end0:
	.size	M2, .Lfunc_end0-M2
	.cfi_endproc
                                        // -- End function
	.type	g_buff_size,@object             // @g_buff_size
	.data
	.globl	g_buff_size
	.p2align	2, 0x0
g_buff_size:
	.byte	33                              // 0x21
	.size	g_buff_size, 1

	.type	hlstr,@object                   // @hlstr
	.globl	hlstr
hlstr:
	.asciz	"hello"
	.size	hlstr, 6

	.ident	"Ubuntu clang version 18.1.3 (1)"
	.section	".note.GNU-stack","",@progbits
	.addrsig
	.addrsig_sym g_buff_size