Index: kernel/arch/sparc64/include/asm.h
===================================================================
--- kernel/arch/sparc64/include/asm.h	(revision f429331b6108df4294a421a92f3e9aaa64d95732)
+++ kernel/arch/sparc64/include/asm.h	(revision e7b7be3ff072782e570cb6ee64b50b1625a3fd89)
@@ -52,5 +52,5 @@
 	uint64_t v;
 	
-	__asm__ volatile ("rdpr %%pstate, %0\n" : "=r" (v));
+	asm volatile ("rdpr %%pstate, %0\n" : "=r" (v));
 	
 	return v;
@@ -63,5 +63,5 @@
 static inline void pstate_write(uint64_t v)
 {
-	__asm__ volatile ("wrpr %0, %1, %%pstate\n" : : "r" (v), "i" (0));
+	asm volatile ("wrpr %0, %1, %%pstate\n" : : "r" (v), "i" (0));
 }
 
@@ -74,5 +74,5 @@
 	uint64_t v;
 	
-	__asm__ volatile ("rd %%tick_cmpr, %0\n" : "=r" (v));
+	asm volatile ("rd %%tick_cmpr, %0\n" : "=r" (v));
 	
 	return v;
@@ -85,5 +85,5 @@
 static inline void tick_compare_write(uint64_t v)
 {
-	__asm__ volatile ("wr %0, %1, %%tick_cmpr\n" : : "r" (v), "i" (0));
+	asm volatile ("wr %0, %1, %%tick_cmpr\n" : : "r" (v), "i" (0));
 }
 
@@ -96,5 +96,5 @@
 	uint64_t v;
 	
-	__asm__ volatile ("rdpr %%tick, %0\n" : "=r" (v));
+	asm volatile ("rdpr %%tick, %0\n" : "=r" (v));
 	
 	return v;
@@ -107,5 +107,5 @@
 static inline void tick_write(uint64_t v)
 {
-	__asm__ volatile ("wrpr %0, %1, %%tick\n" : : "r" (v), "i" (0));
+	asm volatile ("wrpr %0, %1, %%tick\n" : : "r" (v), "i" (0));
 }
 
@@ -118,5 +118,5 @@
 	uint64_t v;
 	
-	__asm__ volatile ("rd %%fprs, %0\n" : "=r" (v));
+	asm volatile ("rd %%fprs, %0\n" : "=r" (v));
 	
 	return v;
@@ -129,5 +129,5 @@
 static inline void fprs_write(uint64_t v)
 {
-	__asm__ volatile ("wr %0, %1, %%fprs\n" : : "r" (v), "i" (0));
+	asm volatile ("wr %0, %1, %%fprs\n" : : "r" (v), "i" (0));
 }
 
@@ -140,5 +140,5 @@
 	uint64_t v;
 
-	__asm__ volatile ("rd %%softint, %0\n" : "=r" (v));
+	asm volatile ("rd %%softint, %0\n" : "=r" (v));
 
 	return v;
@@ -151,5 +151,5 @@
 static inline void softint_write(uint64_t v)
 {
-	__asm__ volatile ("wr %0, %1, %%softint\n" : : "r" (v), "i" (0));
+	asm volatile ("wr %0, %1, %%softint\n" : : "r" (v), "i" (0));
 }
 
@@ -162,5 +162,5 @@
 static inline void clear_softint_write(uint64_t v)
 {
-	__asm__ volatile ("wr %0, %1, %%clear_softint\n" : : "r" (v), "i" (0));
+	asm volatile ("wr %0, %1, %%clear_softint\n" : : "r" (v), "i" (0));
 }
 
@@ -173,5 +173,5 @@
 static inline void set_softint_write(uint64_t v)
 {
-	__asm__ volatile ("wr %0, %1, %%set_softint\n" : : "r" (v), "i" (0));
+	asm volatile ("wr %0, %1, %%set_softint\n" : : "r" (v), "i" (0));
 }
 
@@ -248,5 +248,5 @@
 	uintptr_t unbiased_sp;
 	
-	__asm__ volatile ("add %%sp, %1, %0\n" : "=r" (unbiased_sp) : "i" (STACK_BIAS));
+	asm volatile ("add %%sp, %1, %0\n" : "=r" (unbiased_sp) : "i" (STACK_BIAS));
 	
 	return ALIGN_DOWN(unbiased_sp, STACK_SIZE);
@@ -261,5 +261,5 @@
 	uint64_t v;
 	
-	__asm__ volatile ("rdpr %%ver, %0\n" : "=r" (v));
+	asm volatile ("rdpr %%ver, %0\n" : "=r" (v));
 	
 	return v;
@@ -274,5 +274,5 @@
 	uint64_t v;
 	
-	__asm__ volatile ("rdpr %%tpc, %0\n" : "=r" (v));
+	asm volatile ("rdpr %%tpc, %0\n" : "=r" (v));
 	
 	return v;
@@ -287,5 +287,5 @@
 	uint64_t v;
 	
-	__asm__ volatile ("rdpr %%tl, %0\n" : "=r" (v));
+	asm volatile ("rdpr %%tl, %0\n" : "=r" (v));
 	
 	return v;
@@ -300,5 +300,5 @@
 	uint64_t v;
 	
-	__asm__ volatile ("rdpr %%tba, %0\n" : "=r" (v));
+	asm volatile ("rdpr %%tba, %0\n" : "=r" (v));
 	
 	return v;
@@ -311,5 +311,5 @@
 static inline void tba_write(uint64_t v)
 {
-	__asm__ volatile ("wrpr %0, %1, %%tba\n" : : "r" (v), "i" (0));
+	asm volatile ("wrpr %0, %1, %%tba\n" : : "r" (v), "i" (0));
 }
 
@@ -325,5 +325,5 @@
 	uint64_t v;
 	
-	__asm__ volatile ("ldxa [%1] %2, %0\n" : "=r" (v) : "r" (va), "i" ((unsigned) asi));
+	asm volatile ("ldxa [%1] %2, %0\n" : "=r" (v) : "r" (va), "i" ((unsigned) asi));
 	
 	return v;
@@ -338,5 +338,5 @@
 static inline void asi_u64_write(asi_t asi, uintptr_t va, uint64_t v)
 {
-	__asm__ volatile ("stxa %0, [%1] %2\n" : :  "r" (v), "r" (va), "i" ((unsigned) asi) : "memory");
+	asm volatile ("stxa %0, [%1] %2\n" : :  "r" (v), "r" (va), "i" ((unsigned) asi) : "memory");
 }
 
@@ -344,5 +344,5 @@
 static inline void flushw(void)
 {
-	__asm__ volatile ("flushw\n");
+	asm volatile ("flushw\n");
 }
 
@@ -350,5 +350,5 @@
 static inline void nucleus_enter(void)
 {
-	__asm__ volatile ("wrpr %g0, 1, %tl\n");
+	asm volatile ("wrpr %g0, 1, %tl\n");
 }
 
@@ -356,5 +356,5 @@
 static inline void nucleus_leave(void)
 {
-	__asm__ volatile ("wrpr %g0, %g0, %tl\n");
+	asm volatile ("wrpr %g0, %g0, %tl\n");
 }
 
Index: kernel/arch/sparc64/include/atomic.h
===================================================================
--- kernel/arch/sparc64/include/atomic.h	(revision f429331b6108df4294a421a92f3e9aaa64d95732)
+++ kernel/arch/sparc64/include/atomic.h	(revision e7b7be3ff072782e570cb6ee64b50b1625a3fd89)
@@ -58,5 +58,5 @@
 		a = *((uint64_t *) x);
 		b = a + i;
-		__asm__ volatile ("casx %0, %2, %1\n" : "+m" (*((uint64_t *)x)), "+r" (b) : "r" (a));
+		asm volatile ("casx %0, %2, %1\n" : "+m" (*((uint64_t *)x)), "+r" (b) : "r" (a));
 	} while (a != b);
 
@@ -99,5 +99,5 @@
 	volatile uintptr_t x = (uint64_t) &val->count;
 
-	__asm__ volatile ("casx %0, %2, %1\n" : "+m" (*((uint64_t *) x)), "+r" (v) : "r" (0));
+	asm volatile ("casx %0, %2, %1\n" : "+m" (*((uint64_t *) x)), "+r" (v) : "r" (0));
 
 	return v;
@@ -111,5 +111,5 @@
 	volatile uintptr_t x = (uint64_t) &val->count;
 
-	__asm__ volatile (
+	asm volatile (
 	"0:\n"
 		"casx %0, %3, %1\n"
Index: kernel/arch/sparc64/include/barrier.h
===================================================================
--- kernel/arch/sparc64/include/barrier.h	(revision f429331b6108df4294a421a92f3e9aaa64d95732)
+++ kernel/arch/sparc64/include/barrier.h	(revision e7b7be3ff072782e570cb6ee64b50b1625a3fd89)
@@ -40,10 +40,10 @@
  */
 #define CS_ENTER_BARRIER() 				\
-	__asm__ volatile (				\
+	asm volatile (				\
 		"membar #LoadLoad | #LoadStore\n"	\
 		::: "memory"				\
 	)
 #define CS_LEAVE_BARRIER()				\
-	__asm__ volatile ( 				\
+	asm volatile ( 				\
 		"membar #StoreStore\n"			\
 		"membar #LoadStore\n"			\
@@ -52,9 +52,9 @@
 
 #define memory_barrier()	\
-	__asm__ volatile ("membar #LoadLoad | #StoreStore\n" ::: "memory")
+	asm volatile ("membar #LoadLoad | #StoreStore\n" ::: "memory")
 #define read_barrier()		\
-	__asm__ volatile ("membar #LoadLoad\n" ::: "memory")
+	asm volatile ("membar #LoadLoad\n" ::: "memory")
 #define write_barrier()		\
-	__asm__ volatile ("membar #StoreStore\n" ::: "memory")
+	asm volatile ("membar #StoreStore\n" ::: "memory")
 
 /** Flush Instruction Memory instruction. */
@@ -71,5 +71,5 @@
 	 */
 	 
-        __asm__ volatile ("flush %o7\n");
+        asm volatile ("flush %o7\n");
 }
 
@@ -77,5 +77,5 @@
 static inline void membar(void)
 {
-	__asm__ volatile ("membar #Sync\n");
+	asm volatile ("membar #Sync\n");
 }
 
