logo

oasis

Own branch of Oasis Linux (upstream: <https://git.sr.ht/~mcf/oasis/>) git clone https://anongit.hacktivis.me/git/oasis.git

0003-Use-__asm__-instead-of-asm-to-compile-with-std-c99.patch (8871B)

    

  1. From 2c79a37719c4f115ad718adae6856f903f5a1e7b Mon Sep 17 00:00:00 2001
  2. From: Michael Forney <mforney@mforney.org>
  3. Date: Tue, 17 Jan 2023 13:07:11 -0800
  4. Subject: [PATCH] Use __asm__ instead of asm to compile with -std=c99
  6. ---
  7.  module/zcommon/zfs_fletcher_intel.c | 44 +++++++--------
  8.  module/zcommon/zfs_fletcher_sse.c   | 86 ++++++++++++++---------------
  9.  2 files changed, 65 insertions(+), 65 deletions(-)
  11. diff --git a/module/zcommon/zfs_fletcher_intel.c b/module/zcommon/zfs_fletcher_intel.c
  12. index 34590a155..9213d083c 100644
  13. --- a/module/zcommon/zfs_fletcher_intel.c
  14. +++ b/module/zcommon/zfs_fletcher_intel.c
  15. @@ -83,18 +83,18 @@ fletcher_4_avx2_fini(fletcher_4_ctx_t *ctx, zio_cksum_t *zcp)
  16.  
  17.  #define	FLETCHER_4_AVX2_RESTORE_CTX(ctx)				\
  18.  {									\
  19. -	asm volatile("vmovdqu %0, %%ymm0" :: "m" ((ctx)->avx[0]));	\
  20. -	asm volatile("vmovdqu %0, %%ymm1" :: "m" ((ctx)->avx[1]));	\
  21. -	asm volatile("vmovdqu %0, %%ymm2" :: "m" ((ctx)->avx[2]));	\
  22. -	asm volatile("vmovdqu %0, %%ymm3" :: "m" ((ctx)->avx[3]));	\
  23. +	__asm__ volatile("vmovdqu %0, %%ymm0" :: "m" ((ctx)->avx[0]));	\
  24. +	__asm__ volatile("vmovdqu %0, %%ymm1" :: "m" ((ctx)->avx[1]));	\
  25. +	__asm__ volatile("vmovdqu %0, %%ymm2" :: "m" ((ctx)->avx[2]));	\
  26. +	__asm__ volatile("vmovdqu %0, %%ymm3" :: "m" ((ctx)->avx[3]));	\
  27.  }
  28.  
  29.  #define	FLETCHER_4_AVX2_SAVE_CTX(ctx)					\
  30.  {									\
  31. -	asm volatile("vmovdqu %%ymm0, %0" : "=m" ((ctx)->avx[0]));	\
  32. -	asm volatile("vmovdqu %%ymm1, %0" : "=m" ((ctx)->avx[1]));	\
  33. -	asm volatile("vmovdqu %%ymm2, %0" : "=m" ((ctx)->avx[2]));	\
  34. -	asm volatile("vmovdqu %%ymm3, %0" : "=m" ((ctx)->avx[3]));	\
  35. +	__asm__ volatile("vmovdqu %%ymm0, %0" : "=m" ((ctx)->avx[0]));	\
  36. +	__asm__ volatile("vmovdqu %%ymm1, %0" : "=m" ((ctx)->avx[1]));	\
  37. +	__asm__ volatile("vmovdqu %%ymm2, %0" : "=m" ((ctx)->avx[2]));	\
  38. +	__asm__ volatile("vmovdqu %%ymm3, %0" : "=m" ((ctx)->avx[3]));	\
  39.  }
  40.  
  41.  
  42. @@ -107,15 +107,15 @@ fletcher_4_avx2_native(fletcher_4_ctx_t *ctx, const void *buf, uint64_t size)
  43.  	FLETCHER_4_AVX2_RESTORE_CTX(ctx);
  44.  
  45.  	do {
  46. -		asm volatile("vpmovzxdq %0, %%ymm4"::"m" (*ip));
  47. -		asm volatile("vpaddq %ymm4, %ymm0, %ymm0");
  48. -		asm volatile("vpaddq %ymm0, %ymm1, %ymm1");
  49. -		asm volatile("vpaddq %ymm1, %ymm2, %ymm2");
  50. -		asm volatile("vpaddq %ymm2, %ymm3, %ymm3");
  51. +		__asm__ volatile("vpmovzxdq %0, %%ymm4"::"m" (*ip));
  52. +		__asm__ volatile("vpaddq %ymm4, %ymm0, %ymm0");
  53. +		__asm__ volatile("vpaddq %ymm0, %ymm1, %ymm1");
  54. +		__asm__ volatile("vpaddq %ymm1, %ymm2, %ymm2");
  55. +		__asm__ volatile("vpaddq %ymm2, %ymm3, %ymm3");
  56.  	} while ((ip += 2) < ipend);
  57.  
  58.  	FLETCHER_4_AVX2_SAVE_CTX(ctx);
  59. -	asm volatile("vzeroupper");
  60. +	__asm__ volatile("vzeroupper");
  61.  }
  62.  
  63.  static void
  64. @@ -130,20 +130,20 @@ fletcher_4_avx2_byteswap(fletcher_4_ctx_t *ctx, const void *buf, uint64_t size)
  65.  
  66.  	FLETCHER_4_AVX2_RESTORE_CTX(ctx);
  67.  
  68. -	asm volatile("vmovdqu %0, %%ymm5" :: "m" (mask));
  69. +	__asm__ volatile("vmovdqu %0, %%ymm5" :: "m" (mask));
  70.  
  71.  	do {
  72. -		asm volatile("vpmovzxdq %0, %%ymm4"::"m" (*ip));
  73. -		asm volatile("vpshufb %ymm5, %ymm4, %ymm4");
  74. +		__asm__ volatile("vpmovzxdq %0, %%ymm4"::"m" (*ip));
  75. +		__asm__ volatile("vpshufb %ymm5, %ymm4, %ymm4");
  76.  
  77. -		asm volatile("vpaddq %ymm4, %ymm0, %ymm0");
  78. -		asm volatile("vpaddq %ymm0, %ymm1, %ymm1");
  79. -		asm volatile("vpaddq %ymm1, %ymm2, %ymm2");
  80. -		asm volatile("vpaddq %ymm2, %ymm3, %ymm3");
  81. +		__asm__ volatile("vpaddq %ymm4, %ymm0, %ymm0");
  82. +		__asm__ volatile("vpaddq %ymm0, %ymm1, %ymm1");
  83. +		__asm__ volatile("vpaddq %ymm1, %ymm2, %ymm2");
  84. +		__asm__ volatile("vpaddq %ymm2, %ymm3, %ymm3");
  85.  	} while ((ip += 2) < ipend);
  86.  
  87.  	FLETCHER_4_AVX2_SAVE_CTX(ctx);
  88. -	asm volatile("vzeroupper");
  89. +	__asm__ volatile("vzeroupper");
  90.  }
  91.  
  92.  static boolean_t fletcher_4_avx2_valid(void)
  93. diff --git a/module/zcommon/zfs_fletcher_sse.c b/module/zcommon/zfs_fletcher_sse.c
  94. index 8ab9b9acb..b942de4a2 100644
  95. --- a/module/zcommon/zfs_fletcher_sse.c
  96. +++ b/module/zcommon/zfs_fletcher_sse.c
  97. @@ -82,18 +82,18 @@ fletcher_4_sse2_fini(fletcher_4_ctx_t *ctx, zio_cksum_t *zcp)
  98.  
  99.  #define	FLETCHER_4_SSE_RESTORE_CTX(ctx)					\
  100.  {									\
  101. -	asm volatile("movdqu %0, %%xmm0" :: "m" ((ctx)->sse[0]));	\
  102. -	asm volatile("movdqu %0, %%xmm1" :: "m" ((ctx)->sse[1]));	\
  103. -	asm volatile("movdqu %0, %%xmm2" :: "m" ((ctx)->sse[2]));	\
  104. -	asm volatile("movdqu %0, %%xmm3" :: "m" ((ctx)->sse[3]));	\
  105. +	__asm__ volatile("movdqu %0, %%xmm0" :: "m" ((ctx)->sse[0]));	\
  106. +	__asm__ volatile("movdqu %0, %%xmm1" :: "m" ((ctx)->sse[1]));	\
  107. +	__asm__ volatile("movdqu %0, %%xmm2" :: "m" ((ctx)->sse[2]));	\
  108. +	__asm__ volatile("movdqu %0, %%xmm3" :: "m" ((ctx)->sse[3]));	\
  109.  }
  110.  
  111.  #define	FLETCHER_4_SSE_SAVE_CTX(ctx)					\
  112.  {									\
  113. -	asm volatile("movdqu %%xmm0, %0" : "=m" ((ctx)->sse[0]));	\
  114. -	asm volatile("movdqu %%xmm1, %0" : "=m" ((ctx)->sse[1]));	\
  115. -	asm volatile("movdqu %%xmm2, %0" : "=m" ((ctx)->sse[2]));	\
  116. -	asm volatile("movdqu %%xmm3, %0" : "=m" ((ctx)->sse[3]));	\
  117. +	__asm__ volatile("movdqu %%xmm0, %0" : "=m" ((ctx)->sse[0]));	\
  118. +	__asm__ volatile("movdqu %%xmm1, %0" : "=m" ((ctx)->sse[1]));	\
  119. +	__asm__ volatile("movdqu %%xmm2, %0" : "=m" ((ctx)->sse[2]));	\
  120. +	__asm__ volatile("movdqu %%xmm3, %0" : "=m" ((ctx)->sse[3]));	\
  121.  }
  122.  
  123.  static void
  124. @@ -104,21 +104,21 @@ fletcher_4_sse2_native(fletcher_4_ctx_t *ctx, const void *buf, uint64_t size)
  125.  
  126.  	FLETCHER_4_SSE_RESTORE_CTX(ctx);
  127.  
  128. -	asm volatile("pxor %xmm4, %xmm4");
  129. +	__asm__ volatile("pxor %xmm4, %xmm4");
  130.  
  131.  	do {
  132. -		asm volatile("movdqu %0, %%xmm5" :: "m"(*ip));
  133. -		asm volatile("movdqa %xmm5, %xmm6");
  134. -		asm volatile("punpckldq %xmm4, %xmm5");
  135. -		asm volatile("punpckhdq %xmm4, %xmm6");
  136. -		asm volatile("paddq %xmm5, %xmm0");
  137. -		asm volatile("paddq %xmm0, %xmm1");
  138. -		asm volatile("paddq %xmm1, %xmm2");
  139. -		asm volatile("paddq %xmm2, %xmm3");
  140. -		asm volatile("paddq %xmm6, %xmm0");
  141. -		asm volatile("paddq %xmm0, %xmm1");
  142. -		asm volatile("paddq %xmm1, %xmm2");
  143. -		asm volatile("paddq %xmm2, %xmm3");
  144. +		__asm__ volatile("movdqu %0, %%xmm5" :: "m"(*ip));
  145. +		__asm__ volatile("movdqa %xmm5, %xmm6");
  146. +		__asm__ volatile("punpckldq %xmm4, %xmm5");
  147. +		__asm__ volatile("punpckhdq %xmm4, %xmm6");
  148. +		__asm__ volatile("paddq %xmm5, %xmm0");
  149. +		__asm__ volatile("paddq %xmm0, %xmm1");
  150. +		__asm__ volatile("paddq %xmm1, %xmm2");
  151. +		__asm__ volatile("paddq %xmm2, %xmm3");
  152. +		__asm__ volatile("paddq %xmm6, %xmm0");
  153. +		__asm__ volatile("paddq %xmm0, %xmm1");
  154. +		__asm__ volatile("paddq %xmm1, %xmm2");
  155. +		__asm__ volatile("paddq %xmm2, %xmm3");
  156.  	} while ((ip += 2) < ipend);
  157.  
  158.  	FLETCHER_4_SSE_SAVE_CTX(ctx);
  159. @@ -135,13 +135,13 @@ fletcher_4_sse2_byteswap(fletcher_4_ctx_t *ctx, const void *buf, uint64_t size)
  160.  	do {
  161.  		uint32_t scratch1 = BSWAP_32(ip[0]);
  162.  		uint32_t scratch2 = BSWAP_32(ip[1]);
  163. -		asm volatile("movd %0, %%xmm5" :: "r"(scratch1));
  164. -		asm volatile("movd %0, %%xmm6" :: "r"(scratch2));
  165. -		asm volatile("punpcklqdq %xmm6, %xmm5");
  166. -		asm volatile("paddq %xmm5, %xmm0");
  167. -		asm volatile("paddq %xmm0, %xmm1");
  168. -		asm volatile("paddq %xmm1, %xmm2");
  169. -		asm volatile("paddq %xmm2, %xmm3");
  170. +		__asm__ volatile("movd %0, %%xmm5" :: "r"(scratch1));
  171. +		__asm__ volatile("movd %0, %%xmm6" :: "r"(scratch2));
  172. +		__asm__ volatile("punpcklqdq %xmm6, %xmm5");
  173. +		__asm__ volatile("paddq %xmm5, %xmm0");
  174. +		__asm__ volatile("paddq %xmm0, %xmm1");
  175. +		__asm__ volatile("paddq %xmm1, %xmm2");
  176. +		__asm__ volatile("paddq %xmm2, %xmm3");
  177.  	} while ((ip += 2) < ipend);
  178.  
  179.  	FLETCHER_4_SSE_SAVE_CTX(ctx);
  180. @@ -179,23 +179,23 @@ fletcher_4_ssse3_byteswap(fletcher_4_ctx_t *ctx, const void *buf, uint64_t size)
  181.  
  182.  	FLETCHER_4_SSE_RESTORE_CTX(ctx);
  183.  
  184. -	asm volatile("movdqu %0, %%xmm7"::"m" (mask));
  185. -	asm volatile("pxor %xmm4, %xmm4");
  186. +	__asm__ volatile("movdqu %0, %%xmm7"::"m" (mask));
  187. +	__asm__ volatile("pxor %xmm4, %xmm4");
  188.  
  189.  	do {
  190. -		asm volatile("movdqu %0, %%xmm5"::"m" (*ip));
  191. -		asm volatile("pshufb %xmm7, %xmm5");
  192. -		asm volatile("movdqa %xmm5, %xmm6");
  193. -		asm volatile("punpckldq %xmm4, %xmm5");
  194. -		asm volatile("punpckhdq %xmm4, %xmm6");
  195. -		asm volatile("paddq %xmm5, %xmm0");
  196. -		asm volatile("paddq %xmm0, %xmm1");
  197. -		asm volatile("paddq %xmm1, %xmm2");
  198. -		asm volatile("paddq %xmm2, %xmm3");
  199. -		asm volatile("paddq %xmm6, %xmm0");
  200. -		asm volatile("paddq %xmm0, %xmm1");
  201. -		asm volatile("paddq %xmm1, %xmm2");
  202. -		asm volatile("paddq %xmm2, %xmm3");
  203. +		__asm__ volatile("movdqu %0, %%xmm5"::"m" (*ip));
  204. +		__asm__ volatile("pshufb %xmm7, %xmm5");
  205. +		__asm__ volatile("movdqa %xmm5, %xmm6");
  206. +		__asm__ volatile("punpckldq %xmm4, %xmm5");
  207. +		__asm__ volatile("punpckhdq %xmm4, %xmm6");
  208. +		__asm__ volatile("paddq %xmm5, %xmm0");
  209. +		__asm__ volatile("paddq %xmm0, %xmm1");
  210. +		__asm__ volatile("paddq %xmm1, %xmm2");
  211. +		__asm__ volatile("paddq %xmm2, %xmm3");
  212. +		__asm__ volatile("paddq %xmm6, %xmm0");
  213. +		__asm__ volatile("paddq %xmm0, %xmm1");
  214. +		__asm__ volatile("paddq %xmm1, %xmm2");
  215. +		__asm__ volatile("paddq %xmm2, %xmm3");
  216.  	} while ((ip += 2) < ipend);
  217.  
  218.  	FLETCHER_4_SSE_SAVE_CTX(ctx);
  219. -- 
  220. 2.37.3