| 1 |
# Specific regression driver for AArch64 SME. |
| 2 |
# Copyright (C) 2009-2025 Free Software Foundation, Inc. |
| 3 |
# |
| 4 |
# This file is part of GCC. |
| 5 |
# |
| 6 |
# GCC is free software; you can redistribute it and/or modify it |
| 7 |
# under the terms of the GNU General Public License as published by |
| 8 |
# the Free Software Foundation; either version 3, or (at your option) |
| 9 |
# any later version. |
| 10 |
# |
| 11 |
# GCC is distributed in the hope that it will be useful, but |
| 12 |
# WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 14 |
# General Public License for more details. |
| 15 |
# |
| 16 |
# You should have received a copy of the GNU General Public License |
| 17 |
# along with GCC; see the file COPYING3. If not see |
| 18 |
# <http://www.gnu.org/licenses/>. */ |
| 19 |
|
| 20 |
# Test whether certain SVE instructions are accepted or rejected in |
| 21 |
# SME streaming mode. |
| 22 |
|
| 23 |
# Exit immediately if this isn't an AArch64 target. |
| 24 |
if {![istarget aarch64*-*-*] } { |
| 25 |
return |
| 26 |
} |
| 27 |
|
| 28 |
load_lib gcc-defs.exp |
| 29 |
|
| 30 |
if ![gcc_parallel_test_run_p aarch64-ssve] { |
| 31 |
return |
| 32 |
} |
| 33 |
|
| 34 |
gcc_parallel_test_enable 0 |
| 35 |
|
| 36 |
# Code shared by all tests. |
| 37 |
set preamble { |
| 38 |
#include <arm_sve.h> |
| 39 |
|
| 40 |
#pragma GCC target "+i8mm+f32mm+f64mm+sve2+sve2-bitperm+sve2-sm4+sve2-aes+sve2-sha3+sme" |
| 41 |
|
| 42 |
extern svbool_t &pred; |
| 43 |
|
| 44 |
extern svint8_t &s8; |
| 45 |
extern svint32_t &s32; |
| 46 |
|
| 47 |
extern svuint8_t &u8; |
| 48 |
extern svuint16_t &u16; |
| 49 |
extern svuint32_t &u32; |
| 50 |
extern svuint64_t &u64; |
| 51 |
|
| 52 |
extern svbfloat16_t &bf16; |
| 53 |
extern svfloat32_t &f32; |
| 54 |
|
| 55 |
extern void *void_ptr; |
| 56 |
|
| 57 |
extern int8_t *s8_ptr; |
| 58 |
extern int16_t *s16_ptr; |
| 59 |
extern int32_t *s32_ptr; |
| 60 |
|
| 61 |
extern uint8_t *u8_ptr; |
| 62 |
extern uint16_t *u16_ptr; |
| 63 |
extern uint32_t *u32_ptr; |
| 64 |
extern uint64_t *u64_ptr; |
| 65 |
|
| 66 |
extern uint64_t indx; |
| 67 |
} |
| 68 |
|
| 69 |
# Wrap a standalone call in a streaming-compatible function. |
| 70 |
set sc_harness { |
| 71 |
void |
| 72 |
foo () [[arm::streaming_compatible]] |
| 73 |
{ |
| 74 |
$CALL; |
| 75 |
} |
| 76 |
} |
| 77 |
|
| 78 |
# HARNESS is some source code that should be appended to the preamble |
| 79 |
# variable defined above. It includes the string "$CALL", which should be |
| 80 |
# replaced by the function call in CALL. The result after both steps is |
| 81 |
# a complete C++ translation unit. |
| 82 |
# |
| 83 |
# Try compiling the C++ code and see what output GCC produces. |
| 84 |
# The expected output is either: |
| 85 |
# |
| 86 |
# - empty, if SHOULD_PASS is true |
| 87 |
# - a message rejecting CALL in streaming mode, if SHOULD_PASS is false |
| 88 |
# |
| 89 |
# CALL is simple enough that it can be used in test names. |
| 90 |
proc check_ssve_call { harness name call should_pass } { |
| 91 |
global preamble |
| 92 |
|
| 93 |
set filename test-[pid] |
| 94 |
set fd [open $filename.cc w] |
| 95 |
puts $fd $preamble |
| 96 |
puts -nonewline $fd [string map [list {$CALL} $call] $harness] |
| 97 |
close $fd |
| 98 |
remote_download host $filename.cc |
| 99 |
|
| 100 |
set test "streaming SVE call $name" |
| 101 |
|
| 102 |
set gcc_output [g++_target_compile $filename.cc $filename.s assembly ""] |
| 103 |
remote_file build delete $filename.cc $filename.s |
| 104 |
|
| 105 |
if { [string equal $gcc_output ""] } { |
| 106 |
if { $should_pass } { |
| 107 |
pass $test |
| 108 |
} else { |
| 109 |
fail $test |
| 110 |
} |
| 111 |
return |
| 112 |
} |
| 113 |
|
| 114 |
set lines [split $gcc_output "\n"] |
| 115 |
set error_text "cannot be called when SME streaming mode is enabled" |
| 116 |
if { [llength $lines] == 3 |
| 117 |
&& [string first "In function" [lindex $lines 0]] >= 0 |
| 118 |
&& [string first $error_text [lindex $lines 1]] >= 0 |
| 119 |
&& [string equal [lindex $lines 2] ""] } { |
| 120 |
if { $should_pass } { |
| 121 |
fail $test |
| 122 |
} else { |
| 123 |
pass $test |
| 124 |
} |
| 125 |
return |
| 126 |
} |
| 127 |
|
| 128 |
verbose -log "$test: unexpected output" |
| 129 |
fail $test |
| 130 |
} |
| 131 |
|
| 132 |
# Apply check_ssve_call to each line in CALLS. The other arguments are |
| 133 |
# as for check_ssve_call. |
| 134 |
proc check_ssve_calls { harness calls should_pass } { |
| 135 |
foreach line [split $calls "\n"] { |
| 136 |
set call [string trim $line] |
| 137 |
if { [string equal $call ""] } { |
| 138 |
continue |
| 139 |
} |
| 140 |
check_ssve_call $harness "$call" $call $should_pass |
| 141 |
} |
| 142 |
} |
| 143 |
|
| 144 |
# A small selection of things that are valid in streaming mode. |
| 145 |
set streaming_ok { |
| 146 |
s8 = svadd_x (pred, s8, s8) |
| 147 |
s8 = svld1 (pred, s8_ptr) |
| 148 |
} |
| 149 |
|
| 150 |
# This order follows the list in the SME manual. |
| 151 |
set nonstreaming_only { |
| 152 |
u32 = svadrb_offset (u32, u32) |
| 153 |
u64 = svadrb_offset (u64, u64) |
| 154 |
u32 = svadrh_index (u32, u32) |
| 155 |
u64 = svadrh_index (u64, u64) |
| 156 |
u32 = svadrw_index (u32, u32) |
| 157 |
u64 = svadrw_index (u64, u64) |
| 158 |
u32 = svadrd_index (u32, u32) |
| 159 |
u64 = svadrd_index (u64, u64) |
| 160 |
u8 = svaesd (u8, u8) |
| 161 |
u8 = svaese (u8, u8) |
| 162 |
u8 = svaesimc (u8) |
| 163 |
u8 = svaesmc (u8) |
| 164 |
u8 = svbdep (u8, u8) |
| 165 |
u8 = svbext (u8, u8) |
| 166 |
f32 = svbfmmla (f32, bf16, bf16) |
| 167 |
u8 = svbgrp (u8, u8) |
| 168 |
u32 = svcompact (pred, u32) |
| 169 |
f32 = svadda (pred, 1.0f, f32) |
| 170 |
f32 = svexpa (u32) |
| 171 |
f32 = svmmla (f32, f32, f32) |
| 172 |
f32 = svtmad (f32, f32, 0) |
| 173 |
f32 = svtsmul (f32, u32) |
| 174 |
f32 = svtssel (f32, u32) |
| 175 |
u32 = svhistcnt_z (pred, u32, u32) |
| 176 |
u8 = svhistseg (u8, u8) |
| 177 |
u32 = svld1ub_gather_offset_u32 (pred, u8_ptr, u32) |
| 178 |
u32 = svld1ub_gather_offset_u32 (pred, u32, 1) |
| 179 |
u64 = svld1_gather_index (pred, u64_ptr, u64) |
| 180 |
u64 = svld1_gather_index_u64 (pred, u64, 1) |
| 181 |
u32 = svld1uh_gather_index_u32 (pred, u16_ptr, u32) |
| 182 |
u32 = svld1uh_gather_index_u32 (pred, u32, 1) |
| 183 |
u8 = svld1ro (pred, u8_ptr + indx) |
| 184 |
u8 = svld1ro (pred, u8_ptr + 1) |
| 185 |
u16 = svld1ro (pred, u16_ptr + indx) |
| 186 |
u16 = svld1ro (pred, u16_ptr + 1) |
| 187 |
u32 = svld1ro (pred, u32_ptr + indx) |
| 188 |
u32 = svld1ro (pred, u32_ptr + 1) |
| 189 |
u64 = svld1ro (pred, u64_ptr + indx) |
| 190 |
u64 = svld1ro (pred, u64_ptr + 1) |
| 191 |
u32 = svld1sb_gather_offset_u32 (pred, s8_ptr, u32) |
| 192 |
u32 = svld1sb_gather_offset_u32 (pred, u32, 1) |
| 193 |
u32 = svld1sh_gather_index_u32 (pred, s16_ptr, u32) |
| 194 |
u32 = svld1sh_gather_index_u32 (pred, u32, 1) |
| 195 |
u64 = svld1sw_gather_index_u64 (pred, s32_ptr, u64) |
| 196 |
u64 = svld1sw_gather_index_u64 (pred, u64, 1) |
| 197 |
u64 = svld1uw_gather_index_u64 (pred, u32_ptr, u64) |
| 198 |
u64 = svld1uw_gather_index_u64 (pred, u64, 1) |
| 199 |
u32 = svld1_gather_index (pred, u32_ptr, u32) |
| 200 |
u32 = svld1_gather_index_u32 (pred, u32, 1) |
| 201 |
u8 = svldff1(pred, u8_ptr) |
| 202 |
u16 = svldff1ub_u16(pred, u8_ptr) |
| 203 |
u32 = svldff1ub_u32(pred, u8_ptr) |
| 204 |
u64 = svldff1ub_u64(pred, u8_ptr) |
| 205 |
u32 = svldff1ub_gather_offset_u32 (pred, u8_ptr, u32) |
| 206 |
u32 = svldff1ub_gather_offset_u32 (pred, u32, 1) |
| 207 |
u64 = svldff1(pred, u64_ptr) |
| 208 |
u64 = svldff1_gather_index (pred, u64_ptr, u64) |
| 209 |
u64 = svldff1_gather_index_u64 (pred, u64, 1) |
| 210 |
u16 = svldff1(pred, u16_ptr) |
| 211 |
u32 = svldff1uh_u32(pred, u16_ptr) |
| 212 |
u64 = svldff1uh_u64(pred, u16_ptr) |
| 213 |
u32 = svldff1uh_gather_offset_u32 (pred, u16_ptr, u32) |
| 214 |
u32 = svldff1uh_gather_offset_u32 (pred, u32, 1) |
| 215 |
u16 = svldff1sb_u16(pred, s8_ptr) |
| 216 |
u32 = svldff1sb_u32(pred, s8_ptr) |
| 217 |
u64 = svldff1sb_u64(pred, s8_ptr) |
| 218 |
u32 = svldff1sb_gather_offset_u32 (pred, s8_ptr, u32) |
| 219 |
u32 = svldff1sb_gather_offset_u32 (pred, u32, 1) |
| 220 |
u32 = svldff1sh_u32(pred, s16_ptr) |
| 221 |
u64 = svldff1sh_u64(pred, s16_ptr) |
| 222 |
u32 = svldff1sh_gather_offset_u32 (pred, s16_ptr, u32) |
| 223 |
u32 = svldff1sh_gather_offset_u32 (pred, u32, 1) |
| 224 |
u64 = svldff1sw_u64(pred, s32_ptr) |
| 225 |
u64 = svldff1sw_gather_offset_u64 (pred, s32_ptr, u64) |
| 226 |
u64 = svldff1sw_gather_offset_u64 (pred, u64, 1) |
| 227 |
u32 = svldff1(pred, u32_ptr) |
| 228 |
u32 = svldff1_gather_index (pred, u32_ptr, u32) |
| 229 |
u32 = svldff1_gather_index_u32 (pred, u32, 1) |
| 230 |
u64 = svldff1uw_u64(pred, u32_ptr) |
| 231 |
u64 = svldff1uw_gather_offset_u64 (pred, u32_ptr, u64) |
| 232 |
u64 = svldff1uw_gather_offset_u64 (pred, u64, 1) |
| 233 |
u8 = svldnf1(pred, u8_ptr) |
| 234 |
u16 = svldnf1ub_u16(pred, u8_ptr) |
| 235 |
u32 = svldnf1ub_u32(pred, u8_ptr) |
| 236 |
u64 = svldnf1ub_u64(pred, u8_ptr) |
| 237 |
u64 = svldnf1(pred, u64_ptr) |
| 238 |
u16 = svldnf1(pred, u16_ptr) |
| 239 |
u32 = svldnf1uh_u32(pred, u16_ptr) |
| 240 |
u64 = svldnf1uh_u64(pred, u16_ptr) |
| 241 |
u16 = svldnf1sb_u16(pred, s8_ptr) |
| 242 |
u32 = svldnf1sb_u32(pred, s8_ptr) |
| 243 |
u64 = svldnf1sb_u64(pred, s8_ptr) |
| 244 |
u32 = svldnf1sh_u32(pred, s16_ptr) |
| 245 |
u64 = svldnf1sh_u64(pred, s16_ptr) |
| 246 |
u64 = svldnf1sw_u64(pred, s32_ptr) |
| 247 |
u32 = svldnf1(pred, u32_ptr) |
| 248 |
u64 = svldnf1uw_u64(pred, u32_ptr) |
| 249 |
u32 = svldnt1ub_gather_offset_u32 (pred, u8_ptr, u32) |
| 250 |
u32 = svldnt1ub_gather_offset_u32 (pred, u32, 1) |
| 251 |
u64 = svldnt1_gather_index (pred, u64_ptr, u64) |
| 252 |
u64 = svldnt1_gather_index_u64 (pred, u64, 1) |
| 253 |
u32 = svldnt1uh_gather_offset_u32 (pred, u16_ptr, u32) |
| 254 |
u32 = svldnt1uh_gather_offset_u32 (pred, u32, 1) |
| 255 |
u32 = svldnt1sb_gather_offset_u32 (pred, s8_ptr, u32) |
| 256 |
u32 = svldnt1sb_gather_offset_u32 (pred, u32, 1) |
| 257 |
u32 = svldnt1sh_gather_offset_u32 (pred, s16_ptr, u32) |
| 258 |
u32 = svldnt1sh_gather_offset_u32 (pred, u32, 1) |
| 259 |
u64 = svldnt1sw_gather_offset_u64 (pred, s32_ptr, u64) |
| 260 |
u64 = svldnt1sw_gather_offset_u64 (pred, u64, 1) |
| 261 |
u64 = svldnt1uw_gather_offset_u64 (pred, u32_ptr, u64) |
| 262 |
u64 = svldnt1uw_gather_offset_u64 (pred, u64, 1) |
| 263 |
u32 = svldnt1_gather_offset (pred, u32_ptr, u32) |
| 264 |
u32 = svldnt1_gather_offset_u32 (pred, u32, 1) |
| 265 |
pred = svmatch (pred, u8, u8) |
| 266 |
pred = svnmatch (pred, u8, u8) |
| 267 |
u64 = svpmullb_pair (u64, u64) |
| 268 |
u64 = svpmullt_pair (u64, u64) |
| 269 |
svprfb_gather_offset (pred, void_ptr, u64, SV_PLDL1KEEP) |
| 270 |
svprfb_gather_offset (pred, u64, 1, SV_PLDL1KEEP) |
| 271 |
svprfd_gather_index (pred, void_ptr, u64, SV_PLDL1KEEP) |
| 272 |
svprfd_gather_index (pred, u64, 1, SV_PLDL1KEEP) |
| 273 |
svprfh_gather_index (pred, void_ptr, u64, SV_PLDL1KEEP) |
| 274 |
svprfh_gather_index (pred, u64, 1, SV_PLDL1KEEP) |
| 275 |
svprfw_gather_index (pred, void_ptr, u64, SV_PLDL1KEEP) |
| 276 |
svprfw_gather_index (pred, u64, 1, SV_PLDL1KEEP) |
| 277 |
u64 = svrax1 (u64, u64) |
| 278 |
pred = svrdffr () |
| 279 |
pred = svrdffr_z (pred) |
| 280 |
svsetffr () |
| 281 |
u32 = svsm4e (u32, u32) |
| 282 |
u32 = svsm4ekey (u32, u32) |
| 283 |
s32 = svmmla (s32, s8, s8) |
| 284 |
svst1b_scatter_offset (pred, u8_ptr, u32, u32) |
| 285 |
svst1b_scatter_offset (pred, u32, 1, u32) |
| 286 |
svst1_scatter_index (pred, u64_ptr, u64, u64) |
| 287 |
svst1_scatter_index (pred, u64, 1, u64) |
| 288 |
svst1h_scatter_index (pred, u16_ptr, u32, u32) |
| 289 |
svst1h_scatter_index (pred, u32, 1, u32) |
| 290 |
svst1w_scatter_index (pred, u32_ptr, u64, u64) |
| 291 |
svst1w_scatter_index (pred, u64, 1, u64) |
| 292 |
svst1_scatter_index (pred, u32_ptr, u32, u32) |
| 293 |
svst1_scatter_index (pred, u32, 1, u32) |
| 294 |
svstnt1b_scatter_offset (pred, u8_ptr, u32, u32) |
| 295 |
svstnt1b_scatter_offset (pred, u32, 1, u32) |
| 296 |
svstnt1_scatter_offset (pred, u64_ptr, u64, u64) |
| 297 |
svstnt1_scatter_offset (pred, u64, 1, u64) |
| 298 |
svstnt1h_scatter_offset (pred, u16_ptr, u32, u32) |
| 299 |
svstnt1h_scatter_offset (pred, u32, 1, u32) |
| 300 |
svstnt1w_scatter_offset (pred, u32_ptr, u64, u64) |
| 301 |
svstnt1w_scatter_offset (pred, u64, 1, u64) |
| 302 |
svstnt1_scatter_offset (pred, u32_ptr, u32, u32) |
| 303 |
svstnt1_scatter_offset (pred, u32, 1, u32) |
| 304 |
u8 = svtrn1q (u8, u8) |
| 305 |
u8 = svtrn2q (u8, u8) |
| 306 |
u32 = svmmla (u32, u8, u8) |
| 307 |
u8 = svuzp1q (u8, u8) |
| 308 |
u8 = svuzp2q (u8, u8) |
| 309 |
u8 = svzip1q (u8, u8) |
| 310 |
u8 = svzip2q (u8, u8) |
| 311 |
s32 = svusmmla (s32, u8, s8) |
| 312 |
svwrffr (pred) |
| 313 |
} |
| 314 |
|
| 315 |
check_ssve_calls $sc_harness $streaming_ok 1 |
| 316 |
check_ssve_calls $sc_harness $nonstreaming_only 0 |
| 317 |
|
| 318 |
gcc_parallel_test_enable 1 |