Apply 0028-cstd-asm.patch

dpaoliello · sivadeilra · commit a11a842bfa16 · 2025-11-07T15:09:52.000-08:00
diff --git a/clang/lib/Headers/immintrin.h b/clang/lib/Headers/immintrin.h
@@ -306,25 +306,25 @@ _writegsbase_u64(unsigned long long __V)
 // REVIEW: Decide if upgrade to builtins
 static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))
 __writegsbyte(unsigned long __offset,unsigned char __data) {
-  __asm__ volatile ("movb	%0,%%gs:%c1"
+  __asm__ __volatile__ ("movb	%0,%%gs:%c1"
                     : : "ir"(__data), "ir"(__offset) : "memory");
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))
 __writegsword(unsigned long __offset,unsigned short __data) {
-  __asm__ volatile ("movw	%0,%%gs:%c1"
+  __asm__ __volatile__ ("movw	%0,%%gs:%c1"
                     : : "ir"(__data), "ir"(__offset) : "memory");
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))
 __writegsdword(unsigned long __offset,unsigned long __data) {
-  __asm__ volatile ("movl	%0,%%gs:%c1"
+  __asm__ __volatile__ ("movl	%0,%%gs:%c1"
                     : : "ir"(__data), "ir"(__offset) : "memory");
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))
 __writegsqword(unsigned long __offset,unsigned __int64 __data) {
-  __asm__ volatile ("movq	%0,%%gs:%c1"
+  __asm__ __volatile__ ("movq	%0,%%gs:%c1"
                     : : "ir"(__data), "ir"(__offset) : "memory");
 }
 
diff --git a/clang/lib/Headers/intrin.h b/clang/lib/Headers/intrin.h
@@ -368,7 +368,7 @@ static __inline__ void __DEFAULT_FN_ATTRS __stosq(unsigned __int64 *__dst,
 \*----------------------------------------------------------------------------*/
 #if defined(__i386__) || (defined(__x86_64__) && !defined(__arm64ec__))
 static __inline__ void __DEFAULT_FN_ATTRS __halt(void) {
-  __asm__ volatile("hlt");
+  __asm__ __volatile__("hlt");
 }
 
 static __inline__ unsigned char __inbyte(unsigned short port) {
@@ -391,20 +391,20 @@ static __inline__ unsigned long __indword(unsigned short port) {
 
 static inline void __inbytestring(unsigned short port, unsigned char* buffer, unsigned long count)
 {
-    asm volatile("rep insb" : "+D"(buffer), "+c"(count) : "d"(port) : "memory");
+    __asm__ __volatile__("rep insb" : "+D"(buffer), "+c"(count) : "d"(port) : "memory");
 }
 
 static inline void __inwordstring(unsigned short port, unsigned short* buffer, unsigned long count)
 {
-    asm volatile("rep insw" : "+D"(buffer), "+c"(count) : "d"(port) : "memory");
+    __asm__ __volatile__("rep insw" : "+D"(buffer), "+c"(count) : "d"(port) : "memory");
 }
 
 static inline void __indwordstring(unsigned short port, unsigned long* buffer, unsigned long count)
 {
     unsigned long* word_buffer = (unsigned long*)buffer;
     unsigned long word_count = count * 2;  // Each double word is 2 words
 
-    asm volatile("rep insw" : "+D"(word_buffer), "+c"(word_count) : "d"(port) : "memory");
+    __asm__ __volatile__("rep insw" : "+D"(word_buffer), "+c"(word_count) : "d"(port) : "memory");
 }
 
 static __inline__ void __outbyte(unsigned short port, unsigned char data) {
@@ -421,20 +421,20 @@ static __inline__ void __outdword(unsigned short port, unsigned long data) {
 
 static inline void __outbytestring(unsigned short port, unsigned char* buffer, unsigned long count)
 {
-    asm volatile("rep outsb" : "+S"(buffer), "+c"(count) : "d"(port) : "memory");
+    __asm__ __volatile__("rep outsb" : "+S"(buffer), "+c"(count) : "d"(port) : "memory");
 }
 
 static inline void __outwordstring(unsigned short port, unsigned short* buffer, unsigned long count)
 {
-    asm volatile("rep outsw" : "+S"(buffer), "+c"(count) : "d"(port) : "memory");
+    __asm__ __volatile__("rep outsw" : "+S"(buffer), "+c"(count) : "d"(port) : "memory");
 }
 
 static inline void __outdwordstring(unsigned short port, unsigned long* buffer, unsigned long count)
 {
     unsigned long* word_buffer = (unsigned long*)buffer;
     unsigned long word_count = count * 2;  // Each double word is 2 words
 
-    asm volatile("rep outsw" : "+S"(word_buffer), "+c"(word_count) : "d"(port) : "memory");
+    __asm__ __volatile__ ("rep outsw" : "+S"(word_buffer), "+c"(word_count) : "d"(port) : "memory");
 }
 
 static __inline__ unsigned __int64 __readpmc(unsigned long __A) {
@@ -445,7 +445,7 @@ static __inline__ unsigned __int64 __readpmc(unsigned long __A) {
 
 #if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__)
 static __inline__ void __DEFAULT_FN_ATTRS __nop(void) {
-  __asm__ volatile("nop");
+  __asm__ __volatile__("nop");
 }
 #endif
 
@@ -627,13 +627,13 @@ void __cdecl __prefetch(const void *);
 static __inline__ void  __DEFAULT_FN_ATTRS
 _disable(void)
 {
-    asm volatile ("msr DAIFSet, #2");
+    __asm__ __volatile__ ("msr DAIFSet, #2");
 }
 
 static __inline__ void __DEFAULT_FN_ATTRS
 _enable(void)
 {
-    asm volatile ("msr DAIFClr, #2");
+    __asm__ __volatile__ ("msr DAIFClr, #2");
 }
 
 static __inline__ unsigned __int32 __DEFAULT_FN_ATTRS
@@ -655,9 +655,9 @@ __stlr64(unsigned __int64 volatile * _Target, unsigned __int64 _Value)
 static __inline__ void * __DEFAULT_FN_ATTRS
 __xpaci (void *_Pointer)
 {
-    register void *__lr asm ("lr") = _Pointer;
+    register void *__lr __asm__ ("lr") = _Pointer;
 
-    asm volatile ("xpaclri" : "+r"(__lr));
+    __asm__ __volatile__ ("xpaclri" : "+r"(__lr));
     return __lr;
 }
 
@@ -683,7 +683,7 @@ __readmsr(unsigned long __register) {
 
 static __inline__ void __DEFAULT_FN_ATTRS
 __writemsr(unsigned long __register, unsigned __int64 __value) {
-    asm volatile("wrmsr" : : "d"((unsigned long)(__value >> 32)), "a"((unsigned long)__value), "c"(__register));
+    __asm__ __volatile__("wrmsr" : : "d"((unsigned long)(__value >> 32)), "a"((unsigned long)__value), "c"(__register));
 }
 
 static __inline__ unsigned __LPTRINT_TYPE__ __DEFAULT_FN_ATTRS __readcr0(void) {
@@ -738,27 +738,27 @@ static __inline__ unsigned __LPTRINT_TYPE__ __DEFAULT_FN_ATTRS __readcr8(void) {
 
 static __inline__ void __DEFAULT_FN_ATTRS
 __writecr0(unsigned __INTPTR_TYPE__ __cr0_val) {
-  __asm__ ("mov {%0, %%cr0|cr0, %0}" : : "r"(__cr0_val) : "memory");
+  __asm__ __volatile__("mov {%0, %%cr0|cr0, %0}" : : "r"(__cr0_val) : "memory");
 }
 
 static __inline__ void __DEFAULT_FN_ATTRS
 __writecr2(unsigned __INTPTR_TYPE__ __cr2_val) {
-  __asm__ ("mov {%0, %%cr2|cr2, %0}" : : "r"(__cr2_val) : "memory");
+  __asm__ __volatile__("mov {%0, %%cr2|cr2, %0}" : : "r"(__cr2_val) : "memory");
 }
 
 static __inline__ void __DEFAULT_FN_ATTRS
 __writecr3(unsigned __INTPTR_TYPE__ __cr3_val) {
-  __asm__ ("mov {%0, %%cr3|cr3, %0}" : : "r"(__cr3_val) : "memory");
+  __asm__ __volatile__("mov {%0, %%cr3|cr3, %0}" : : "r"(__cr3_val) : "memory");
 }
 
 static __inline__ void __DEFAULT_FN_ATTRS
 __writecr4(unsigned __INTPTR_TYPE__ __cr4_val) {
-  __asm__ ("mov {%0, %%cr4|cr4, %0}" : : "r"(__cr4_val) : "memory");
+  __asm__ __volatile__("mov {%0, %%cr4|cr4, %0}" : : "r"(__cr4_val) : "memory");
 }
 
 static __inline__ void __DEFAULT_FN_ATTRS
 __writecr8(unsigned __INTPTR_TYPE__ __cr8_val) {
-  __asm__ ("mov {%0, %%cr8|cr8, %0}" : : "r"(__cr8_val) : "memory");
+  __asm__ __volatile__("mov {%0, %%cr8|cr8, %0}" : : "r"(__cr8_val) : "memory");
 }
 
 static __inline__ void __lidt(void *source) {
@@ -770,11 +770,11 @@ static __inline__ void __sidt(void *source) {
 }
 
 static __inline__ void  _enable(void) {
-  __asm__ volatile("sti");
+  __asm__ __volatile__("sti");
 }
 
 static __inline__ void  _disable(void) {
-  __asm__ volatile("cli");
+  __asm__ __volatile__("cli");
 }
 
 static __inline__ void _clac(void) {
@@ -786,7 +786,7 @@ static __inline__ void _stac(void) {
 }
 
 static __inline__ void __invlpg(void *va) {
-    asm volatile("invlpg (%0)" : : "r"(va) : "memory");
+    __asm__ __volatile__("invlpg (%0)" : : "r"(va) : "memory");
 }
 
 #endif

Original file line number	Diff line number	Diff line change
`@@ -368,7 +368,7 @@ static __inline__ void __DEFAULT_FN_ATTRS __stosq(unsigned __int64 *__dst,`
`368`	`368`	`\----------------------------------------------------------------------------/`
`369`	`369`	`#if defined(__i386__) \|\| (defined(__x86_64__) && !defined(__arm64ec__))`
`370`	`370`	`static __inline__ void __DEFAULT_FN_ATTRS __halt(void) {`
`371`		`- __asm__ volatile("hlt");`
	`371`	`+ __asm__ __volatile__("hlt");`
`372`	`372`	`}`
`373`	`373`
`374`	`374`	`static __inline__ unsigned char __inbyte(unsigned short port) {`
`@@ -391,20 +391,20 @@ static __inline__ unsigned long __indword(unsigned short port) {`
`391`	`391`
`392`	`392`	`static inline void __inbytestring(unsigned short port, unsigned char* buffer, unsigned long count)`
`393`	`393`	`{`
`394`		`- asm volatile("rep insb" : "+D"(buffer), "+c"(count) : "d"(port) : "memory");`
	`394`	`+ __asm__ __volatile__("rep insb" : "+D"(buffer), "+c"(count) : "d"(port) : "memory");`
`395`	`395`	`}`
`396`	`396`
`397`	`397`	`static inline void __inwordstring(unsigned short port, unsigned short* buffer, unsigned long count)`
`398`	`398`	`{`
`399`		`- asm volatile("rep insw" : "+D"(buffer), "+c"(count) : "d"(port) : "memory");`
	`399`	`+ __asm__ __volatile__("rep insw" : "+D"(buffer), "+c"(count) : "d"(port) : "memory");`
`400`	`400`	`}`
`401`	`401`
`402`	`402`	`static inline void __indwordstring(unsigned short port, unsigned long* buffer, unsigned long count)`
`403`	`403`	`{`
`404`	`404`	`unsigned long* word_buffer = (unsigned long*)buffer;`
`405`	`405`	`unsigned long word_count = count * 2; // Each double word is 2 words`
`406`	`406`
`407`		`- asm volatile("rep insw" : "+D"(word_buffer), "+c"(word_count) : "d"(port) : "memory");`
	`407`	`+ __asm__ __volatile__("rep insw" : "+D"(word_buffer), "+c"(word_count) : "d"(port) : "memory");`
`408`	`408`	`}`
`409`	`409`
`410`	`410`	`static __inline__ void __outbyte(unsigned short port, unsigned char data) {`
`@@ -421,20 +421,20 @@ static __inline__ void __outdword(unsigned short port, unsigned long data) {`
`421`	`421`
`422`	`422`	`static inline void __outbytestring(unsigned short port, unsigned char* buffer, unsigned long count)`
`423`	`423`	`{`
`424`		`- asm volatile("rep outsb" : "+S"(buffer), "+c"(count) : "d"(port) : "memory");`
	`424`	`+ __asm__ __volatile__("rep outsb" : "+S"(buffer), "+c"(count) : "d"(port) : "memory");`
`425`	`425`	`}`
`426`	`426`
`427`	`427`	`static inline void __outwordstring(unsigned short port, unsigned short* buffer, unsigned long count)`
`428`	`428`	`{`
`429`		`- asm volatile("rep outsw" : "+S"(buffer), "+c"(count) : "d"(port) : "memory");`
	`429`	`+ __asm__ __volatile__("rep outsw" : "+S"(buffer), "+c"(count) : "d"(port) : "memory");`
`430`	`430`	`}`
`431`	`431`
`432`	`432`	`static inline void __outdwordstring(unsigned short port, unsigned long* buffer, unsigned long count)`
`433`	`433`	`{`
`434`	`434`	`unsigned long* word_buffer = (unsigned long*)buffer;`
`435`	`435`	`unsigned long word_count = count * 2; // Each double word is 2 words`
`436`	`436`
`437`		`- asm volatile("rep outsw" : "+S"(word_buffer), "+c"(word_count) : "d"(port) : "memory");`
	`437`	`+ __asm__ __volatile__ ("rep outsw" : "+S"(word_buffer), "+c"(word_count) : "d"(port) : "memory");`
`438`	`438`	`}`
`439`	`439`
`440`	`440`	`static __inline__ unsigned __int64 __readpmc(unsigned long __A) {`
`@@ -445,7 +445,7 @@ static __inline__ unsigned __int64 __readpmc(unsigned long __A) {`
`445`	`445`
`446`	`446`	`#if defined(__i386__) \|\| defined(__x86_64__) \|\| defined(__aarch64__)`
`447`	`447`	`static __inline__ void __DEFAULT_FN_ATTRS __nop(void) {`
`448`		`- __asm__ volatile("nop");`
	`448`	`+ __asm__ __volatile__("nop");`
`449`	`449`	`}`
`450`	`450`	`#endif`
`451`	`451`
`@@ -627,13 +627,13 @@ void __cdecl __prefetch(const void *);`
`627`	`627`	`static __inline__ void __DEFAULT_FN_ATTRS`
`628`	`628`	`_disable(void)`
`629`	`629`	`{`
`630`		`- asm volatile ("msr DAIFSet, #2");`
	`630`	`+ __asm__ __volatile__ ("msr DAIFSet, #2");`
`631`	`631`	`}`
`632`	`632`
`633`	`633`	`static __inline__ void __DEFAULT_FN_ATTRS`
`634`	`634`	`_enable(void)`
`635`	`635`	`{`
`636`		`- asm volatile ("msr DAIFClr, #2");`
	`636`	`+ __asm__ __volatile__ ("msr DAIFClr, #2");`
`637`	`637`	`}`
`638`	`638`
`639`	`639`	`static __inline__ unsigned __int32 __DEFAULT_FN_ATTRS`
`@@ -655,9 +655,9 @@ __stlr64(unsigned __int64 volatile * _Target, unsigned __int64 _Value)`
`655`	`655`	`static __inline__ void * __DEFAULT_FN_ATTRS`
`656`	`656`	`__xpaci (void *_Pointer)`
`657`	`657`	`{`
`658`		`- register void *__lr asm ("lr") = _Pointer;`
	`658`	`+ register void *__lr __asm__ ("lr") = _Pointer;`
`659`	`659`
`660`		`- asm volatile ("xpaclri" : "+r"(__lr));`
	`660`	`+ __asm__ __volatile__ ("xpaclri" : "+r"(__lr));`
`661`	`661`	`return __lr;`
`662`	`662`	`}`
`663`	`663`
`@@ -683,7 +683,7 @@ __readmsr(unsigned long __register) {`
`683`	`683`
`684`	`684`	`static __inline__ void __DEFAULT_FN_ATTRS`
`685`	`685`	`__writemsr(unsigned long __register, unsigned __int64 __value) {`
`686`		`- asm volatile("wrmsr" : : "d"((unsigned long)(__value >> 32)), "a"((unsigned long)__value), "c"(__register));`
	`686`	`+ __asm__ __volatile__("wrmsr" : : "d"((unsigned long)(__value >> 32)), "a"((unsigned long)__value), "c"(__register));`
`687`	`687`	`}`
`688`	`688`
`689`	`689`	`static __inline__ unsigned __LPTRINT_TYPE__ __DEFAULT_FN_ATTRS __readcr0(void) {`
`@@ -738,27 +738,27 @@ static __inline__ unsigned __LPTRINT_TYPE__ __DEFAULT_FN_ATTRS __readcr8(void) {`
`738`	`738`
`739`	`739`	`static __inline__ void __DEFAULT_FN_ATTRS`
`740`	`740`	`__writecr0(unsigned __INTPTR_TYPE__ __cr0_val) {`
`741`		`- __asm__ ("mov {%0, %%cr0\|cr0, %0}" : : "r"(__cr0_val) : "memory");`
	`741`	`+ __asm__ __volatile__("mov {%0, %%cr0\|cr0, %0}" : : "r"(__cr0_val) : "memory");`
`742`	`742`	`}`
`743`	`743`
`744`	`744`	`static __inline__ void __DEFAULT_FN_ATTRS`
`745`	`745`	`__writecr2(unsigned __INTPTR_TYPE__ __cr2_val) {`
`746`		`- __asm__ ("mov {%0, %%cr2\|cr2, %0}" : : "r"(__cr2_val) : "memory");`
	`746`	`+ __asm__ __volatile__("mov {%0, %%cr2\|cr2, %0}" : : "r"(__cr2_val) : "memory");`
`747`	`747`	`}`
`748`	`748`
`749`	`749`	`static __inline__ void __DEFAULT_FN_ATTRS`
`750`	`750`	`__writecr3(unsigned __INTPTR_TYPE__ __cr3_val) {`
`751`		`- __asm__ ("mov {%0, %%cr3\|cr3, %0}" : : "r"(__cr3_val) : "memory");`
	`751`	`+ __asm__ __volatile__("mov {%0, %%cr3\|cr3, %0}" : : "r"(__cr3_val) : "memory");`
`752`	`752`	`}`
`753`	`753`
`754`	`754`	`static __inline__ void __DEFAULT_FN_ATTRS`
`755`	`755`	`__writecr4(unsigned __INTPTR_TYPE__ __cr4_val) {`
`756`		`- __asm__ ("mov {%0, %%cr4\|cr4, %0}" : : "r"(__cr4_val) : "memory");`
	`756`	`+ __asm__ __volatile__("mov {%0, %%cr4\|cr4, %0}" : : "r"(__cr4_val) : "memory");`
`757`	`757`	`}`
`758`	`758`
`759`	`759`	`static __inline__ void __DEFAULT_FN_ATTRS`
`760`	`760`	`__writecr8(unsigned __INTPTR_TYPE__ __cr8_val) {`
`761`		`- __asm__ ("mov {%0, %%cr8\|cr8, %0}" : : "r"(__cr8_val) : "memory");`
	`761`	`+ __asm__ __volatile__("mov {%0, %%cr8\|cr8, %0}" : : "r"(__cr8_val) : "memory");`
`762`	`762`	`}`
`763`	`763`
`764`	`764`	`static __inline__ void __lidt(void *source) {`
`@@ -770,11 +770,11 @@ static __inline__ void __sidt(void *source) {`
`770`	`770`	`}`
`771`	`771`
`772`	`772`	`static __inline__ void _enable(void) {`
`773`		`- __asm__ volatile("sti");`
	`773`	`+ __asm__ __volatile__("sti");`
`774`	`774`	`}`
`775`	`775`
`776`	`776`	`static __inline__ void _disable(void) {`
`777`		`- __asm__ volatile("cli");`
	`777`	`+ __asm__ __volatile__("cli");`
`778`	`778`	`}`
`779`	`779`
`780`	`780`	`static __inline__ void _clac(void) {`
`@@ -786,7 +786,7 @@ static __inline__ void _stac(void) {`
`786`	`786`	`}`
`787`	`787`
`788`	`788`	`static __inline__ void __invlpg(void *va) {`
`789`		`- asm volatile("invlpg (%0)" : : "r"(va) : "memory");`
	`789`	`+ __asm__ __volatile__("invlpg (%0)" : : "r"(va) : "memory");`
`790`	`790`	`}`
`791`	`791`
`792`	`792`	`#endif`