X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=support%2Fmap.c;h=4b91eecdbe0e9a9f1448885c84a3b4ea3786af1a;hb=29b42947bb854295a67abc875391333b5340c6b3;hp=a987cacda3ead491a71c4f39c4bfccbeb57fdd4d;hpb=0ccb7aca3d89c82a7e8c45b61cd63b66d8824e7a;p=mono.git

diff --git a/support/map.c b/support/map.c
index a987cacda3e..4b91eecdbe0 100644
--- a/support/map.c
+++ b/support/map.c
@@ -1,8 +1,9 @@
 /*
- * This file was automatically generated by make-map from Mono.Posix.dll.
+ * This file was automatically generated by make-map from ../../mcs/class/lib/default/Mono.Posix.dll.
  *
  * DO NOT MODIFY.
  */
+#include <config.h>
 
 #include "map.h"
 
@@ -14,13 +15,31 @@
 #endif /* ndef _XOPEN_SOURCE */
 #include <sys/types.h>
 #include <sys/stat.h>
+#ifdef HAVE_SYS_POLL_H
 #include <sys/poll.h>
+#endif
+#ifdef HAVE_SYS_WAIT_H
 #include <sys/wait.h>
+#endif
+#ifdef HAVE_SYS_STATVFS_H
+#include <sys/statvfs.h>
+#endif
+#ifdef HAVE_SYS_XATTR_H
+#include <sys/xattr.h>
+#endif
 #include <unistd.h>
 #include <fcntl.h>
 #include <signal.h>
+#ifdef HAVE_POLL_H
+#include <poll.h>
+#endif
+#ifdef HAVE_GRP_H
 #include <grp.h>
+#endif
 #include <errno.h>
+#ifdef HAVE_SYSLOG_H
+#include <syslog.h>
+#endif
 
 int Mono_Posix_FromError (int x, int *r)
 {
@@ -1278,6 +1297,399 @@ int Mono_Posix_ToError (int x, int *r)
 	errno = EINVAL; return -1;
 }
 
+int Mono_Posix_FromSyslogOptions (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_SyslogOptions_LOG_PID) == Mono_Posix_SyslogOptions_LOG_PID)
+#ifdef LOG_PID
+		*r |= LOG_PID;
+#else /* def LOG_PID */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_PID */
+	if ((x & Mono_Posix_SyslogOptions_LOG_CONS) == Mono_Posix_SyslogOptions_LOG_CONS)
+#ifdef LOG_CONS
+		*r |= LOG_CONS;
+#else /* def LOG_CONS */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_CONS */
+	if ((x & Mono_Posix_SyslogOptions_LOG_ODELAY) == Mono_Posix_SyslogOptions_LOG_ODELAY)
+#ifdef LOG_ODELAY
+		*r |= LOG_ODELAY;
+#else /* def LOG_ODELAY */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_ODELAY */
+	if ((x & Mono_Posix_SyslogOptions_LOG_NDELAY) == Mono_Posix_SyslogOptions_LOG_NDELAY)
+#ifdef LOG_NDELAY
+		*r |= LOG_NDELAY;
+#else /* def LOG_NDELAY */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_NDELAY */
+	if ((x & Mono_Posix_SyslogOptions_LOG_NOWAIT) == Mono_Posix_SyslogOptions_LOG_NOWAIT)
+#ifdef LOG_NOWAIT
+		*r |= LOG_NOWAIT;
+#else /* def LOG_NOWAIT */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_NOWAIT */
+	if ((x & Mono_Posix_SyslogOptions_LOG_PERROR) == Mono_Posix_SyslogOptions_LOG_PERROR)
+#ifdef LOG_PERROR
+		*r |= LOG_PERROR;
+#else /* def LOG_PERROR */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_PERROR */
+	return 0;
+}
+
+int Mono_Posix_ToSyslogOptions (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef LOG_PID
+	if ((x & LOG_PID) == LOG_PID)
+		*r |= Mono_Posix_SyslogOptions_LOG_PID;
+#endif /* ndef LOG_PID */
+#ifdef LOG_CONS
+	if ((x & LOG_CONS) == LOG_CONS)
+		*r |= Mono_Posix_SyslogOptions_LOG_CONS;
+#endif /* ndef LOG_CONS */
+#ifdef LOG_ODELAY
+	if ((x & LOG_ODELAY) == LOG_ODELAY)
+		*r |= Mono_Posix_SyslogOptions_LOG_ODELAY;
+#endif /* ndef LOG_ODELAY */
+#ifdef LOG_NDELAY
+	if ((x & LOG_NDELAY) == LOG_NDELAY)
+		*r |= Mono_Posix_SyslogOptions_LOG_NDELAY;
+#endif /* ndef LOG_NDELAY */
+#ifdef LOG_NOWAIT
+	if ((x & LOG_NOWAIT) == LOG_NOWAIT)
+		*r |= Mono_Posix_SyslogOptions_LOG_NOWAIT;
+#endif /* ndef LOG_NOWAIT */
+#ifdef LOG_PERROR
+	if ((x & LOG_PERROR) == LOG_PERROR)
+		*r |= Mono_Posix_SyslogOptions_LOG_PERROR;
+#endif /* ndef LOG_PERROR */
+	return 0;
+}
+
+int Mono_Posix_FromSyslogFacility (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if (x == Mono_Posix_SyslogFacility_LOG_KERN)
+#ifdef LOG_KERN
+		{*r = LOG_KERN; return 0;}
+#else /* def LOG_KERN */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_KERN */
+	if (x == Mono_Posix_SyslogFacility_LOG_USER)
+#ifdef LOG_USER
+		{*r = LOG_USER; return 0;}
+#else /* def LOG_USER */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_USER */
+	/* Mono_Posix_SyslogFacility_LOG_USRE is obsolete; ignoring */
+	if (x == Mono_Posix_SyslogFacility_LOG_MAIL)
+#ifdef LOG_MAIL
+		{*r = LOG_MAIL; return 0;}
+#else /* def LOG_MAIL */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_MAIL */
+	if (x == Mono_Posix_SyslogFacility_LOG_DAEMON)
+#ifdef LOG_DAEMON
+		{*r = LOG_DAEMON; return 0;}
+#else /* def LOG_DAEMON */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_DAEMON */
+	if (x == Mono_Posix_SyslogFacility_LOG_AUTH)
+#ifdef LOG_AUTH
+		{*r = LOG_AUTH; return 0;}
+#else /* def LOG_AUTH */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_AUTH */
+	if (x == Mono_Posix_SyslogFacility_LOG_SYSLOG)
+#ifdef LOG_SYSLOG
+		{*r = LOG_SYSLOG; return 0;}
+#else /* def LOG_SYSLOG */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_SYSLOG */
+	if (x == Mono_Posix_SyslogFacility_LOG_LPR)
+#ifdef LOG_LPR
+		{*r = LOG_LPR; return 0;}
+#else /* def LOG_LPR */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_LPR */
+	if (x == Mono_Posix_SyslogFacility_LOG_NEWS)
+#ifdef LOG_NEWS
+		{*r = LOG_NEWS; return 0;}
+#else /* def LOG_NEWS */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_NEWS */
+	if (x == Mono_Posix_SyslogFacility_LOG_UUCP)
+#ifdef LOG_UUCP
+		{*r = LOG_UUCP; return 0;}
+#else /* def LOG_UUCP */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_UUCP */
+	if (x == Mono_Posix_SyslogFacility_LOG_CRON)
+#ifdef LOG_CRON
+		{*r = LOG_CRON; return 0;}
+#else /* def LOG_CRON */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_CRON */
+	if (x == Mono_Posix_SyslogFacility_LOG_AUTHPRIV)
+#ifdef LOG_AUTHPRIV
+		{*r = LOG_AUTHPRIV; return 0;}
+#else /* def LOG_AUTHPRIV */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_AUTHPRIV */
+	if (x == Mono_Posix_SyslogFacility_LOG_FTP)
+#ifdef LOG_FTP
+		{*r = LOG_FTP; return 0;}
+#else /* def LOG_FTP */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_FTP */
+	if (x == Mono_Posix_SyslogFacility_LOG_LOCAL0)
+#ifdef LOG_LOCAL0
+		{*r = LOG_LOCAL0; return 0;}
+#else /* def LOG_LOCAL0 */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_LOCAL0 */
+	if (x == Mono_Posix_SyslogFacility_LOG_LOCAL1)
+#ifdef LOG_LOCAL1
+		{*r = LOG_LOCAL1; return 0;}
+#else /* def LOG_LOCAL1 */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_LOCAL1 */
+	if (x == Mono_Posix_SyslogFacility_LOG_LOCAL2)
+#ifdef LOG_LOCAL2
+		{*r = LOG_LOCAL2; return 0;}
+#else /* def LOG_LOCAL2 */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_LOCAL2 */
+	if (x == Mono_Posix_SyslogFacility_LOG_LOCAL3)
+#ifdef LOG_LOCAL3
+		{*r = LOG_LOCAL3; return 0;}
+#else /* def LOG_LOCAL3 */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_LOCAL3 */
+	if (x == Mono_Posix_SyslogFacility_LOG_LOCAL4)
+#ifdef LOG_LOCAL4
+		{*r = LOG_LOCAL4; return 0;}
+#else /* def LOG_LOCAL4 */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_LOCAL4 */
+	if (x == Mono_Posix_SyslogFacility_LOG_LOCAL5)
+#ifdef LOG_LOCAL5
+		{*r = LOG_LOCAL5; return 0;}
+#else /* def LOG_LOCAL5 */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_LOCAL5 */
+	if (x == Mono_Posix_SyslogFacility_LOG_LOCAL6)
+#ifdef LOG_LOCAL6
+		{*r = LOG_LOCAL6; return 0;}
+#else /* def LOG_LOCAL6 */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_LOCAL6 */
+	if (x == Mono_Posix_SyslogFacility_LOG_LOCAL7)
+#ifdef LOG_LOCAL7
+		{*r = LOG_LOCAL7; return 0;}
+#else /* def LOG_LOCAL7 */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_LOCAL7 */
+	errno = EINVAL; return -1;
+}
+
+int Mono_Posix_ToSyslogFacility (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef LOG_KERN
+	if (x == LOG_KERN)
+		{*r = Mono_Posix_SyslogFacility_LOG_KERN; return 0;}
+#endif /* ndef LOG_KERN */
+#ifdef LOG_USER
+	if (x == LOG_USER)
+		{*r = Mono_Posix_SyslogFacility_LOG_USER; return 0;}
+#endif /* ndef LOG_USER */
+#ifdef LOG_USRE
+	if (x == LOG_USRE)
+		{*r = Mono_Posix_SyslogFacility_LOG_USRE; return 0;}
+#endif /* ndef LOG_USRE */
+#ifdef LOG_MAIL
+	if (x == LOG_MAIL)
+		{*r = Mono_Posix_SyslogFacility_LOG_MAIL; return 0;}
+#endif /* ndef LOG_MAIL */
+#ifdef LOG_DAEMON
+	if (x == LOG_DAEMON)
+		{*r = Mono_Posix_SyslogFacility_LOG_DAEMON; return 0;}
+#endif /* ndef LOG_DAEMON */
+#ifdef LOG_AUTH
+	if (x == LOG_AUTH)
+		{*r = Mono_Posix_SyslogFacility_LOG_AUTH; return 0;}
+#endif /* ndef LOG_AUTH */
+#ifdef LOG_SYSLOG
+	if (x == LOG_SYSLOG)
+		{*r = Mono_Posix_SyslogFacility_LOG_SYSLOG; return 0;}
+#endif /* ndef LOG_SYSLOG */
+#ifdef LOG_LPR
+	if (x == LOG_LPR)
+		{*r = Mono_Posix_SyslogFacility_LOG_LPR; return 0;}
+#endif /* ndef LOG_LPR */
+#ifdef LOG_NEWS
+	if (x == LOG_NEWS)
+		{*r = Mono_Posix_SyslogFacility_LOG_NEWS; return 0;}
+#endif /* ndef LOG_NEWS */
+#ifdef LOG_UUCP
+	if (x == LOG_UUCP)
+		{*r = Mono_Posix_SyslogFacility_LOG_UUCP; return 0;}
+#endif /* ndef LOG_UUCP */
+#ifdef LOG_CRON
+	if (x == LOG_CRON)
+		{*r = Mono_Posix_SyslogFacility_LOG_CRON; return 0;}
+#endif /* ndef LOG_CRON */
+#ifdef LOG_AUTHPRIV
+	if (x == LOG_AUTHPRIV)
+		{*r = Mono_Posix_SyslogFacility_LOG_AUTHPRIV; return 0;}
+#endif /* ndef LOG_AUTHPRIV */
+#ifdef LOG_FTP
+	if (x == LOG_FTP)
+		{*r = Mono_Posix_SyslogFacility_LOG_FTP; return 0;}
+#endif /* ndef LOG_FTP */
+#ifdef LOG_LOCAL0
+	if (x == LOG_LOCAL0)
+		{*r = Mono_Posix_SyslogFacility_LOG_LOCAL0; return 0;}
+#endif /* ndef LOG_LOCAL0 */
+#ifdef LOG_LOCAL1
+	if (x == LOG_LOCAL1)
+		{*r = Mono_Posix_SyslogFacility_LOG_LOCAL1; return 0;}
+#endif /* ndef LOG_LOCAL1 */
+#ifdef LOG_LOCAL2
+	if (x == LOG_LOCAL2)
+		{*r = Mono_Posix_SyslogFacility_LOG_LOCAL2; return 0;}
+#endif /* ndef LOG_LOCAL2 */
+#ifdef LOG_LOCAL3
+	if (x == LOG_LOCAL3)
+		{*r = Mono_Posix_SyslogFacility_LOG_LOCAL3; return 0;}
+#endif /* ndef LOG_LOCAL3 */
+#ifdef LOG_LOCAL4
+	if (x == LOG_LOCAL4)
+		{*r = Mono_Posix_SyslogFacility_LOG_LOCAL4; return 0;}
+#endif /* ndef LOG_LOCAL4 */
+#ifdef LOG_LOCAL5
+	if (x == LOG_LOCAL5)
+		{*r = Mono_Posix_SyslogFacility_LOG_LOCAL5; return 0;}
+#endif /* ndef LOG_LOCAL5 */
+#ifdef LOG_LOCAL6
+	if (x == LOG_LOCAL6)
+		{*r = Mono_Posix_SyslogFacility_LOG_LOCAL6; return 0;}
+#endif /* ndef LOG_LOCAL6 */
+#ifdef LOG_LOCAL7
+	if (x == LOG_LOCAL7)
+		{*r = Mono_Posix_SyslogFacility_LOG_LOCAL7; return 0;}
+#endif /* ndef LOG_LOCAL7 */
+	errno = EINVAL; return -1;
+}
+
+int Mono_Posix_FromSyslogLevel (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if (x == Mono_Posix_SyslogLevel_LOG_EMERG)
+#ifdef LOG_EMERG
+		{*r = LOG_EMERG; return 0;}
+#else /* def LOG_EMERG */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_EMERG */
+	if (x == Mono_Posix_SyslogLevel_LOG_ALERT)
+#ifdef LOG_ALERT
+		{*r = LOG_ALERT; return 0;}
+#else /* def LOG_ALERT */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_ALERT */
+	if (x == Mono_Posix_SyslogLevel_LOG_CRIT)
+#ifdef LOG_CRIT
+		{*r = LOG_CRIT; return 0;}
+#else /* def LOG_CRIT */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_CRIT */
+	if (x == Mono_Posix_SyslogLevel_LOG_ERR)
+#ifdef LOG_ERR
+		{*r = LOG_ERR; return 0;}
+#else /* def LOG_ERR */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_ERR */
+	if (x == Mono_Posix_SyslogLevel_LOG_WARNING)
+#ifdef LOG_WARNING
+		{*r = LOG_WARNING; return 0;}
+#else /* def LOG_WARNING */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_WARNING */
+	if (x == Mono_Posix_SyslogLevel_LOG_NOTICE)
+#ifdef LOG_NOTICE
+		{*r = LOG_NOTICE; return 0;}
+#else /* def LOG_NOTICE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_NOTICE */
+	if (x == Mono_Posix_SyslogLevel_LOG_INFO)
+#ifdef LOG_INFO
+		{*r = LOG_INFO; return 0;}
+#else /* def LOG_INFO */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_INFO */
+	if (x == Mono_Posix_SyslogLevel_LOG_DEBUG)
+#ifdef LOG_DEBUG
+		{*r = LOG_DEBUG; return 0;}
+#else /* def LOG_DEBUG */
+		{errno = EINVAL; return -1;}
+#endif /* ndef LOG_DEBUG */
+	errno = EINVAL; return -1;
+}
+
+int Mono_Posix_ToSyslogLevel (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef LOG_EMERG
+	if (x == LOG_EMERG)
+		{*r = Mono_Posix_SyslogLevel_LOG_EMERG; return 0;}
+#endif /* ndef LOG_EMERG */
+#ifdef LOG_ALERT
+	if (x == LOG_ALERT)
+		{*r = Mono_Posix_SyslogLevel_LOG_ALERT; return 0;}
+#endif /* ndef LOG_ALERT */
+#ifdef LOG_CRIT
+	if (x == LOG_CRIT)
+		{*r = Mono_Posix_SyslogLevel_LOG_CRIT; return 0;}
+#endif /* ndef LOG_CRIT */
+#ifdef LOG_ERR
+	if (x == LOG_ERR)
+		{*r = Mono_Posix_SyslogLevel_LOG_ERR; return 0;}
+#endif /* ndef LOG_ERR */
+#ifdef LOG_WARNING
+	if (x == LOG_WARNING)
+		{*r = Mono_Posix_SyslogLevel_LOG_WARNING; return 0;}
+#endif /* ndef LOG_WARNING */
+#ifdef LOG_NOTICE
+	if (x == LOG_NOTICE)
+		{*r = Mono_Posix_SyslogLevel_LOG_NOTICE; return 0;}
+#endif /* ndef LOG_NOTICE */
+#ifdef LOG_INFO
+	if (x == LOG_INFO)
+		{*r = Mono_Posix_SyslogLevel_LOG_INFO; return 0;}
+#endif /* ndef LOG_INFO */
+#ifdef LOG_DEBUG
+	if (x == LOG_DEBUG)
+		{*r = Mono_Posix_SyslogLevel_LOG_DEBUG; return 0;}
+#endif /* ndef LOG_DEBUG */
+	errno = EINVAL; return -1;
+}
+
 int Mono_Posix_FromOpenFlags (int x, int *r)
 {
 	*r = 0;
@@ -5402,30 +5814,30 @@ int Mono_Posix_ToConfStr (int x, int *r)
 	errno = EINVAL; return -1;
 }
 
-int Mono_Posix_FromLockFlags (int x, int *r)
+int Mono_Posix_FromLockfCommand (int x, int *r)
 {
 	*r = 0;
 	if (x == 0)
 		return 0;
-	if (x == Mono_Posix_LockFlags_F_ULOCK)
+	if (x == Mono_Posix_LockfCommand_F_ULOCK)
 #ifdef F_ULOCK
 		{*r = F_ULOCK; return 0;}
 #else /* def F_ULOCK */
 		{errno = EINVAL; return -1;}
 #endif /* ndef F_ULOCK */
-	if (x == Mono_Posix_LockFlags_F_LOCK)
+	if (x == Mono_Posix_LockfCommand_F_LOCK)
 #ifdef F_LOCK
 		{*r = F_LOCK; return 0;}
 #else /* def F_LOCK */
 		{errno = EINVAL; return -1;}
 #endif /* ndef F_LOCK */
-	if (x == Mono_Posix_LockFlags_F_TLOCK)
+	if (x == Mono_Posix_LockfCommand_F_TLOCK)
 #ifdef F_TLOCK
 		{*r = F_TLOCK; return 0;}
 #else /* def F_TLOCK */
 		{errno = EINVAL; return -1;}
 #endif /* ndef F_TLOCK */
-	if (x == Mono_Posix_LockFlags_F_TEST)
+	if (x == Mono_Posix_LockfCommand_F_TEST)
 #ifdef F_TEST
 		{*r = F_TEST; return 0;}
 #else /* def F_TEST */
@@ -5434,26 +5846,26 @@ int Mono_Posix_FromLockFlags (int x, int *r)
 	errno = EINVAL; return -1;
 }
 
-int Mono_Posix_ToLockFlags (int x, int *r)
+int Mono_Posix_ToLockfCommand (int x, int *r)
 {
 	*r = 0;
 	if (x == 0)
 		return 0;
 #ifdef F_ULOCK
 	if (x == F_ULOCK)
-		{*r = Mono_Posix_LockFlags_F_ULOCK; return 0;}
+		{*r = Mono_Posix_LockfCommand_F_ULOCK; return 0;}
 #endif /* ndef F_ULOCK */
 #ifdef F_LOCK
 	if (x == F_LOCK)
-		{*r = Mono_Posix_LockFlags_F_LOCK; return 0;}
+		{*r = Mono_Posix_LockfCommand_F_LOCK; return 0;}
 #endif /* ndef F_LOCK */
 #ifdef F_TLOCK
 	if (x == F_TLOCK)
-		{*r = Mono_Posix_LockFlags_F_TLOCK; return 0;}
+		{*r = Mono_Posix_LockfCommand_F_TLOCK; return 0;}
 #endif /* ndef F_TLOCK */
 #ifdef F_TEST
 	if (x == F_TEST)
-		{*r = Mono_Posix_LockFlags_F_TEST; return 0;}
+		{*r = Mono_Posix_LockfCommand_F_TEST; return 0;}
 #endif /* ndef F_TEST */
 	errno = EINVAL; return -1;
 }
@@ -5574,3 +5986,505 @@ int Mono_Posix_ToPollEvents (short x, short *r)
 	return 0;
 }
 
+int Mono_Posix_FromXattrFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_XattrFlags_XATTR_AUTO) == Mono_Posix_XattrFlags_XATTR_AUTO)
+#ifdef XATTR_AUTO
+		*r |= XATTR_AUTO;
+#else /* def XATTR_AUTO */
+		{errno = EINVAL; return -1;}
+#endif /* ndef XATTR_AUTO */
+	if ((x & Mono_Posix_XattrFlags_XATTR_CREATE) == Mono_Posix_XattrFlags_XATTR_CREATE)
+#ifdef XATTR_CREATE
+		*r |= XATTR_CREATE;
+#else /* def XATTR_CREATE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef XATTR_CREATE */
+	if ((x & Mono_Posix_XattrFlags_XATTR_REPLACE) == Mono_Posix_XattrFlags_XATTR_REPLACE)
+#ifdef XATTR_REPLACE
+		*r |= XATTR_REPLACE;
+#else /* def XATTR_REPLACE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef XATTR_REPLACE */
+	return 0;
+}
+
+int Mono_Posix_ToXattrFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef XATTR_AUTO
+	if ((x & XATTR_AUTO) == XATTR_AUTO)
+		*r |= Mono_Posix_XattrFlags_XATTR_AUTO;
+#endif /* ndef XATTR_AUTO */
+#ifdef XATTR_CREATE
+	if ((x & XATTR_CREATE) == XATTR_CREATE)
+		*r |= Mono_Posix_XattrFlags_XATTR_CREATE;
+#endif /* ndef XATTR_CREATE */
+#ifdef XATTR_REPLACE
+	if ((x & XATTR_REPLACE) == XATTR_REPLACE)
+		*r |= Mono_Posix_XattrFlags_XATTR_REPLACE;
+#endif /* ndef XATTR_REPLACE */
+	return 0;
+}
+
+int Mono_Posix_FromMountFlags (guint64 x, guint64 *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_MountFlags_ST_RDONLY) == Mono_Posix_MountFlags_ST_RDONLY)
+#ifdef ST_RDONLY
+		*r |= ST_RDONLY;
+#else /* def ST_RDONLY */
+		{errno = EINVAL; return -1;}
+#endif /* ndef ST_RDONLY */
+	if ((x & Mono_Posix_MountFlags_ST_NOSUID) == Mono_Posix_MountFlags_ST_NOSUID)
+#ifdef ST_NOSUID
+		*r |= ST_NOSUID;
+#else /* def ST_NOSUID */
+		{errno = EINVAL; return -1;}
+#endif /* ndef ST_NOSUID */
+	if ((x & Mono_Posix_MountFlags_ST_NODEV) == Mono_Posix_MountFlags_ST_NODEV)
+#ifdef ST_NODEV
+		*r |= ST_NODEV;
+#else /* def ST_NODEV */
+		{errno = EINVAL; return -1;}
+#endif /* ndef ST_NODEV */
+	if ((x & Mono_Posix_MountFlags_ST_SYNCHRONOUS) == Mono_Posix_MountFlags_ST_SYNCHRONOUS)
+#ifdef ST_SYNCHRONOUS
+		*r |= ST_SYNCHRONOUS;
+#else /* def ST_SYNCHRONOUS */
+		{errno = EINVAL; return -1;}
+#endif /* ndef ST_SYNCHRONOUS */
+	if ((x & Mono_Posix_MountFlags_ST_MANDLOCK) == Mono_Posix_MountFlags_ST_MANDLOCK)
+#ifdef ST_MANDLOCK
+		*r |= ST_MANDLOCK;
+#else /* def ST_MANDLOCK */
+		{errno = EINVAL; return -1;}
+#endif /* ndef ST_MANDLOCK */
+	if ((x & Mono_Posix_MountFlags_ST_WRITE) == Mono_Posix_MountFlags_ST_WRITE)
+#ifdef ST_WRITE
+		*r |= ST_WRITE;
+#else /* def ST_WRITE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef ST_WRITE */
+	if ((x & Mono_Posix_MountFlags_ST_APPEND) == Mono_Posix_MountFlags_ST_APPEND)
+#ifdef ST_APPEND
+		*r |= ST_APPEND;
+#else /* def ST_APPEND */
+		{errno = EINVAL; return -1;}
+#endif /* ndef ST_APPEND */
+	if ((x & Mono_Posix_MountFlags_ST_IMMUTABLE) == Mono_Posix_MountFlags_ST_IMMUTABLE)
+#ifdef ST_IMMUTABLE
+		*r |= ST_IMMUTABLE;
+#else /* def ST_IMMUTABLE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef ST_IMMUTABLE */
+	if ((x & Mono_Posix_MountFlags_ST_NOATIME) == Mono_Posix_MountFlags_ST_NOATIME)
+#ifdef ST_NOATIME
+		*r |= ST_NOATIME;
+#else /* def ST_NOATIME */
+		{errno = EINVAL; return -1;}
+#endif /* ndef ST_NOATIME */
+	if ((x & Mono_Posix_MountFlags_ST_NODIRATIME) == Mono_Posix_MountFlags_ST_NODIRATIME)
+#ifdef ST_NODIRATIME
+		*r |= ST_NODIRATIME;
+#else /* def ST_NODIRATIME */
+		{errno = EINVAL; return -1;}
+#endif /* ndef ST_NODIRATIME */
+	return 0;
+}
+
+int Mono_Posix_ToMountFlags (guint64 x, guint64 *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef ST_RDONLY
+	if ((x & ST_RDONLY) == ST_RDONLY)
+		*r |= Mono_Posix_MountFlags_ST_RDONLY;
+#endif /* ndef ST_RDONLY */
+#ifdef ST_NOSUID
+	if ((x & ST_NOSUID) == ST_NOSUID)
+		*r |= Mono_Posix_MountFlags_ST_NOSUID;
+#endif /* ndef ST_NOSUID */
+#ifdef ST_NODEV
+	if ((x & ST_NODEV) == ST_NODEV)
+		*r |= Mono_Posix_MountFlags_ST_NODEV;
+#endif /* ndef ST_NODEV */
+#ifdef ST_SYNCHRONOUS
+	if ((x & ST_SYNCHRONOUS) == ST_SYNCHRONOUS)
+		*r |= Mono_Posix_MountFlags_ST_SYNCHRONOUS;
+#endif /* ndef ST_SYNCHRONOUS */
+#ifdef ST_MANDLOCK
+	if ((x & ST_MANDLOCK) == ST_MANDLOCK)
+		*r |= Mono_Posix_MountFlags_ST_MANDLOCK;
+#endif /* ndef ST_MANDLOCK */
+#ifdef ST_WRITE
+	if ((x & ST_WRITE) == ST_WRITE)
+		*r |= Mono_Posix_MountFlags_ST_WRITE;
+#endif /* ndef ST_WRITE */
+#ifdef ST_APPEND
+	if ((x & ST_APPEND) == ST_APPEND)
+		*r |= Mono_Posix_MountFlags_ST_APPEND;
+#endif /* ndef ST_APPEND */
+#ifdef ST_IMMUTABLE
+	if ((x & ST_IMMUTABLE) == ST_IMMUTABLE)
+		*r |= Mono_Posix_MountFlags_ST_IMMUTABLE;
+#endif /* ndef ST_IMMUTABLE */
+#ifdef ST_NOATIME
+	if ((x & ST_NOATIME) == ST_NOATIME)
+		*r |= Mono_Posix_MountFlags_ST_NOATIME;
+#endif /* ndef ST_NOATIME */
+#ifdef ST_NODIRATIME
+	if ((x & ST_NODIRATIME) == ST_NODIRATIME)
+		*r |= Mono_Posix_MountFlags_ST_NODIRATIME;
+#endif /* ndef ST_NODIRATIME */
+	return 0;
+}
+
+int Mono_Posix_FromMmapFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_MmapFlags_MAP_SHARED) == Mono_Posix_MmapFlags_MAP_SHARED)
+#ifdef MAP_SHARED
+		*r |= MAP_SHARED;
+#else /* def MAP_SHARED */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_SHARED */
+	if ((x & Mono_Posix_MmapFlags_MAP_PRIVATE) == Mono_Posix_MmapFlags_MAP_PRIVATE)
+#ifdef MAP_PRIVATE
+		*r |= MAP_PRIVATE;
+#else /* def MAP_PRIVATE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_PRIVATE */
+	if ((x & Mono_Posix_MmapFlags_MAP_TYPE) == Mono_Posix_MmapFlags_MAP_TYPE)
+#ifdef MAP_TYPE
+		*r |= MAP_TYPE;
+#else /* def MAP_TYPE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_TYPE */
+	if ((x & Mono_Posix_MmapFlags_MAP_FIXED) == Mono_Posix_MmapFlags_MAP_FIXED)
+#ifdef MAP_FIXED
+		*r |= MAP_FIXED;
+#else /* def MAP_FIXED */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_FIXED */
+	if ((x & Mono_Posix_MmapFlags_MAP_FILE) == Mono_Posix_MmapFlags_MAP_FILE)
+#ifdef MAP_FILE
+		*r |= MAP_FILE;
+#else /* def MAP_FILE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_FILE */
+	if ((x & Mono_Posix_MmapFlags_MAP_ANONYMOUS) == Mono_Posix_MmapFlags_MAP_ANONYMOUS)
+#ifdef MAP_ANONYMOUS
+		*r |= MAP_ANONYMOUS;
+#else /* def MAP_ANONYMOUS */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_ANONYMOUS */
+	if ((x & Mono_Posix_MmapFlags_MAP_ANON) == Mono_Posix_MmapFlags_MAP_ANON)
+#ifdef MAP_ANON
+		*r |= MAP_ANON;
+#else /* def MAP_ANON */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_ANON */
+	if ((x & Mono_Posix_MmapFlags_MAP_GROWSDOWN) == Mono_Posix_MmapFlags_MAP_GROWSDOWN)
+#ifdef MAP_GROWSDOWN
+		*r |= MAP_GROWSDOWN;
+#else /* def MAP_GROWSDOWN */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_GROWSDOWN */
+	if ((x & Mono_Posix_MmapFlags_MAP_DENYWRITE) == Mono_Posix_MmapFlags_MAP_DENYWRITE)
+#ifdef MAP_DENYWRITE
+		*r |= MAP_DENYWRITE;
+#else /* def MAP_DENYWRITE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_DENYWRITE */
+	if ((x & Mono_Posix_MmapFlags_MAP_EXECUTABLE) == Mono_Posix_MmapFlags_MAP_EXECUTABLE)
+#ifdef MAP_EXECUTABLE
+		*r |= MAP_EXECUTABLE;
+#else /* def MAP_EXECUTABLE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_EXECUTABLE */
+	if ((x & Mono_Posix_MmapFlags_MAP_LOCKED) == Mono_Posix_MmapFlags_MAP_LOCKED)
+#ifdef MAP_LOCKED
+		*r |= MAP_LOCKED;
+#else /* def MAP_LOCKED */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_LOCKED */
+	if ((x & Mono_Posix_MmapFlags_MAP_NORESERVE) == Mono_Posix_MmapFlags_MAP_NORESERVE)
+#ifdef MAP_NORESERVE
+		*r |= MAP_NORESERVE;
+#else /* def MAP_NORESERVE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_NORESERVE */
+	if ((x & Mono_Posix_MmapFlags_MAP_POPULATE) == Mono_Posix_MmapFlags_MAP_POPULATE)
+#ifdef MAP_POPULATE
+		*r |= MAP_POPULATE;
+#else /* def MAP_POPULATE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_POPULATE */
+	if ((x & Mono_Posix_MmapFlags_MAP_NONBLOCK) == Mono_Posix_MmapFlags_MAP_NONBLOCK)
+#ifdef MAP_NONBLOCK
+		*r |= MAP_NONBLOCK;
+#else /* def MAP_NONBLOCK */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_NONBLOCK */
+	return 0;
+}
+
+int Mono_Posix_ToMmapFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef MAP_SHARED
+	if ((x & MAP_SHARED) == MAP_SHARED)
+		*r |= Mono_Posix_MmapFlags_MAP_SHARED;
+#endif /* ndef MAP_SHARED */
+#ifdef MAP_PRIVATE
+	if ((x & MAP_PRIVATE) == MAP_PRIVATE)
+		*r |= Mono_Posix_MmapFlags_MAP_PRIVATE;
+#endif /* ndef MAP_PRIVATE */
+#ifdef MAP_TYPE
+	if ((x & MAP_TYPE) == MAP_TYPE)
+		*r |= Mono_Posix_MmapFlags_MAP_TYPE;
+#endif /* ndef MAP_TYPE */
+#ifdef MAP_FIXED
+	if ((x & MAP_FIXED) == MAP_FIXED)
+		*r |= Mono_Posix_MmapFlags_MAP_FIXED;
+#endif /* ndef MAP_FIXED */
+#ifdef MAP_FILE
+	if ((x & MAP_FILE) == MAP_FILE)
+		*r |= Mono_Posix_MmapFlags_MAP_FILE;
+#endif /* ndef MAP_FILE */
+#ifdef MAP_ANONYMOUS
+	if ((x & MAP_ANONYMOUS) == MAP_ANONYMOUS)
+		*r |= Mono_Posix_MmapFlags_MAP_ANONYMOUS;
+#endif /* ndef MAP_ANONYMOUS */
+#ifdef MAP_ANON
+	if ((x & MAP_ANON) == MAP_ANON)
+		*r |= Mono_Posix_MmapFlags_MAP_ANON;
+#endif /* ndef MAP_ANON */
+#ifdef MAP_GROWSDOWN
+	if ((x & MAP_GROWSDOWN) == MAP_GROWSDOWN)
+		*r |= Mono_Posix_MmapFlags_MAP_GROWSDOWN;
+#endif /* ndef MAP_GROWSDOWN */
+#ifdef MAP_DENYWRITE
+	if ((x & MAP_DENYWRITE) == MAP_DENYWRITE)
+		*r |= Mono_Posix_MmapFlags_MAP_DENYWRITE;
+#endif /* ndef MAP_DENYWRITE */
+#ifdef MAP_EXECUTABLE
+	if ((x & MAP_EXECUTABLE) == MAP_EXECUTABLE)
+		*r |= Mono_Posix_MmapFlags_MAP_EXECUTABLE;
+#endif /* ndef MAP_EXECUTABLE */
+#ifdef MAP_LOCKED
+	if ((x & MAP_LOCKED) == MAP_LOCKED)
+		*r |= Mono_Posix_MmapFlags_MAP_LOCKED;
+#endif /* ndef MAP_LOCKED */
+#ifdef MAP_NORESERVE
+	if ((x & MAP_NORESERVE) == MAP_NORESERVE)
+		*r |= Mono_Posix_MmapFlags_MAP_NORESERVE;
+#endif /* ndef MAP_NORESERVE */
+#ifdef MAP_POPULATE
+	if ((x & MAP_POPULATE) == MAP_POPULATE)
+		*r |= Mono_Posix_MmapFlags_MAP_POPULATE;
+#endif /* ndef MAP_POPULATE */
+#ifdef MAP_NONBLOCK
+	if ((x & MAP_NONBLOCK) == MAP_NONBLOCK)
+		*r |= Mono_Posix_MmapFlags_MAP_NONBLOCK;
+#endif /* ndef MAP_NONBLOCK */
+	return 0;
+}
+
+int Mono_Posix_FromMmapProt (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_MmapProt_PROT_READ) == Mono_Posix_MmapProt_PROT_READ)
+#ifdef PROT_READ
+		*r |= PROT_READ;
+#else /* def PROT_READ */
+		{errno = EINVAL; return -1;}
+#endif /* ndef PROT_READ */
+	if ((x & Mono_Posix_MmapProt_PROT_WRITE) == Mono_Posix_MmapProt_PROT_WRITE)
+#ifdef PROT_WRITE
+		*r |= PROT_WRITE;
+#else /* def PROT_WRITE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef PROT_WRITE */
+	if ((x & Mono_Posix_MmapProt_PROT_EXEC) == Mono_Posix_MmapProt_PROT_EXEC)
+#ifdef PROT_EXEC
+		*r |= PROT_EXEC;
+#else /* def PROT_EXEC */
+		{errno = EINVAL; return -1;}
+#endif /* ndef PROT_EXEC */
+	if ((x & Mono_Posix_MmapProt_PROT_NONE) == Mono_Posix_MmapProt_PROT_NONE)
+#ifdef PROT_NONE
+		*r |= PROT_NONE;
+#else /* def PROT_NONE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef PROT_NONE */
+	if ((x & Mono_Posix_MmapProt_PROT_GROWSDOWN) == Mono_Posix_MmapProt_PROT_GROWSDOWN)
+#ifdef PROT_GROWSDOWN
+		*r |= PROT_GROWSDOWN;
+#else /* def PROT_GROWSDOWN */
+		{errno = EINVAL; return -1;}
+#endif /* ndef PROT_GROWSDOWN */
+	if ((x & Mono_Posix_MmapProt_PROT_GROWSUP) == Mono_Posix_MmapProt_PROT_GROWSUP)
+#ifdef PROT_GROWSUP
+		*r |= PROT_GROWSUP;
+#else /* def PROT_GROWSUP */
+		{errno = EINVAL; return -1;}
+#endif /* ndef PROT_GROWSUP */
+	return 0;
+}
+
+int Mono_Posix_ToMmapProt (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef PROT_READ
+	if ((x & PROT_READ) == PROT_READ)
+		*r |= Mono_Posix_MmapProt_PROT_READ;
+#endif /* ndef PROT_READ */
+#ifdef PROT_WRITE
+	if ((x & PROT_WRITE) == PROT_WRITE)
+		*r |= Mono_Posix_MmapProt_PROT_WRITE;
+#endif /* ndef PROT_WRITE */
+#ifdef PROT_EXEC
+	if ((x & PROT_EXEC) == PROT_EXEC)
+		*r |= Mono_Posix_MmapProt_PROT_EXEC;
+#endif /* ndef PROT_EXEC */
+#ifdef PROT_NONE
+	if ((x & PROT_NONE) == PROT_NONE)
+		*r |= Mono_Posix_MmapProt_PROT_NONE;
+#endif /* ndef PROT_NONE */
+#ifdef PROT_GROWSDOWN
+	if ((x & PROT_GROWSDOWN) == PROT_GROWSDOWN)
+		*r |= Mono_Posix_MmapProt_PROT_GROWSDOWN;
+#endif /* ndef PROT_GROWSDOWN */
+#ifdef PROT_GROWSUP
+	if ((x & PROT_GROWSUP) == PROT_GROWSUP)
+		*r |= Mono_Posix_MmapProt_PROT_GROWSUP;
+#endif /* ndef PROT_GROWSUP */
+	return 0;
+}
+
+int Mono_Posix_FromMsyncFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_MsyncFlags_MS_ASYNC) == Mono_Posix_MsyncFlags_MS_ASYNC)
+#ifdef MS_ASYNC
+		*r |= MS_ASYNC;
+#else /* def MS_ASYNC */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MS_ASYNC */
+	if ((x & Mono_Posix_MsyncFlags_MS_SYNC) == Mono_Posix_MsyncFlags_MS_SYNC)
+#ifdef MS_SYNC
+		*r |= MS_SYNC;
+#else /* def MS_SYNC */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MS_SYNC */
+	if ((x & Mono_Posix_MsyncFlags_MS_INVALIDATE) == Mono_Posix_MsyncFlags_MS_INVALIDATE)
+#ifdef MS_INVALIDATE
+		*r |= MS_INVALIDATE;
+#else /* def MS_INVALIDATE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MS_INVALIDATE */
+	return 0;
+}
+
+int Mono_Posix_ToMsyncFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef MS_ASYNC
+	if ((x & MS_ASYNC) == MS_ASYNC)
+		*r |= Mono_Posix_MsyncFlags_MS_ASYNC;
+#endif /* ndef MS_ASYNC */
+#ifdef MS_SYNC
+	if ((x & MS_SYNC) == MS_SYNC)
+		*r |= Mono_Posix_MsyncFlags_MS_SYNC;
+#endif /* ndef MS_SYNC */
+#ifdef MS_INVALIDATE
+	if ((x & MS_INVALIDATE) == MS_INVALIDATE)
+		*r |= Mono_Posix_MsyncFlags_MS_INVALIDATE;
+#endif /* ndef MS_INVALIDATE */
+	return 0;
+}
+
+int Mono_Posix_FromMlockallFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_MlockallFlags_MCL_CURRENT) == Mono_Posix_MlockallFlags_MCL_CURRENT)
+#ifdef MCL_CURRENT
+		*r |= MCL_CURRENT;
+#else /* def MCL_CURRENT */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MCL_CURRENT */
+	if ((x & Mono_Posix_MlockallFlags_MCL_FUTURE) == Mono_Posix_MlockallFlags_MCL_FUTURE)
+#ifdef MCL_FUTURE
+		*r |= MCL_FUTURE;
+#else /* def MCL_FUTURE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MCL_FUTURE */
+	return 0;
+}
+
+int Mono_Posix_ToMlockallFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef MCL_CURRENT
+	if ((x & MCL_CURRENT) == MCL_CURRENT)
+		*r |= Mono_Posix_MlockallFlags_MCL_CURRENT;
+#endif /* ndef MCL_CURRENT */
+#ifdef MCL_FUTURE
+	if ((x & MCL_FUTURE) == MCL_FUTURE)
+		*r |= Mono_Posix_MlockallFlags_MCL_FUTURE;
+#endif /* ndef MCL_FUTURE */
+	return 0;
+}
+
+int Mono_Posix_FromMremapFlags (guint64 x, guint64 *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_MremapFlags_MREMAP_MAYMOVE) == Mono_Posix_MremapFlags_MREMAP_MAYMOVE)
+#ifdef MREMAP_MAYMOVE
+		*r |= MREMAP_MAYMOVE;
+#else /* def MREMAP_MAYMOVE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MREMAP_MAYMOVE */
+	return 0;
+}
+
+int Mono_Posix_ToMremapFlags (guint64 x, guint64 *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef MREMAP_MAYMOVE
+	if ((x & MREMAP_MAYMOVE) == MREMAP_MAYMOVE)
+		*r |= Mono_Posix_MremapFlags_MREMAP_MAYMOVE;
+#endif /* ndef MREMAP_MAYMOVE */
+	return 0;
+}
+