[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [MiNT] Improvements for inline assembler



Here is my patch for cleaning up inline assembly in the whole MiNTLib.
Only the syntax has been improved, no functionality has been changed.

Alan, could you commit, please ?

--
Vincent Rivière

diff -aurN -x CVS mintlib.orig/ChangeLog mintlib/ChangeLog
--- mintlib.orig/ChangeLog	2009-05-07 11:05:40.000000000 +0200
+++ mintlib/ChangeLog	2009-05-14 23:37:31.750000000 +0200
@@ -1,3 +1,16 @@
+2009-05-14 Thursday 23:37  Vincent Riviere <vincent.riviere@freesbee.fr>
+
+	* include/macros.h, include/bits/byteswap.h, include/bits/math-68881.h,
+	include/mint/falcon.h, include/mint/linea.h, include/mint/mintbind.h,
+	include/mint/osbind.h, mintlib/atomicity-68020.h, mintlib/libc-symbols.h
+	mintlib/linea.c, mintlib/machine-gmon.h, string/strrchr.c,
+	syscall/traps.c
+
+	Cleanup inline assembly syntax.
+	Removed semicolumns, using "\n\t" instead.
+	Split strings spanning on multiple lines into multiple strings.
+	Replaced "asm" and "__asm" keywords by "__asm__".
+	
 2009-05-01 Friday 09:18  Vincent Riviere <vincent.riviere@freesbee.fr>
 
 	* Makefile, configvars, libinstall, libv4e/.cvsignore, libv4e/BINFILES,
diff -aurN -x CVS mintlib.orig/include/bits/byteswap.h mintlib/include/bits/byteswap.h
--- mintlib.orig/include/bits/byteswap.h	2001-04-06 03:41:09.000000000 +0200
+++ mintlib/include/bits/byteswap.h	2009-05-12 23:13:57.875000000 +0200
@@ -39,8 +39,8 @@
      if (__builtin_constant_p (x))				\
        __bswap_32_v = __bswap_constant_32 (x);			\
      else							\
-       __asm__ __volatile__ ("ror%.w %#8, %0;"			\
-			     "swap %0;"				\
+       __asm__ __volatile__ ("ror%.w %#8, %0\n\t"		\
+			     "swap %0\n\t"			\
 			     "ror%.w %#8, %0"			\
 			     : "=d" (__bswap_32_v)		\
 			     : "0" ((unsigned int) (x)));	\
diff -aurN -x CVS mintlib.orig/include/bits/math-68881.h mintlib/include/bits/math-68881.h
--- mintlib.orig/include/bits/math-68881.h	2005-12-06 20:22:02.000000000 +0100
+++ mintlib/include/bits/math-68881.h	2009-05-14 21:02:33.390625000 +0200
@@ -57,7 +57,7 @@
 ({									\
   double huge_val;							\
 									\
-  __asm ("fmove%.d #0x7ff0000000000000,%0"	/* Infinity */		\
+  __asm__ ("fmove%.d #0x7ff0000000000000,%0"	/* Infinity */		\
 	 : "=f" (huge_val)						\
 	 : /* no inputs */);						\
   huge_val;								\
@@ -69,7 +69,7 @@
 {
   double value;
 
-  __asm ("fsin%.x %1,%0"
+  __asm__ ("fsin%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -80,7 +80,7 @@
 {
   double value;
 
-  __asm ("fcos%.x %1,%0"
+  __asm__ ("fcos%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -91,7 +91,7 @@
 {
   double value;
 
-  __asm ("ftan%.x %1,%0"
+  __asm__ ("ftan%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -102,7 +102,7 @@
 {
   double value;
 
-  __asm ("fasin%.x %1,%0"
+  __asm__ ("fasin%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -113,7 +113,7 @@
 {
   double value;
 
-  __asm ("facos%.x %1,%0"
+  __asm__ ("facos%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -124,7 +124,7 @@
 {
   double value;
 
-  __asm ("fatan%.x %1,%0"
+  __asm__ ("fatan%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -135,10 +135,10 @@
 {
   double pi, pi_over_2;
 
-  __asm ("fmovecr%.x #0,%0"		/* extended precision pi */
+  __asm__ ("fmovecr%.x #0,%0"		/* extended precision pi */
 	 : "=f" (pi)
 	 : /* no inputs */ );
-  __asm ("fscale%.b #-1,%0"		/* no loss of accuracy */
+  __asm__ ("fscale%.b #-1,%0"		/* no loss of accuracy */
 	 : "=f" (pi_over_2)
 	 : "0" (pi));
   if (x > 0)
@@ -178,7 +178,7 @@
 	      double value;
 
 	      errno = EDOM;
-	      __asm ("fmove%.d #0x7fffffffffffffff,%0"	/* quiet NaN */
+	      __asm__ ("fmove%.d #0x7fffffffffffffff,%0"	/* quiet NaN */
 		     : "=f" (value)
 		     : /* no inputs */);
 	      return value;
@@ -192,7 +192,7 @@
 {
   double value;
 
-  __asm ("fsinh%.x %1,%0"
+  __asm__ ("fsinh%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -203,7 +203,7 @@
 {
   double value;
 
-  __asm ("fcosh%.x %1,%0"
+  __asm__ ("fcosh%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -214,7 +214,7 @@
 {
   double value;
 
-  __asm ("ftanh%.x %1,%0"
+  __asm__ ("ftanh%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -225,7 +225,7 @@
 {
   double value;
 
-  __asm ("fatanh%.x %1,%0"
+  __asm__ ("fatanh%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -236,7 +236,7 @@
 {
   double value;
 
-  __asm ("fetox%.x %1,%0"
+  __asm__ ("fetox%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -247,7 +247,7 @@
 {
   double value;
 
-  __asm ("fetoxm1%.x %1,%0"
+  __asm__ ("fetoxm1%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -258,7 +258,7 @@
 {
   double value;
 
-  __asm ("flogn%.x %1,%0"
+  __asm__ ("flogn%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -269,7 +269,7 @@
 {
   double value;
 
-  __asm ("flognp1%.x %1,%0"
+  __asm__ ("flognp1%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -280,7 +280,7 @@
 {
   double value;
 
-  __asm ("flog10%.x %1,%0"
+  __asm__ ("flog10%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -291,7 +291,7 @@
 {
   double value;
 
-  __asm ("fsqrt%.x %1,%0"
+  __asm__ ("fsqrt%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -317,7 +317,7 @@
 	  double value;
 
 	  errno = EDOM;
-	  __asm ("fmove%.d #0x7fffffffffffffff,%0"		/* quiet NaN */
+	  __asm__ ("fmove%.d #0x7fffffffffffffff,%0"		/* quiet NaN */
 		 : "=f" (value)
 		 : /* no inputs */);
 	  return value;
@@ -327,7 +327,7 @@
     {
       double temp;
 
-      __asm ("fintrz%.x %1,%0"
+      __asm__ ("fintrz%.x %1,%0"
 	     : "=f" (temp)			/* integer-valued float */
 	     : "f" (y));
       if (y == temp)
@@ -344,7 +344,7 @@
 	  double value;
 
 	  errno = EDOM;
-	  __asm ("fmove%.d #0x7fffffffffffffff,%0"		/* quiet NaN */
+	  __asm__ ("fmove%.d #0x7fffffffffffffff,%0"		/* quiet NaN */
 		 : "=f" (value)
 		 : /* no inputs */);
 	  return value;
@@ -357,7 +357,7 @@
 {
   double value;
 
-  __asm ("fabs%.x %1,%0"
+  __asm__ ("fabs%.x %1,%0"
 	 : "=f" (value)
 	 : "f" (x));
   return value;
@@ -369,17 +369,17 @@
   int rounding_mode, round_up;
   double value;
 
-  __asm volatile ("fmove%.l %!,%0"
+  __asm__ volatile ("fmove%.l %!,%0"
 		  : "=dm" (rounding_mode)
 		  : /* no inputs */ );
   round_up = rounding_mode | 0x30;
-  __asm volatile ("fmove%.l %0,%!"
+  __asm__ volatile ("fmove%.l %0,%!"
 		  : /* no outputs */
 		  : "dmi" (round_up));
-  __asm volatile ("fint%.x %1,%0"
+  __asm__ volatile ("fint%.x %1,%0"
 		  : "=f" (value)
 		  : "f" (x));
-  __asm volatile ("fmove%.l %0,%!"
+  __asm__ volatile ("fmove%.l %0,%!"
 		  : /* no outputs */
 		  : "dmi" (rounding_mode));
   return value;
@@ -391,18 +391,18 @@
   int rounding_mode, round_down;
   double value;
 
-  __asm volatile ("fmove%.l %!,%0"
+  __asm__ volatile ("fmove%.l %!,%0"
 		  : "=dm" (rounding_mode)
 		  : /* no inputs */ );
   round_down = (rounding_mode & ~0x10)
 		| 0x20;
-  __asm volatile ("fmove%.l %0,%!"
+  __asm__ volatile ("fmove%.l %0,%!"
 		  : /* no outputs */
 		  : "dmi" (round_down));
-  __asm volatile ("fint%.x %1,%0"
+  __asm__ volatile ("fint%.x %1,%0"
 		  : "=f" (value)
 		  : "f" (x));
-  __asm volatile ("fmove%.l %0,%!"
+  __asm__ volatile ("fmove%.l %0,%!"
 		  : /* no outputs */
 		  : "dmi" (rounding_mode));
   return value;
@@ -414,17 +414,17 @@
   int rounding_mode, round_nearest;
   double value;
 
-  __asm volatile ("fmove%.l %!,%0"
+  __asm__ volatile ("fmove%.l %!,%0"
 		  : "=dm" (rounding_mode)
 		  : /* no inputs */ );
   round_nearest = rounding_mode & ~0x30;
-  __asm volatile ("fmove%.l %0,%!"
+  __asm__ volatile ("fmove%.l %0,%!"
 		  : /* no outputs */
 		  : "dmi" (round_nearest));
-  __asm volatile ("fint%.x %1,%0"
+  __asm__ volatile ("fint%.x %1,%0"
 		  : "=f" (value)
 		  : "f" (x));
-  __asm volatile ("fmove%.l %0,%!"
+  __asm__ volatile ("fmove%.l %0,%!"
 		  : /* no outputs */
 		  : "dmi" (rounding_mode));
   return value;
@@ -435,7 +435,7 @@
 {
   double value;
 
-  __asm ("fmod%.x %2,%0"
+  __asm__ ("fmod%.x %2,%0"
 	 : "=f" (value)
 	 : "0" (x),
 	   "f" (y));
@@ -447,7 +447,7 @@
 {
   double value;
 
-  __asm ("frem%.x %2,%0"
+  __asm__ ("frem%.x %2,%0"
 	 : "=f" (value)
 	 : "0" (x),
 	   "f" (y));
@@ -459,7 +459,7 @@
 {
   double value;
 
-  __asm ("fscale%.l %2,%0"
+  __asm__ ("fscale%.l %2,%0"
 	 : "=f" (value)
 	 : "0" (x),
 	   "dmi" (n));
@@ -471,7 +471,7 @@
 {
   double exponent;
 
-  __asm ("fgetexp%.x %1,%0"
+  __asm__ ("fgetexp%.x %1,%0"
 	 : "=f" (exponent)
 	 : "f" (x));
   return exponent;
@@ -482,7 +482,7 @@
 {
   double value;
 
-  __asm ("fscale%.l %2,%0"
+  __asm__ ("fscale%.l %2,%0"
 	 : "=f" (value)
 	 : "0" (x),
 	   "dmi" (n));
@@ -496,16 +496,16 @@
   int int_exponent;
   double mantissa;
 
-  __asm ("fgetexp%.x %1,%0"
+  __asm__ ("fgetexp%.x %1,%0"
 	 : "=f" (float_exponent)	/* integer-valued float */
 	 : "f" (x));
   int_exponent = (int) float_exponent;
-  __asm ("fgetman%.x %1,%0"
+  __asm__ ("fgetman%.x %1,%0"
 	 : "=f" (mantissa)		/* 1.0 <= mantissa < 2.0 */
 	 : "f" (x));
   if (mantissa != 0)
     {
-      __asm ("fscale%.b #-1,%0"
+      __asm__ ("fscale%.b #-1,%0"
 	     : "=f" (mantissa)		/* mantissa /= 2.0 */
 	     : "0" (mantissa));
       int_exponent += 1;
@@ -519,7 +519,7 @@
 {
   double temp;
 
-  __asm ("fintrz%.x %1,%0"
+  __asm__ ("fintrz%.x %1,%0"
 	 : "=f" (temp)			/* integer-valued float */
 	 : "f" (x));
   *ip = temp;
diff -aurN -x CVS mintlib.orig/include/macros.h mintlib/include/macros.h
--- mintlib.orig/include/macros.h	2000-10-12 12:56:30.000000000 +0200
+++ mintlib/include/macros.h	2009-05-14 20:54:08.890625000 +0200
@@ -67,62 +67,62 @@
 #ifdef __GNUC__
 #define ROLL(offset, x)	\
 ({ unsigned long __arg = (x);	\
-    asm ("roll %2,%1": "=r" (__arg) : "0" (__arg), "d" (offset)); \
+    __asm__ ("roll %2,%1": "=r" (__arg) : "0" (__arg), "d" (offset)); \
     __arg; })
 
 #define RORL(offset, x)	\
 ({ unsigned long __arg = (x);	\
-    asm ("rorl %2,%1": "=r" (__arg) : "0" (__arg), "d" (offset)); \
+    __asm__ ("rorl %2,%1": "=r" (__arg) : "0" (__arg), "d" (offset)); \
     __arg; })
 
 #define ROLW(offset, x)	\
 ({ unsigned short __arg = (x);	\
-    asm ("roll %2,%1": "=r" (__arg) : "0" (__arg), "d" (offset)); \
+    __asm__ ("roll %2,%1": "=r" (__arg) : "0" (__arg), "d" (offset)); \
     __arg; })
 
 #define RORW(offset, x)	\
 ({ unsigned short __arg = (x);	\
-    asm ("rorl %2,%1": "=r" (__arg) : "0" (__arg), "d" (offset)); \
+    __asm__ ("rorl %2,%1": "=r" (__arg) : "0" (__arg), "d" (offset)); \
     __arg; })
 
 #define ROLB(offset, x)	\
 ({ unsigned char __arg = (x);	\
-    asm ("roll %2,%1": "=r" (__arg) : "0" (__arg), "d" (offset)); \
+    __asm__ ("roll %2,%1": "=r" (__arg) : "0" (__arg), "d" (offset)); \
     __arg; })
 
 #define RORB(offset, x)	\
 ({ unsigned char __arg = (x);	\
-    asm ("rorl %2,%1": "=r" (__arg) : "0" (__arg), "d" (offset)); \
+    __asm__ ("rorl %2,%1": "=r" (__arg) : "0" (__arg), "d" (offset)); \
     __arg; })
 
 #define ROLL1(x)	\
 ({ unsigned long __arg = (x);	\
-    asm ("roll #1,%1": "=r" (__arg) : "0" (__arg)); \
+    __asm__ ("roll #1,%1": "=r" (__arg) : "0" (__arg)); \
     __arg; })
 
 #define RORL1(x)	\
 ({ unsigned long __arg = (x);	\
-    asm ("roll #1,%1": "=r" (__arg) : "0" (__arg)); \
+    __asm__ ("roll #1,%1": "=r" (__arg) : "0" (__arg)); \
     __arg; })
 
 #define ROLW1(x)	\
 ({ unsigned short __arg = (x);	\
-    asm ("roll #1,%1": "=r" (__arg) : "0" (__arg)); \
+    __asm__ ("roll #1,%1": "=r" (__arg) : "0" (__arg)); \
     __arg; })
 
 #define RORW1(x)	\
 ({ unsigned short __arg = (x);	\
-    asm ("roll #1,%1": "=r" (__arg) : "0" (__arg)); \
+    __asm__ ("roll #1,%1": "=r" (__arg) : "0" (__arg)); \
     __arg; })
 
 #define ROLB1(x)	\
 ({ unsigned char __arg = (x);	\
-    asm ("roll #1,%1": "=r" (__arg) : "0" (__arg)); \
+    __asm__ ("roll #1,%1": "=r" (__arg) : "0" (__arg)); \
     __arg; })
 
 #define RORB1(x)	\
 ({ unsigned char __arg = (x);	\
-    asm ("roll #1,%1": "=r" (__arg) : "0" (__arg)); \
+    __asm__ ("roll #1,%1": "=r" (__arg) : "0" (__arg)); \
     __arg; })
 
 #endif
diff -aurN -x CVS mintlib.orig/include/mint/falcon.h mintlib/include/mint/falcon.h
--- mintlib.orig/include/mint/falcon.h	2008-01-22 10:36:54.000000000 +0100
+++ mintlib/include/mint/falcon.h	2009-05-12 23:19:41.515625000 +0200
@@ -23,15 +23,15 @@
 	short _e = (short)(e);						\
 									\
 	__asm__ volatile						\
-	("\
-		movw	%6,sp@-; \
-		movw	%5,sp@-; \
-		movw	%4,sp@-; \
-		movw	%3,sp@-; \
-		movw	%2,sp@-; \
-		movw	%1,sp@-; \
-		trap	#14; \
-		lea	sp@(12),sp"					\
+	(								\
+		"movw	%6,sp@-\n\t"					\
+		"movw	%5,sp@-\n\t"					\
+		"movw	%4,sp@-\n\t"					\
+		"movw	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(12),sp"					\
 	: "=r"(retvalue)						\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d), "r"(_e)		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2", "memory");		\
@@ -50,14 +50,14 @@
 	long _d = (long)(d);						\
 									\
 	__asm__ volatile						\
-	("\
-		movl	%5,sp@-; \
-		movl	%4,sp@-; \
-		movl	%3,sp@-; \
-		movl	%2,sp@-; \
-		movw	%1,sp@-; \
-		trap	#14; \
-		lea	sp@(18),sp"					\
+	(								\
+		"movl	%5,sp@-\n\t"					\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(18),sp"					\
 	: "=r"(retvalue)						\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d)			\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2", "memory");		\
@@ -78,16 +78,16 @@
 	long _f = (long)(f);						\
 									\
 	__asm__ volatile						\
-	("\
-		movl	%7,sp@-; \
-		movl	%6,sp@-; \
-		movl	%5,sp@-; \
-		movl	%4,sp@-; \
-		movl	%3,sp@-; \
-		movl	%2,sp@-; \
-		movw	%1,sp@-; \
-		trap	#14; \
-		lea	sp@(26),sp"					\
+	(								\
+		"movl	%7,sp@-\n\t"					\
+		"movl	%6,sp@-\n\t"					\
+		"movl	%5,sp@-\n\t"					\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(26),sp"					\
 	: "=r"(retvalue)						\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d), "r"(_e), "r"(_f)	\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2", "memory");		\
@@ -104,12 +104,12 @@
 	long _b = (long)(b);						\
 									\
 	__asm__ volatile						\
-	("\
-		movl	%3,sp@-; \
-		movl	%2,sp@-; \
-		movw	%1,sp@-; \
-		trap	#14; \
-		lea	sp@(10),sp"					\
+	(								\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(10),sp"					\
 	: "=r"(retvalue)						\
 	: "g"(n), "r"(_a), "r"(_b)					\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2", "memory");		\
@@ -127,13 +127,13 @@
 	long _c = (long)(c);						\
 									\
 	__asm__ volatile						\
-	("\
-		movl	%4,sp@-; \
-		movw	%3,sp@-; \
-		movl	%2,sp@-; \
-		movw	%1,sp@-; \
-		trap	#14; \
-		lea	sp@(12),sp"					\
+	(								\
+		"movl	%4,sp@-\n\t"					\
+		"movw	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(12),sp"					\
 	: "=r"(retvalue)						\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c)				\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2", "memory");		\
diff -aurN -x CVS mintlib.orig/include/mint/linea.h mintlib/include/mint/linea.h
--- mintlib.orig/include/mint/linea.h	2005-12-06 20:27:55.000000000 +0100
+++ mintlib/include/mint/linea.h	2009-05-12 23:31:32.734375000 +0200
@@ -766,8 +766,8 @@
 	register short (**__xfuncs) (void) __asm__ ("a2");		\
 									\
 	__asm__ volatile						\
-	("\
-		.word   0xA000"						\
+	(								\
+		".word	0xA000"						\
 	: "=g"(__xaline), "=g"(__xfonts), "=g"(__xfuncs)  /* outputs */	\
 	: 						  /* inputs  */	\
 	: __CLOBBER_RETURN("a0") __CLOBBER_RETURN("a1") __CLOBBER_RETURN("a2") "d0", "d1", "d2"       /* clobbered regs */	\
@@ -779,10 +779,9 @@
 
 #define linea1() 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
-		.word   0xA001" \
+	(								\
+		".word	0xA001"						\
 	: 						  /* outputs */	\
 	: 						  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	\
@@ -793,8 +792,8 @@
 ({									\
 	register short retvalue __asm__ ("d0");				\
 	__asm__ volatile						\
-	("\
-		.word   0xA002"   \
+	(								\
+		".word	0xA002"						\
 	: "=g"(retvalue)				  /* outputs */	\
 	: 						  /* inputs  */	\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	\
@@ -804,10 +803,9 @@
 
 #define linea3() 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
-		.word   0xA003" \
+	(								\
+		".word	0xA003"						\
 	: 						  /* outputs */	\
 	: 						  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	\
@@ -816,10 +814,9 @@
 
 #define linea4() 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
-		.word   0xA004" \
+	(								\
+		".word	0xA004"						\
 	: 						  /* outputs */	\
 	: 						  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	\
@@ -828,10 +825,9 @@
 
 #define linea5() 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
-		.word   0xA005" \
+	(								\
+		".word	0xA005"						\
 	: 						  /* outputs */	\
 	: 						  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	\
@@ -840,10 +836,9 @@
 
 #define linea6() 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
-		.word   0xA006" \
+	(								\
+		".word	0xA006"						\
 	: 						  /* outputs */	\
 	: 						  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	\
@@ -852,13 +847,12 @@
 
 #define linea7(P) 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
-		movml	d2/a2/a6, sp@-; \
- 		movl	%0,a6;  \
-		.word   0xA007; \
-		movml	sp@+, d2/a2/a6" \
+	(								\
+		"movml	d2/a2/a6,sp@-\n\t"				\
+ 		"movl	%0,a6\n\t"					\
+		".word	0xA007\n\t"					\
+		"movml	sp@+,d2/a2/a6"					\
 	: 						  /* outputs */	\
 	: "r"(P)					  /* inputs  */	\
 	: "d0", "d1", "a0", "a1"	  	/* clobbered regs */	\
@@ -867,10 +861,9 @@
 
 #define linea8() 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
-		.word   0xA008" \
+	(								\
+		".word	0xA008"						\
 	: 						  /* outputs */	\
 	: 						  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	\
@@ -879,10 +872,9 @@
 
 #define linea9() 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
-		.word   0xA009" \
+	(								\
+		".word	0xA009"						\
 	: 						  /* outputs */	\
 	: 						  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	\
@@ -891,10 +883,9 @@
 
 #define lineaa() 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
-		.word   0xA00A" \
+	(								\
+		".word	0xA00A"						\
 	: 						  /* outputs */	\
 	: 						  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	\
@@ -903,10 +894,9 @@
 
 #define lineab() 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
-		.word   0xA00B" \
+	(								\
+		".word	0xA00B"						\
 	: 						  /* outputs */	\
 	: 						  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	\
@@ -915,13 +905,12 @@
 
 #define lineac(P) 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
- 		movl	%0,a2;	\
-		movl	a6,sp@-;\
-		.word   0xA00C; \
-		movl	sp@+,a6"\
+	(								\
+ 		"movl	%0,a2\n\t"					\
+		"movl	a6,sp@-\n\t"					\
+		".word	0xA00C\n\t"					\
+		"movl	sp@+,a6"					\
 	: 						  /* outputs */	\
 	: "g"(P)					  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"	   /* clobbered regs */	\
@@ -931,16 +920,15 @@
 #define linead(x, y, sd, ss)	__linead((short)x, (short)y, (void *)sd, (void *)ss)
 #define __linead(x, y,  sd, ss)						\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
- 		movw	%0,d0;  \
- 		movw	%1,d1;  \
- 		movl	%2,a0;  \
- 		movl	%3,a2;  \
-		movl	a6,sp@-;\
-		.word   0xA00D; \
-		movl	sp@+,a6"\
+	(								\
+ 		"movw	%0,d0\n\t"					\
+ 		"movw	%1,d1\n\t"					\
+ 		"movl	%2,a0\n\t"					\
+ 		"movl	%3,a2\n\t"					\
+		"movl	a6,sp@-\n\t"					\
+		".word	0xA00D\n\t"					\
+		"movl	sp@+,a6"					\
 	: 						  /* outputs */	\
 	: "g"(x), "g"(y), "g"(sd), "g"(ss)		  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"	   /* clobbered regs */	\
@@ -949,10 +937,9 @@
 
 #define lineae() 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
-		.word   0xA00E" \
+	(								\
+		".word	0xA00E"						\
 	: 						  /* outputs */	\
 	: 						  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	\
@@ -961,10 +948,9 @@
 
 #define lineaf() 							\
 ({									\
-	    								\
 	__asm__ volatile						\
-	("\
-		.word   0xA00F" \
+	(								\
+		".word	0xA00F"						\
 	: 						  /* outputs */	\
 	: 						  /* inputs  */	\
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	\
diff -aurN -x CVS mintlib.orig/include/mint/mintbind.h mintlib/include/mint/mintbind.h
--- mintlib.orig/include/mint/mintbind.h	2009-02-19 02:27:05.000000000 +0100
+++ mintlib/include/mint/mintbind.h	2009-05-12 23:47:18.984375000 +0200
@@ -23,13 +23,13 @@
 	short  _c = (short) (c);					\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %4,sp@-; \
-		movl    %3,sp@-; \
-		movl    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		lea	sp@(10),sp " \
+	(								\
+		"movw	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(10),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -47,13 +47,13 @@
 	short  _c = (short) (c);					\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %4,sp@-; \
-		movl    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		lea	sp@(10),sp " \
+	(								\
+		"movw	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(10),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -71,13 +71,13 @@
 	short  _c = (short)(c);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %4,sp@-; \
-		movw    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		addqw    #8,sp "					\
+	(								\
+		"movw	%4,sp@-\n\t"					\
+		"movw	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"addqw	#8,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -95,13 +95,13 @@
 	long  _c = (long)(c);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %4,sp@-; \
-		movw    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		lea     sp@(10),sp "					\
+	(								\
+		"movl	%4,sp@-\n\t"					\
+		"movw	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(10),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -118,12 +118,12 @@
 	long  _b = (long) (b);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		addqw    #8,sp "					\
+	(								\
+		"movl	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"addqw	#8,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b)		/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -142,14 +142,14 @@
 	short _d = (short) (d);						\
 	    								\
 	__asm__ volatile						\
-	("								\
-		movw    %5,sp@-;					\
-		movl    %4,sp@-;					\
-		movl    %3,sp@-;					\
-		movl    %2,sp@-;					\
-		movw    %1,sp@-;					\
-		trap    #1;						\
-		lea	sp@(16),sp "					\
+	(								\
+		"movw	%5,sp@-\n\t"					\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(16),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */	\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -168,12 +168,12 @@
 	    								\
 	__asm__ volatile						\
 	(								\
-		"movl    %4,sp@-;"					\
-		"movl    %3,sp@-;"					\
-		"movl    %2,sp@-;"					\
-		"movw    %1,sp@-;"					\
-		"trap    #1;"						\
-		"lea     sp@(14),sp"					\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(14),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c)	/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -194,15 +194,15 @@
 	long  _e = (long) (e);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %6,sp@-; \
-		movl    %5,sp@-; \
-		movl    %4,sp@-; \
-		movl    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		lea     sp@(20),sp "					\
+	(								\
+		"movl	%6,sp@-\n\t"					\
+		"movl	%5,sp@-\n\t"					\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(20),sp "					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d), "r"(_e) /* inputs  */ \
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -222,13 +222,13 @@
 	    								\
 	__asm__ volatile						\
 	(								\
-		"movl    %5,sp@-;"					\
-		"movl    %4,sp@-;"					\
-		"movl    %3,sp@-;"					\
-		"movl    %2,sp@-;"					\
-		"movw    %1,sp@-;"					\
-		"trap    #1;"						\
-		"lea     sp@(18),sp"					\
+		"movl	%5,sp@-\n\t"					\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(18),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c),				\
 	  "r"(_d)				/* inputs  */		\
@@ -252,15 +252,15 @@
 	    								\
 	__asm__ volatile						\
 	(								\
-		"movl    %7,sp@-;"					\
-		"movl    %6,sp@-;"					\
-		"movl    %5,sp@-;"					\
-		"movl    %4,sp@-;"					\
-		"movl    %3,sp@-;"					\
-		"movw    %2,sp@-;"					\
-		"movw    %1,sp@-;"					\
-		"trap    #1;"						\
-		"lea     sp@(24),sp"					\
+		"movl	%7,sp@-\n\t"					\
+		"movl	%6,sp@-\n\t"					\
+		"movl	%5,sp@-\n\t"					\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(24),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c),				\
 	  "r"(_d), "r"(_e), "r"(_f)		/* inputs  */		\
@@ -283,14 +283,14 @@
 	    								\
 	__asm__ volatile						\
 	(								\
-		"movl    %6,sp@-;"					\
-		"movl    %5,sp@-;"					\
-		"movl    %4,sp@-;"					\
-		"movl    %3,sp@-;"					\
-		"movl    %2,sp@-;"					\
-		"movw    %1,sp@-;"					\
-		"trap    #1;"						\
-		"lea     sp@(22),sp"					\
+		"movl	%6,sp@-\n\t"					\
+		"movl	%5,sp@-\n\t"					\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(22),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c),				\
 	  "r"(_d), "r"(_e)			/* inputs  */		\
@@ -314,15 +314,15 @@
 	    								\
 	__asm__ volatile						\
 	(								\
-		"movl    %7,sp@-;"					\
-		"movl    %6,sp@-;"					\
-		"movl    %5,sp@-;"					\
-		"movl    %4,sp@-;"					\
-		"movl    %3,sp@-;"					\
-		"movl    %2,sp@-;"					\
-		"movw    %1,sp@-;"					\
-		"trap    #1;"						\
-		"lea     sp@(26),sp"					\
+		"movl	%7,sp@-\n\t"					\
+		"movl	%6,sp@-\n\t"					\
+		"movl	%5,sp@-\n\t"					\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(26),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c),				\
 	  "r"(_d), "r"(_e), "r"(_f)		/* inputs  */		\
diff -aurN -x CVS mintlib.orig/include/mint/osbind.h mintlib/include/mint/osbind.h
--- mintlib.orig/include/mint/osbind.h	2008-09-29 17:35:26.000000000 +0200
+++ mintlib/include/mint/osbind.h	2009-05-14 22:57:06.671875000 +0200
@@ -137,10 +137,10 @@
 	register long retvalue __asm__("d0");				\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %1,sp@-; \
-		trap    #1;	\
-		addqw   #2,sp "						\
+	(								\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"addqw	#2,sp\n\t"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n)				/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -156,11 +156,11 @@
 	short _a = (short)(a);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw	%2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		addqw   #4,sp "						\
+	(								\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"addqw	#4,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a)			/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -176,11 +176,11 @@
 	long  _a = (long) (a);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl	%2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		addqw   #6,sp "						\
+	(								\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"addqw	#6,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a)			/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -197,12 +197,12 @@
 	short _b = (short)(b);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %3,sp@-; \
-		movl    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		addqw   #8,sp "						\
+	(								\
+		"movw	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"addqw	#8,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b)		/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -220,13 +220,13 @@
 	long  _c = (long) (c);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %4,sp@-; \
-		movl    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		lea	sp@(12),sp "					\
+	(								\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(12),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -244,13 +244,13 @@
 	short _c = (short)(c);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %4,sp@-; \
-		movw    %3,sp@-; \
-		movl    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		lea	sp@(10),sp "					\
+	(								\
+		"movw	%4,sp@-\n\t"					\
+		"movw	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(10),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -269,14 +269,14 @@
 	long  _d = (short) (d);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %5,sp@-; \
-		movw    %4,sp@-; \
-		movw    %3,sp@-; \
-		movl    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		lea	sp@(12),sp "					\
+	(								\
+		"movw	%5,sp@-\n\t"					\
+		"movw	%4,sp@-\n\t"					\
+		"movw	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(12),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */	\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2", "memory"			\
@@ -292,12 +292,12 @@
 	short _b = (short)(b);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		addqw   #6,sp "						\
+	(								\
+		"movw	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"addqw	#6,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b)		/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -314,12 +314,12 @@
 	long  _b = (long) (b);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %3,sp@-; \
-		movl    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		lea	sp@(10),sp "					\
+	(								\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(10),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b)		/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -338,14 +338,14 @@
 	long  _d = (long) (d);			\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %5,sp@-; \
-		movl    %4,sp@-; \
-		movl    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		lea	sp@(16),sp "					\
+	(								\
+		"movl	%5,sp@-\n\t"					\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(16),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */	\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2", "memory"			\
@@ -363,14 +363,14 @@
 	long  _d = (long) (d);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %5,sp@-; \
-		movl    %4,sp@-; \
-		movw    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #1;	\
-		lea	sp@(14),sp "					\
+	(								\
+		"movl	%5,sp@-\n\t"					\
+		"movl	%4,sp@-\n\t"					\
+		"movw	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#1\n\t"						\
+		"lea	sp@(14),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */	\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2", "memory"			\
@@ -385,11 +385,11 @@
 	long  _a = (long) (a);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl	%2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #13;	\
-		addqw   #6,sp "						\
+	(								\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#13\n\t"					\
+		"addqw	#6,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a)			/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -404,10 +404,10 @@
 	register long retvalue __asm__("d0");				\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %1,sp@-; \
-		trap    #13;	\
-		addqw   #2,sp "						\
+	(								\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#13\n\t"					\
+		"addqw	#2,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n)				/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -423,11 +423,11 @@
 	short _a = (short)(a);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw	%2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #13;	\
-		addqw   #4,sp "						\
+	(								\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#13\n\t"					\
+		"addqw	#4,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a)			/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -444,12 +444,12 @@
 	short _b = (short)(b);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %3,sp@-; \
-		movw	%2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #13;	\
-		addqw   #6,sp "						\
+	(								\
+		"movw	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#13\n\t"					\
+		"addqw	#6,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b)		/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -469,15 +469,15 @@
 	short _e = (short)(e);			\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %6,sp@-; \
-		movw    %5,sp@-; \
-		movw    %4,sp@-; \
-		movl    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #13;	\
-		lea	sp@(14),sp "					\
+	(								\
+		"movw	%6,sp@-\n\t"					\
+		"movw	%5,sp@-\n\t"					\
+		"movw	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#13\n\t"					\
+		"lea	sp@(14),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n),							\
 	  "r"(_a), "r"(_b), "r"(_c), "r"(_d), "r"(_e) /* inputs  */	\
@@ -494,12 +494,12 @@
 	long  _b = (long) (b);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #13;	\
-		addqw   #8,sp "						\
+	(								\
+		"movl	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#13\n\t"					\
+		"addqw	#8,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b)		/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -516,12 +516,12 @@
 	long  _b = (long) (b);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		addqw   #8,sp "						\
+	(								\
+		"movl	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"addqw	#8,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b)              /* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -539,13 +539,13 @@
 	long  _c = (long) (c);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %4,sp@-; \
-		movl    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		lea	sp@(12),sp "					\
+	(								\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(12),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -561,11 +561,11 @@
 	short _a = (short)(a);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		addqw   #4,sp "						\
+	(								\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"addqw	#4,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a)			/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -580,10 +580,10 @@
 	register long retvalue __asm__("d0");				\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %1,sp@-; \
-		trap    #14;	\
-		addqw   #2,sp "						\
+	(								\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"addqw	#2,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n)				/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -601,13 +601,13 @@
 	short _c = (short)(c);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %4,sp@-; \
-		movl    %3,sp@-; \
-		movl    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		lea	sp@(12),sp "					\
+	(								\
+		"movw	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(12),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c)       /* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -623,11 +623,11 @@
 	long  _a = (long) (a);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		addqw   #6,sp "						\
+	(								\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"addqw	#6,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a)			/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -644,12 +644,12 @@
 	short _b = (short)(b);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		addqw   #6,sp "						\
+	(								\
+		"movw	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"addqw	#6,sp"						\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b)		/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -671,17 +671,17 @@
 	short _g = (short)(g);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %8,sp@-; \
-		movw    %7,sp@-; \
-		movw    %6,sp@-; \
-		movw    %5,sp@-; \
-		movw    %4,sp@-; \
-		movl    %3,sp@-; \
-		movl    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		lea	sp@(20),sp "					\
+	(								\
+		"movw	%8,sp@-\n\t"					\
+		"movw	%7,sp@-\n\t"					\
+		"movw	%6,sp@-\n\t"					\
+		"movw	%5,sp@-\n\t"					\
+		"movw	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(20),sp "					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b),					\
 	  "r"(_c), "r"(_d), "r"(_e), "r"(_f), "r"(_g) /* inputs  */	\
@@ -704,18 +704,18 @@
 	short _h = (short)(h);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %9,sp@-; \
-		movl    %8,sp@-; \
-		movw    %7,sp@-; \
-		movw    %6,sp@-; \
-		movw    %5,sp@-; \
-		movw    %4,sp@-; \
-		movl    %3,sp@-; \
-		movl    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		lea	sp@(24),sp "					\
+	(								\
+		"movw	%9,sp@-\n\t"					\
+		"movl	%8,sp@-\n\t"					\
+		"movw	%7,sp@-\n\t"					\
+		"movw	%6,sp@-\n\t"					\
+		"movw	%5,sp@-\n\t"					\
+		"movw	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(24),sp "					\
 	: "=r"(retvalue)			   /* outputs */	\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c),				\
 	  "r"(_d), "r"(_e), "r"(_f), "r"(_g), "r"(_h) /* inputs  */	\
@@ -739,26 +739,26 @@
 	short _i = (short)(i);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %9,sp@-; \
-		movl    %8,sp@-; \
-		movw    %7,sp@-; \
-		movw    %6,sp@-; \
-		movw    %5,sp@-; \
-		movw    %4,sp@-; \
-		movw    %3,sp@-; \
-		movl    %2,sp@-; \
-		movl    %1,sp@-; \
-                movw    %0,sp@- "					\
+	(								\
+		"movw	%9,sp@-\n\t"					\
+		"movl	%8,sp@-\n\t"					\
+		"movw	%7,sp@-\n\t"					\
+		"movw	%6,sp@-\n\t"					\
+		"movw	%5,sp@-\n\t"					\
+		"movw	%4,sp@-\n\t"					\
+		"movw	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movl	%1,sp@-\n\t"					\
+                "movw	%0,sp@-"					\
 	:					      /* outputs */	\
 	: "g"(n), "g"(_a), "g"(_b), "g"(_c), "g"(_d),			\
 	  "g"(_e), "g"(_f), "g"(_g), "g"(_h), "g"(_i) /* inputs  */	\
 	);								\
 	    								\
 	__asm__ volatile						\
-	("\
-		trap    #14;	\
-		lea	sp@(26),sp "					\
+	(								\
+		"trap	#14\n\t"					\
+		"lea	sp@(26),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: 					/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2", "memory"			\
@@ -779,16 +779,16 @@
 	short _f = (short)(f);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %7,sp@-; \
-		movw    %6,sp@-; \
-		movw    %5,sp@-; \
-		movw    %4,sp@-; \
-		movw    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		lea	sp@(14),sp "					\
+	(								\
+		"movw	%7,sp@-\n\t"					\
+		"movw	%6,sp@-\n\t"					\
+		"movw	%5,sp@-\n\t"					\
+		"movw	%4,sp@-\n\t"					\
+		"movw	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(14),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "g"(_a),						\
 	  "g"(_b), "g"(_c), "g"(_d), "g"(_e), "g"(_f)	/* inputs  */	\
@@ -806,13 +806,13 @@
 	long  _c = (long) (c);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %4,sp@-; \
-		movl    %3,sp@-; \
-		movl    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		lea	sp@(14),sp "					\
+	(								\
+		"movl	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(14),sp "					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -831,14 +831,14 @@
 	short _d = (short)(d);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %5,sp@-; \
-		movw    %4,sp@-; \
-		movl    %3,sp@-; \
-		movl    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		lea	sp@(14),sp "					\
+	(								\
+		"movw	%5,sp@-\n\t"					\
+		"movw	%4,sp@-\n\t"					\
+		"movl	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(14),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n),							\
 	  "r"(_a), "r"(_b), "r"(_c), "r"(_d)    /* inputs  */		\
@@ -857,14 +857,14 @@
 	long  _d = (long) (d);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movl    %5,sp@-; \
-		movw    %4,sp@-; \
-		movw    %3,sp@-; \
-		movw    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		lea	sp@(12),sp "					\
+	(								\
+		"movl	%5,sp@-\n\t"					\
+		"movw	%4,sp@-\n\t"					\
+		"movw	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(12),sp "					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n),							\
 	  "r"(_a), "r"(_b), "r"(_c), "r"(_d)        /* inputs  */	\
@@ -882,13 +882,13 @@
 	long  _c = (long)(c);						\
 	    								\
 	__asm__ volatile						\
-	("								\
-		movl	%4,sp@-;					\
-		movw    %3,sp@-;					\
-		movw    %2,sp@-;					\
-		movw    %1,sp@-;					\
-		trap    #14;						\
-		lea	sp@(10),sp "					\
+	(								\
+		"movl	%4,sp@-\n\t"					\
+		"movw	%3,sp@-\n\t"					\
+		"movw	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(10),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n), "r"(_a), "r"(_b), "r"(_c)	/* inputs  */		\
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */	\
@@ -907,14 +907,14 @@
 	short _d = (short)(d);						\
 	    								\
 	__asm__ volatile						\
-	("\
-		movw    %5,sp@-; \
-		movl    %4,sp@-; \
-		movw    %3,sp@-; \
-		movl    %2,sp@-; \
-		movw    %1,sp@-; \
-		trap    #14;	\
-		lea	sp@(14),sp "					\
+	(								\
+		"movw	%5,sp@-\n\t"					\
+		"movl	%4,sp@-\n\t"					\
+		"movw	%3,sp@-\n\t"					\
+		"movl	%2,sp@-\n\t"					\
+		"movw	%1,sp@-\n\t"					\
+		"trap	#14\n\t"					\
+		"lea	sp@(14),sp"					\
 	: "=r"(retvalue)			/* outputs */		\
 	: "g"(n),							\
 	  "r"(_a), "r"(_b), "r"(_c), "r"(_d)    /* inputs  */		\
diff -aurN -x CVS mintlib.orig/mintlib/atomicity-68020.h mintlib/mintlib/atomicity-68020.h
--- mintlib.orig/mintlib/atomicity-68020.h	2000-10-12 13:30:47.000000000 +0200
+++ mintlib/mintlib/atomicity-68020.h	2009-05-13 00:20:33.000000000 +0200
@@ -33,10 +33,10 @@
 {
   register int result = *mem;
   register int temp;
-  __asm__ __volatile__ ("1: move%.l %0,%1;"
-			"   add%.l %2,%1;"
-			"   cas%.l %0,%1,%3;"
-			"   jbne 1b"
+  __asm__ __volatile__ ("1: move%.l %0,%1\n\t"
+			"add%.l	%2,%1\n\t"
+			"cas%.l	%0,%1,%3\n\t"
+			"jbne	1b"
 			: "=d" (result), "=&d" (temp)
 			: "d" (val), "m" (*mem), "0" (result) : "memory");
   return result;
@@ -47,7 +47,7 @@
 atomic_add (volatile uint32_t *mem, int val)
 {
   /* XXX Use cas here as well?  */
-  __asm__ __volatile__ ("add%.l %0,%1"
+  __asm__ __volatile__ ("add%.l	%0,%1"
 			: : "ir" (val), "m" (*mem) : "memory");
 }
 
@@ -58,7 +58,8 @@
   char ret;
   long int readval;
 
-  __asm__ __volatile__ ("cas%.l %2,%3,%1; seq %0"
+  __asm__ __volatile__ ("cas%.l	%2,%3,%1\n\t"
+			"seq	%0"
                         : "=dm" (ret), "=m" (*p), "=d" (readval)
                         : "d" (newval), "m" (*p), "2" (oldval));
   return ret;
diff -aurN -x CVS mintlib.orig/mintlib/libc-symbols.h mintlib/mintlib/libc-symbols.h
--- mintlib.orig/mintlib/libc-symbols.h	2008-10-20 22:07:46.000000000 +0200
+++ mintlib/mintlib/libc-symbols.h	2009-05-14 20:55:20.171875000 +0200
@@ -35,23 +35,23 @@
 
 /* Define ALIAS as a strong alias for ORIGINAL.  */
 #  define strong_alias(original, alias) \
-  asm (".globl _" #alias "\n" \
-         ".set _" #alias ",_" #original);
+  __asm__ (".globl _" #alias "\n\t" \
+       ".set _" #alias ",_" #original);
 
 /* Define ALIAS as a weak alias for ORIGINAL.  */
 #  ifdef HAVE_WEAK_SYMBOLS
 #   define weak_alias(original, alias) \
-  asm (".weak _" #alias "\n" \
+  __asm__ (".weak _" #alias "\n\t" \
        "_" #alias " = " "_" #original);
-#   define weak_extern(symbol) asm (".weak _" #symbol);
+#   define weak_extern(symbol) __asm__ (".weak _" #symbol);
 #  endif  /* !__HAVE_WEAK_SYMBOLS */
 
 /* When a reference to SYMBOL is encountered, the linker will emit a
    warning message MSG.  */
 # ifdef __HAVE_GNU_LD
-#  define link_warning(symbol, msg)   \
-  asm(".stabs \"" msg "\",30,0,0,0\n"  \
-      ".stabs \"" "_" #symbol  "\",1,0,0,0\n");
+#  define link_warning(symbol, msg) \
+  __asm__(".stabs \"" msg "\",30,0,0,0\n\t" \
+      ".stabs \"_" #symbol "\",1,0,0,0");
 # endif  /* __HAVE_GNU_LD */
 
 # endif  /* !__GNUC__ */
diff -aurN -x CVS mintlib.orig/mintlib/linea.c mintlib/mintlib/linea.c
--- mintlib.orig/mintlib/linea.c	2009-01-28 16:13:27.000000000 +0100
+++ mintlib/mintlib/linea.c	2009-05-14 20:34:29.843750000 +0200
@@ -8,29 +8,28 @@
 
 void linea0()                                                   
 {
-        register __LINEA *__xaline __asm__ ("a0");                      \
-        register __FONT **__xfonts __asm__ ("a1");                      \
-        register short (**__xfuncs) (void) __asm__ ("a2");              \
-                                                                        
-        __asm__ volatile                                                
-        (" \
-        .word   0xA000"                                         \
-        : "=g"(__xaline), "=g"(__xfonts), "=g"(__xfuncs)  /* outputs */ \
-        :                                                 /* inputs  */ 
-        : __CLOBBER_RETURN("a0") __CLOBBER_RETURN("a1") __CLOBBER_RETURN("a2") "d0", "d1", "d2"       /* clobbered regs */ 
-        );                                                              
-        __aline = __xaline;                                             \
-        __fonts = __xfonts;                                             \
-        __funcs = __xfuncs;                                             \
-
+        register __LINEA *__xaline __asm__ ("a0");
+        register __FONT **__xfonts __asm__ ("a1");
+        register short (**__xfuncs) (void) __asm__ ("a2");
+
+        __asm__ volatile
+        (
+		".word	0xA000"
+        : "=g"(__xaline), "=g"(__xfonts), "=g"(__xfuncs)  /* outputs */
+        :                                                 /* inputs  */
+        : __CLOBBER_RETURN("a0") __CLOBBER_RETURN("a1") __CLOBBER_RETURN("a2") "d0", "d1", "d2"       /* clobbered regs */
+        );
+
+        __aline = __xaline;
+        __fonts = __xfonts;
+        __funcs = __xfuncs;
 }
 
 void linea1() 							
 {									
-	    								
-	__asm__ volatile						
-	(" \
-		.word   0xA001" 
+	__asm__ volatile
+	(
+		".word	0xA001"
 	: 						  /* outputs */	
 	: 						  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	
@@ -42,21 +41,21 @@
 	register long retvalue __asm__("d0");
 
 	__asm__ volatile						
-	(" \
-		.word   0xA002"
+	(
+		".word	0xA002"
 	: "=r"(retvalue)				  /* outputs */	
 	: 						  /* inputs  */	
 	: __CLOBBER_RETURN("d0") "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	
 	);								
+
 	return (int) retvalue;
 }
 
 void linea3() 							
 {									
-	    								
 	__asm__ volatile						
-	(" \
-		.word   0xA003" 
+	(
+		".word	0xA003"
 	: 						  /* outputs */	
 	: 						  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	
@@ -65,10 +64,9 @@
 
 void linea4() 							
 {									
-	    								
 	__asm__ volatile						
-	(" \
-		.word   0xA004" 
+	(
+		".word	0xA004"
 	: 						  /* outputs */	
 	: 						  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	
@@ -77,10 +75,9 @@
 
 void linea5() 							
 {									
-	    								
 	__asm__ volatile						
-	(" \
-		.word   0xA005" 
+	(
+		".word	0xA005"
 	: 						  /* outputs */	
 	: 						  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	
@@ -89,10 +86,9 @@
 
 void linea6() 							
 {									
-	    								
 	__asm__ volatile						
-	(" \
-		.word   0xA006" 
+	(
+		".word	0xA006"
 	: 						  /* outputs */	
 	: 						  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	
@@ -101,25 +97,23 @@
 
 void linea7(BBPB *P) 							
 {									
-	    								
 	__asm__ volatile						
-	(" \
-		movml	d2/a2/a6, sp@-; \
- 		movl	%0,a6;  \
-		.word   0xA007; \
-		movml	sp@+, d2/a2/a6"
+	(
+		"movml	d2/a2/a6, sp@-\n\t"
+ 		"movl	%0,a6\n\t"
+		".word	0xA007\n\t"
+		"movml	sp@+, d2/a2/a6"
 	: 						  /* outputs */	
 	: "r"(P)					  /* inputs  */	
-	: "d0", "d1", "a0", "a1"	  	/* clobbered regs */	\
+	: "d0", "d1", "a0", "a1"		   /* clobbered regs */
 	);								
 }
 
 void linea8() 							
 {									
-	    								
 	__asm__ volatile						
-	(" \
-		.word   0xA008" 
+	(
+		".word	0xA008"
 	: 						  /* outputs */	
 	: 						  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	
@@ -128,10 +122,9 @@
 
 void linea9() 							
 {									
-	    								
 	__asm__ volatile						
-	(" \
-		.word   0xA009" 
+	(
+		".word	0xA009"
 	: 						  /* outputs */	
 	: 						  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	
@@ -139,11 +132,10 @@
 }
 
 void lineaa() 							
-{									
-	    								
+{
 	__asm__ volatile						
-	(" \
-		.word   0xA00A" 
+	(
+		".word	0xA00A"
 	: 						  /* outputs */	
 	: 						  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	
@@ -152,10 +144,9 @@
 
 void lineab() 							
 {									
-	    								
 	__asm__ volatile						
-	(" \
-		.word   0xA00B" 
+	(
+		".word	0xA00B"
 	: 						  /* outputs */	
 	: 						  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	
@@ -164,11 +155,10 @@
 
 void lineac(void *P) 							
 {									
-	    								
 	__asm__ volatile						
-	(" \
- 		movl	%0,a2;  \
-		.word   0xA00C" 
+	(
+ 		"movl	%0,a2\n\t"
+		".word	0xA00C"
 	: 						  /* outputs */	
 	: "r"(P)					  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"              /* clobbered regs */	
@@ -177,14 +167,13 @@
 
 void linead(int x, int y,  SFORM * sd, void *ss)
 {									
-	    								
 	__asm__ volatile						
-	(" \
- 		movw	%0,d0;  \
- 		movw	%1,d1;  \
- 		movl	%2,a0;  \
- 		movl	%3,a2;  \
-		.word   0xA00D" 
+	(
+ 		"movw	%0,d0\n\t"
+ 		"movw	%1,d1\n\t"
+ 		"movl	%2,a0\n\t"
+ 		"movl	%3,a2\n\t"
+		".word	0xA00D"
 	: 						  /* outputs */	
 	: "r"((short)x), "r"((short)y), "r"(sd), "r"(ss)  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"              /* clobbered regs */	
@@ -193,10 +182,9 @@
 
 void lineae() 							
 {									
-	    								
 	__asm__ volatile						
-	(" \
-		.word   0xA00E" 
+	(
+		".word	0xA00E"
 	: 						  /* outputs */	
 	: 						  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	
@@ -205,10 +193,9 @@
 
 void lineaf() 							
 {									
-	    								
 	__asm__ volatile						
-	(" \
-		.word   0xA00F" 
+	(
+		".word	0xA00F"
 	: 						  /* outputs */	
 	: 						  /* inputs  */	
 	: "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */	
diff -aurN -x CVS mintlib.orig/mintlib/machine-gmon.h mintlib/mintlib/machine-gmon.h
--- mintlib.orig/mintlib/machine-gmon.h	2000-10-12 13:30:47.000000000 +0200
+++ mintlib/mintlib/machine-gmon.h	2009-05-14 21:00:11.843750000 +0200
@@ -34,7 +34,7 @@
 #ifndef NO_UNDERSCORES
 /* The asm symbols for C functions are `_function'.
    The canonical name for the counter function is `mcount', no _.  */
-void _mcount (void) asm ("mcount");
+void _mcount (void) __asm__ ("mcount");
 #else
 /* The canonical name for the function is `_mcount' in both C and asm,
    but some old asm code might assume it's `mcount'.  */
diff -aurN -x CVS mintlib.orig/string/strrchr.c mintlib/string/strrchr.c
--- mintlib.orig/string/strrchr.c	2000-10-12 12:56:59.000000000 +0200
+++ mintlib/string/strrchr.c	2009-05-14 21:00:54.593750000 +0200
@@ -5,7 +5,7 @@
  * strrchr - find last occurrence of a character in a string
  */
 #ifdef __GNUC__
-asm(".stabs \"_rindex\",5,0,0,_strrchr"); /* dept of clean tricks */
+__asm__(".stabs \"_rindex\",5,0,0,_strrchr"); /* dept of clean tricks */
 #else
 char *
 rindex(s, charwanted)
diff -aurN -x CVS mintlib.orig/syscall/traps.c mintlib/syscall/traps.c
--- mintlib.orig/syscall/traps.c	2005-12-22 10:37:57.000000000 +0100
+++ mintlib/syscall/traps.c	2009-05-14 23:27:15.843750000 +0200
@@ -138,13 +138,13 @@
 			size += 4;
 		}
 		
-		fprintf(out, "\t%%%i,sp@-;\"\n", i+2);
+		fprintf(out, "\t%%%i,sp@-\\n\\t\"\n", i+2);
 		
 		i--;
 	}
 	
-	fprintf(out, "\t\t\"movw\t%%1,sp@-;\"\n");
-	fprintf(out, "\t\t\"trap\t#1;\"\n");
+	fprintf(out, "\t\t\"movw\t%%1,sp@-\\n\\t\"\n");
+	fprintf(out, "\t\t\"trap\t#1\\n\\t\"\n");
 	if (size <= 8)
 		fprintf(out, "\t\t\"addqw\t#%i,sp\"\n", size);
 	else