Use XLAT macro

Automatically convert all xlat structures to XLAT form
using the following sed regexp:
s/^[[:space:]]*{[[:space:]]*\([^",}[:space:]]\+\)[[:space:]]*,[[:space:]]*"\1",\?[[:space:]]*}[[:space:]]*/\tXLAT(\1)/

21 files changed, 1567 insertions, 1567 deletions

diff --git a/bjm.c b/bjm.c
index cd7dc13..366eefc 100644
--- a/bjm.c
+++ b/bjm.c
@@ -70,23 +70,23 @@ struct module_info
 };
 
 static const struct xlat which[] = {
-	{ 0,		"0"		},
-	{ QM_MODULES,	"QM_MODULES"	},
-	{ QM_DEPS,	"QM_DEPS"	},
-	{ QM_REFS,	"QM_REFS"	},
-	{ QM_SYMBOLS,	"QM_SYMBOLS"	},
-	{ QM_INFO,	"QM_INFO"	},
+	XLAT(0),
+	XLAT(QM_MODULES),
+	XLAT(QM_DEPS),
+	XLAT(QM_REFS),
+	XLAT(QM_SYMBOLS),
+	XLAT(QM_INFO),
 	{ 0,		NULL		},
 };
 
 static const struct xlat modflags[] = {
-	{ MOD_UNINITIALIZED,	"MOD_UNINITIALIZED"	},
-	{ MOD_RUNNING,		"MOD_RUNNING"		},
-	{ MOD_DELETED,		"MOD_DELETED"		},
-	{ MOD_AUTOCLEAN,	"MOD_AUTOCLEAN"		},
-	{ MOD_VISITED,		"MOD_VISITED"		},
-	{ MOD_USED_ONCE,	"MOD_USED_ONCE"		},
-	{ MOD_JUST_FREED,	"MOD_JUST_FREED"	},
+	XLAT(MOD_UNINITIALIZED),
+	XLAT(MOD_RUNNING),
+	XLAT(MOD_DELETED),
+	XLAT(MOD_AUTOCLEAN),
+	XLAT(MOD_VISITED),
+	XLAT(MOD_USED_ONCE),
+	XLAT(MOD_JUST_FREED),
 	{ 0,			NULL			},
 };
 
diff --git a/block.c b/block.c
index 374002e..f40b75c 100644
--- a/block.c
+++ b/block.c
@@ -80,8 +80,8 @@ struct blk_user_trace_setup {
 #endif
 
 static const struct xlat blkpg_ops[] = {
-	{ BLKPG_ADD_PARTITION,	"BLKPG_ADD_PARTITION", },
-	{ BLKPG_DEL_PARTITION,	"BLKPG_DEL_PARTITION", },
+	XLAT(BLKPG_ADD_PARTITION),
+	XLAT(BLKPG_DEL_PARTITION),
 	{ 0,			NULL },
 };
 
diff --git a/desc.c b/desc.c
index 3ccf422..124a066 100644
--- a/desc.c
+++ b/desc.c
@@ -39,118 +39,118 @@
 #endif
 
 static const struct xlat fcntlcmds[] = {
-	{ F_DUPFD,	"F_DUPFD"	},
-	{ F_GETFD,	"F_GETFD"	},
-	{ F_SETFD,	"F_SETFD"	},
-	{ F_GETFL,	"F_GETFL"	},
-	{ F_SETFL,	"F_SETFL"	},
-	{ F_GETLK,	"F_GETLK"	},
-	{ F_SETLK,	"F_SETLK"	},
-	{ F_SETLKW,	"F_SETLKW"	},
-	{ F_GETOWN,	"F_GETOWN"	},
-	{ F_SETOWN,	"F_SETOWN"	},
+	XLAT(F_DUPFD),
+	XLAT(F_GETFD),
+	XLAT(F_SETFD),
+	XLAT(F_GETFL),
+	XLAT(F_SETFL),
+	XLAT(F_GETLK),
+	XLAT(F_SETLK),
+	XLAT(F_SETLKW),
+	XLAT(F_GETOWN),
+	XLAT(F_SETOWN),
 #ifdef F_RSETLK
-	{ F_RSETLK,	"F_RSETLK"	},
+	XLAT(F_RSETLK),
 #endif
 #ifdef F_RSETLKW
-	{ F_RSETLKW,	"F_RSETLKW"	},
+	XLAT(F_RSETLKW),
 #endif
 #ifdef F_RGETLK
-	{ F_RGETLK,	"F_RGETLK"	},
+	XLAT(F_RGETLK),
 #endif
 #ifdef F_CNVT
-	{ F_CNVT,	"F_CNVT"	},
+	XLAT(F_CNVT),
 #endif
 #ifdef F_SETSIG
-	{ F_SETSIG,	"F_SETSIG"	},
+	XLAT(F_SETSIG),
 #endif
 #ifdef F_GETSIG
-	{ F_GETSIG,	"F_GETSIG"	},
+	XLAT(F_GETSIG),
 #endif
 #ifdef F_CHKFL
-	{ F_CHKFL,	"F_CHKFL"	},
+	XLAT(F_CHKFL),
 #endif
 #ifdef F_DUP2FD
-	{ F_DUP2FD,	"F_DUP2FD"	},
+	XLAT(F_DUP2FD),
 #endif
 #ifdef F_ALLOCSP
-	{ F_ALLOCSP,	"F_ALLOCSP"	},
+	XLAT(F_ALLOCSP),
 #endif
 #ifdef F_ISSTREAM
-	{ F_ISSTREAM,	"F_ISSTREAM"	},
+	XLAT(F_ISSTREAM),
 #endif
 #ifdef F_PRIV
-	{ F_PRIV,	"F_PRIV"	},
+	XLAT(F_PRIV),
 #endif
 #ifdef F_NPRIV
-	{ F_NPRIV,	"F_NPRIV"	},
+	XLAT(F_NPRIV),
 #endif
 #ifdef F_QUOTACL
-	{ F_QUOTACL,	"F_QUOTACL"	},
+	XLAT(F_QUOTACL),
 #endif
 #ifdef F_BLOCKS
-	{ F_BLOCKS,	"F_BLOCKS"	},
+	XLAT(F_BLOCKS),
 #endif
 #ifdef F_BLKSIZE
-	{ F_BLKSIZE,	"F_BLKSIZE"	},
+	XLAT(F_BLKSIZE),
 #endif
 #ifdef F_GETOWN
-	{ F_GETOWN,	"F_GETOWN"	},
+	XLAT(F_GETOWN),
 #endif
 #ifdef F_SETOWN
-	{ F_SETOWN,	"F_SETOWN"	},
+	XLAT(F_SETOWN),
 #endif
 #ifdef F_REVOKE
-	{ F_REVOKE,	"F_REVOKE"	},
+	XLAT(F_REVOKE),
 #endif
 #ifdef F_SETLK
-	{ F_SETLK,	"F_SETLK"	},
+	XLAT(F_SETLK),
 #endif
 #ifdef F_SETLKW
-	{ F_SETLKW,	"F_SETLKW"	},
+	XLAT(F_SETLKW),
 #endif
 #ifdef F_FREESP
-	{ F_FREESP,	"F_FREESP"	},
+	XLAT(F_FREESP),
 #endif
 #ifdef F_GETLK
-	{ F_GETLK,	"F_GETLK"	},
+	XLAT(F_GETLK),
 #endif
 #ifdef F_SETLK64
-	{ F_SETLK64,	"F_SETLK64"	},
+	XLAT(F_SETLK64),
 #endif
 #ifdef F_SETLKW64
-	{ F_SETLKW64,	"F_SETLKW64"	},
+	XLAT(F_SETLKW64),
 #endif
 #ifdef F_FREESP64
-	{ F_FREESP64,	"F_FREESP64"	},
+	XLAT(F_FREESP64),
 #endif
 #ifdef F_GETLK64
-	{ F_GETLK64,	"F_GETLK64"	},
+	XLAT(F_GETLK64),
 #endif
 #ifdef F_SHARE
-	{ F_SHARE,	"F_SHARE"	},
+	XLAT(F_SHARE),
 #endif
 #ifdef F_UNSHARE
-	{ F_UNSHARE,	"F_UNSHARE"	},
+	XLAT(F_UNSHARE),
 #endif
 #ifdef F_SETLEASE
-	{ F_SETLEASE,	"F_SETLEASE"	},
+	XLAT(F_SETLEASE),
 #endif
 #ifdef F_GETLEASE
-	{ F_GETLEASE,	"F_GETLEASE"	},
+	XLAT(F_GETLEASE),
 #endif
 #ifdef F_NOTIFY
-	{ F_NOTIFY,	"F_NOTIFY"	},
+	XLAT(F_NOTIFY),
 #endif
 #ifdef F_DUPFD_CLOEXEC
-	{ F_DUPFD_CLOEXEC,"F_DUPFD_CLOEXEC"},
+	XLAT(F_DUPFD_CLOEXEC),
 #endif
 	{ 0,		NULL		},
 };
 
 static const struct xlat fdflags[] = {
 #ifdef FD_CLOEXEC
-	{ FD_CLOEXEC,	"FD_CLOEXEC"	},
+	XLAT(FD_CLOEXEC),
 #endif
 	{ 0,		NULL		},
 };
@@ -158,24 +158,24 @@ static const struct xlat fdflags[] = {
 #ifdef LOCK_SH
 
 static const struct xlat flockcmds[] = {
-	{ LOCK_SH,	"LOCK_SH"	},
-	{ LOCK_EX,	"LOCK_EX"	},
-	{ LOCK_NB,	"LOCK_NB"	},
-	{ LOCK_UN,	"LOCK_UN"	},
+	XLAT(LOCK_SH),
+	XLAT(LOCK_EX),
+	XLAT(LOCK_NB),
+	XLAT(LOCK_UN),
 	{ 0,		NULL		},
 };
 
 #endif /* LOCK_SH */
 
 static const struct xlat lockfcmds[] = {
-	{ F_RDLCK,	"F_RDLCK"	},
-	{ F_WRLCK,	"F_WRLCK"	},
-	{ F_UNLCK,	"F_UNLCK"	},
+	XLAT(F_RDLCK),
+	XLAT(F_WRLCK),
+	XLAT(F_UNLCK),
 #ifdef F_EXLCK
-	{ F_EXLCK,	"F_EXLCK"	},
+	XLAT(F_EXLCK),
 #endif
 #ifdef F_SHLCK
-	{ F_SHLCK,	"F_SHLCK"	},
+	XLAT(F_SHLCK),
 #endif
 	{ 0,		NULL		},
 };
@@ -183,25 +183,25 @@ static const struct xlat lockfcmds[] = {
 #ifdef F_NOTIFY
 static const struct xlat notifyflags[] = {
 #ifdef DN_ACCESS
-	{ DN_ACCESS,	"DN_ACCESS"	},
+	XLAT(DN_ACCESS),
 #endif
 #ifdef DN_MODIFY
-	{ DN_MODIFY,	"DN_MODIFY"	},
+	XLAT(DN_MODIFY),
 #endif
 #ifdef DN_CREATE
-	{ DN_CREATE,	"DN_CREATE"	},
+	XLAT(DN_CREATE),
 #endif
 #ifdef DN_DELETE
-	{ DN_DELETE,	"DN_DELETE"	},
+	XLAT(DN_DELETE),
 #endif
 #ifdef DN_RENAME
-	{ DN_RENAME,	"DN_RENAME"	},
+	XLAT(DN_RENAME),
 #endif
 #ifdef DN_ATTRIB
-	{ DN_ATTRIB,	"DN_ATTRIB"	},
+	XLAT(DN_ATTRIB),
 #endif
 #ifdef DN_MULTISHOT
-	{ DN_MULTISHOT,	"DN_MULTISHOT"	},
+	XLAT(DN_MULTISHOT),
 #endif
 	{ 0,		NULL		},
 };
@@ -209,13 +209,13 @@ static const struct xlat notifyflags[] = {
 
 static const struct xlat perf_event_open_flags[] = {
 #ifdef PERF_FLAG_FD_NO_GROUP
-	{ PERF_FLAG_FD_NO_GROUP,	"PERF_FLAG_FD_NO_GROUP"	},
+	XLAT(PERF_FLAG_FD_NO_GROUP),
 #endif
 #ifdef PERF_FLAG_FD_OUTPUT
-	{ PERF_FLAG_FD_OUTPUT,		"PERF_FLAG_FD_OUTPUT"	},
+	XLAT(PERF_FLAG_FD_OUTPUT),
 #endif
 #ifdef PERF_FLAG_PID_CGROUP
-	{ PERF_FLAG_PID_CGROUP,		"PERF_FLAG_PID_CGROUP"	},
+	XLAT(PERF_FLAG_PID_CGROUP),
 #endif
 	{ 0,				NULL			},
 };
@@ -655,56 +655,56 @@ sys_osf_select(struct tcb *tcp)
 
 static const struct xlat epollctls[] = {
 #ifdef EPOLL_CTL_ADD
-	{ EPOLL_CTL_ADD,	"EPOLL_CTL_ADD"	},
+	XLAT(EPOLL_CTL_ADD),
 #endif
 #ifdef EPOLL_CTL_MOD
-	{ EPOLL_CTL_MOD,	"EPOLL_CTL_MOD"	},
+	XLAT(EPOLL_CTL_MOD),
 #endif
 #ifdef EPOLL_CTL_DEL
-	{ EPOLL_CTL_DEL,	"EPOLL_CTL_DEL"	},
+	XLAT(EPOLL_CTL_DEL),
 #endif
 	{ 0,			NULL		}
 };
 
 static const struct xlat epollevents[] = {
 #ifdef EPOLLIN
-	{ EPOLLIN,	"EPOLLIN"	},
+	XLAT(EPOLLIN),
 #endif
 #ifdef EPOLLPRI
-	{ EPOLLPRI,	"EPOLLPRI"	},
+	XLAT(EPOLLPRI),
 #endif
 #ifdef EPOLLOUT
-	{ EPOLLOUT,	"EPOLLOUT"	},
+	XLAT(EPOLLOUT),
 #endif
 #ifdef EPOLLRDNORM
-	{ EPOLLRDNORM,	"EPOLLRDNORM"	},
+	XLAT(EPOLLRDNORM),
 #endif
 #ifdef EPOLLRDBAND
-	{ EPOLLRDBAND,	"EPOLLRDBAND"	},
+	XLAT(EPOLLRDBAND),
 #endif
 #ifdef EPOLLWRNORM
-	{ EPOLLWRNORM,	"EPOLLWRNORM"	},
+	XLAT(EPOLLWRNORM),
 #endif
 #ifdef EPOLLWRBAND
-	{ EPOLLWRBAND,	"EPOLLWRBAND"	},
+	XLAT(EPOLLWRBAND),
 #endif
 #ifdef EPOLLMSG
-	{ EPOLLMSG,	"EPOLLMSG"	},
+	XLAT(EPOLLMSG),
 #endif
 #ifdef EPOLLERR
-	{ EPOLLERR,	"EPOLLERR"	},
+	XLAT(EPOLLERR),
 #endif
 #ifdef EPOLLHUP
-	{ EPOLLHUP,	"EPOLLHUP"	},
+	XLAT(EPOLLHUP),
 #endif
 #ifdef EPOLLRDHUP
-	{ EPOLLRDHUP,	"EPOLLRDHUP"	},
+	XLAT(EPOLLRDHUP),
 #endif
 #ifdef EPOLLONESHOT
-	{ EPOLLONESHOT,	"EPOLLONESHOT"	},
+	XLAT(EPOLLONESHOT),
 #endif
 #ifdef EPOLLET
-	{ EPOLLET,	"EPOLLET"	},
+	XLAT(EPOLLET),
 #endif
 	{ 0,		NULL		}
 };
@@ -718,10 +718,10 @@ sys_epoll_create(struct tcb *tcp)
 
 static const struct xlat epollflags[] = {
 #ifdef EPOLL_CLOEXEC
-	{ EPOLL_CLOEXEC,	"EPOLL_CLOEXEC"	},
+	XLAT(EPOLL_CLOEXEC),
 #endif
 #ifdef EPOLL_NONBLOCK
-	{ EPOLL_NONBLOCK,	"EPOLL_NONBLOCK"	},
+	XLAT(EPOLL_NONBLOCK),
 #endif
 	{ 0,		NULL		}
 };
diff --git a/file.c b/file.c
index 25152f0..afb1951 100644
--- a/file.c
+++ b/file.c
@@ -212,42 +212,42 @@ struct kernel_dirent {
 };
 
 const struct xlat open_access_modes[] = {
-	{ O_RDONLY,	"O_RDONLY"	},
-	{ O_WRONLY,	"O_WRONLY"	},
-	{ O_RDWR,	"O_RDWR"	},
+	XLAT(O_RDONLY),
+	XLAT(O_WRONLY),
+	XLAT(O_RDWR),
 #ifdef O_ACCMODE
-	{ O_ACCMODE,	"O_ACCMODE"	},
+	XLAT(O_ACCMODE),
 #endif
 	{ 0,		NULL		},
 };
 
 const struct xlat open_mode_flags[] = {
-	{ O_CREAT,	"O_CREAT"	},
-	{ O_EXCL,	"O_EXCL"	},
-	{ O_NOCTTY,	"O_NOCTTY"	},
-	{ O_TRUNC,	"O_TRUNC"	},
-	{ O_APPEND,	"O_APPEND"	},
-	{ O_NONBLOCK,	"O_NONBLOCK"	},
+	XLAT(O_CREAT),
+	XLAT(O_EXCL),
+	XLAT(O_NOCTTY),
+	XLAT(O_TRUNC),
+	XLAT(O_APPEND),
+	XLAT(O_NONBLOCK),
 #ifdef O_SYNC
-	{ O_SYNC,	"O_SYNC"	},
+	XLAT(O_SYNC),
 #endif
 #ifdef O_ASYNC
-	{ O_ASYNC,	"O_ASYNC"	},
+	XLAT(O_ASYNC),
 #endif
 #ifdef O_DSYNC
-	{ O_DSYNC,	"O_DSYNC"	},
+	XLAT(O_DSYNC),
 #endif
 #ifdef O_RSYNC
-	{ O_RSYNC,	"O_RSYNC"	},
+	XLAT(O_RSYNC),
 #endif
 #if defined(O_NDELAY) && (O_NDELAY != O_NONBLOCK)
-	{ O_NDELAY,	"O_NDELAY"	},
+	XLAT(O_NDELAY),
 #endif
 #ifdef O_PRIV
-	{ O_PRIV,	"O_PRIV"	},
+	XLAT(O_PRIV),
 #endif
 #ifdef O_DIRECT
-	{ O_DIRECT,	"O_DIRECT"	},
+	XLAT(O_DIRECT),
 #endif
 #ifdef O_LARGEFILE
 # if O_LARGEFILE == 0		/* biarch platforms in 64-bit mode */
@@ -259,68 +259,68 @@ const struct xlat open_mode_flags[] = {
 #  endif
 # endif
 # ifdef O_LARGEFILE
-	{ O_LARGEFILE,	"O_LARGEFILE"	},
+	XLAT(O_LARGEFILE),
 # endif
 #endif
 #ifdef O_DIRECTORY
-	{ O_DIRECTORY,	"O_DIRECTORY"	},
+	XLAT(O_DIRECTORY),
 #endif
 #ifdef O_NOFOLLOW
-	{ O_NOFOLLOW,	"O_NOFOLLOW"	},
+	XLAT(O_NOFOLLOW),
 #endif
 #ifdef O_NOATIME
-	{ O_NOATIME,	"O_NOATIME"	},
+	XLAT(O_NOATIME),
 #endif
 #ifdef O_CLOEXEC
-	{ O_CLOEXEC,	"O_CLOEXEC"	},
+	XLAT(O_CLOEXEC),
 #endif
 #ifdef O_PATH
-	{ O_PATH,	"O_PATH"	},
+	XLAT(O_PATH),
 #endif
 #ifdef FNDELAY
-	{ FNDELAY,	"FNDELAY"	},
+	XLAT(FNDELAY),
 #endif
 #ifdef FAPPEND
-	{ FAPPEND,	"FAPPEND"	},
+	XLAT(FAPPEND),
 #endif
 #ifdef FMARK
-	{ FMARK,	"FMARK"		},
+	XLAT(FMARK),
 #endif
 #ifdef FDEFER
-	{ FDEFER,	"FDEFER"	},
+	XLAT(FDEFER),
 #endif
 #ifdef FASYNC
-	{ FASYNC,	"FASYNC"	},
+	XLAT(FASYNC),
 #endif
 #ifdef FSHLOCK
-	{ FSHLOCK,	"FSHLOCK"	},
+	XLAT(FSHLOCK),
 #endif
 #ifdef FEXLOCK
-	{ FEXLOCK,	"FEXLOCK"	},
+	XLAT(FEXLOCK),
 #endif
 #ifdef FCREAT
-	{ FCREAT,	"FCREAT"	},
+	XLAT(FCREAT),
 #endif
 #ifdef FTRUNC
-	{ FTRUNC,	"FTRUNC"	},
+	XLAT(FTRUNC),
 #endif
 #ifdef FEXCL
-	{ FEXCL,	"FEXCL"		},
+	XLAT(FEXCL),
 #endif
 #ifdef FNBIO
-	{ FNBIO,	"FNBIO"		},
+	XLAT(FNBIO),
 #endif
 #ifdef FSYNC
-	{ FSYNC,	"FSYNC"		},
+	XLAT(FSYNC),
 #endif
 #ifdef FNOCTTY
-	{ FNOCTTY,	"FNOCTTY"	},
+	XLAT(FNOCTTY),
 #endif
 #ifdef O_SHLOCK
-	{ O_SHLOCK,	"O_SHLOCK"	},
+	XLAT(O_SHLOCK),
 #endif
 #ifdef O_EXLOCK
-	{ O_EXLOCK,	"O_EXLOCK"	},
+	XLAT(O_EXLOCK),
 #endif
 	{ 0,		NULL		},
 };
@@ -468,15 +468,15 @@ sys_creat(struct tcb *tcp)
 }
 
 static const struct xlat access_flags[] = {
-	{ F_OK,		"F_OK",		},
-	{ R_OK,		"R_OK"		},
-	{ W_OK,		"W_OK"		},
-	{ X_OK,		"X_OK"		},
+	XLAT(F_OK),
+	XLAT(R_OK),
+	XLAT(W_OK),
+	XLAT(X_OK),
 #ifdef EFF_ONLY_OK
-	{ EFF_ONLY_OK,	"EFF_ONLY_OK"	},
+	XLAT(EFF_ONLY_OK),
 #endif
 #ifdef EX_OK
-	{ EX_OK,	"EX_OK"		},
+	XLAT(EX_OK),
 #endif
 	{ 0,		NULL		},
 };
@@ -516,14 +516,14 @@ sys_umask(struct tcb *tcp)
 }
 
 const struct xlat whence_codes[] = {
-	{ SEEK_SET,	"SEEK_SET"	},
-	{ SEEK_CUR,	"SEEK_CUR"	},
-	{ SEEK_END,	"SEEK_END"	},
+	XLAT(SEEK_SET),
+	XLAT(SEEK_CUR),
+	XLAT(SEEK_END),
 #ifdef SEEK_DATA
-	{ SEEK_DATA,	"SEEK_DATA"	},
+	XLAT(SEEK_DATA),
 #endif
 #ifdef SEEK_HOLE
-	{ SEEK_HOLE,	"SEEK_HOLE"	},
+	XLAT(SEEK_HOLE),
 #endif
 	{ 0,		NULL		},
 };
@@ -668,13 +668,13 @@ sys_ftruncate64(struct tcb *tcp)
 /* several stats */
 
 static const struct xlat modetypes[] = {
-	{ S_IFREG,	"S_IFREG"	},
-	{ S_IFSOCK,	"S_IFSOCK"	},
-	{ S_IFIFO,	"S_IFIFO"	},
-	{ S_IFLNK,	"S_IFLNK"	},
-	{ S_IFDIR,	"S_IFDIR"	},
-	{ S_IFBLK,	"S_IFBLK"	},
-	{ S_IFCHR,	"S_IFCHR"	},
+	XLAT(S_IFREG),
+	XLAT(S_IFSOCK),
+	XLAT(S_IFIFO),
+	XLAT(S_IFLNK),
+	XLAT(S_IFDIR),
+	XLAT(S_IFBLK),
+	XLAT(S_IFCHR),
 	{ 0,		NULL		},
 };
 
@@ -1323,11 +1323,11 @@ sys_stat64(struct tcb *tcp)
 #endif
 
 static const struct xlat at_flags[] = {
-	{ AT_SYMLINK_NOFOLLOW,	"AT_SYMLINK_NOFOLLOW"	},
-	{ AT_REMOVEDIR,		"AT_REMOVEDIR"		},
-	{ AT_SYMLINK_FOLLOW,	"AT_SYMLINK_FOLLOW"	},
-	{ AT_NO_AUTOMOUNT,	"AT_NO_AUTOMOUNT"	},
-	{ AT_EMPTY_PATH,	"AT_EMPTY_PATH"		},
+	XLAT(AT_SYMLINK_NOFOLLOW),
+	XLAT(AT_REMOVEDIR),
+	XLAT(AT_SYMLINK_FOLLOW),
+	XLAT(AT_NO_AUTOMOUNT),
+	XLAT(AT_EMPTY_PATH),
 	{ 0,			NULL			}
 };
 
@@ -1497,22 +1497,22 @@ sys_xmknod(struct tcb *tcp)
 
 static const struct xlat aclcmds[] = {
 #  ifdef SETACL
-	{ SETACL,	"SETACL"	},
+	XLAT(SETACL),
 #  endif
 #  ifdef GETACL
-	{ GETACL,	"GETACL"	},
+	XLAT(GETACL),
 #  endif
 #  ifdef GETACLCNT
-	{ GETACLCNT,	"GETACLCNT"	},
+	XLAT(GETACLCNT),
 #  endif
 #  ifdef ACL_GET
-	{ ACL_GET,	"ACL_GET"	},
+	XLAT(ACL_GET),
 #  endif
 #  ifdef ACL_SET
-	{ ACL_SET,	"ACL_SET"	},
+	XLAT(ACL_SET),
 #  endif
 #  ifdef ACL_CNT
-	{ ACL_CNT,	"ACL_CNT"	},
+	XLAT(ACL_CNT),
 #  endif
 	{ 0,		NULL		},
 };
@@ -1558,13 +1558,13 @@ sys_facl(struct tcb *tcp)
 
 static const struct xlat aclipc[] = {
 #  ifdef IPC_SHM
-	{ IPC_SHM,	"IPC_SHM"	},
+	XLAT(IPC_SHM),
 #  endif
 #  ifdef IPC_SEM
-	{ IPC_SEM,	"IPC_SEM"	},
+	XLAT(IPC_SEM),
 #  endif
 #  ifdef IPC_MSG
-	{ IPC_MSG,	"IPC_MSG"	},
+	XLAT(IPC_MSG),
 #  endif
 	{ 0,		NULL		},
 };
@@ -2240,15 +2240,15 @@ sys_readdir(struct tcb *tcp)
 }
 
 static const struct xlat direnttypes[] = {
-	{ DT_UNKNOWN,	"DT_UNKNOWN"	},
-	{ DT_FIFO,	"DT_FIFO"	},
-	{ DT_CHR,	"DT_CHR"	},
-	{ DT_DIR,	"DT_DIR"	},
-	{ DT_BLK,	"DT_BLK"	},
-	{ DT_REG,	"DT_REG"	},
-	{ DT_LNK,	"DT_LNK"	},
-	{ DT_SOCK,	"DT_SOCK"	},
-	{ DT_WHT,	"DT_WHT"	},
+	XLAT(DT_UNKNOWN),
+	XLAT(DT_FIFO),
+	XLAT(DT_CHR),
+	XLAT(DT_DIR),
+	XLAT(DT_BLK),
+	XLAT(DT_REG),
+	XLAT(DT_LNK),
+	XLAT(DT_SOCK),
+	XLAT(DT_WHT),
 	{ 0,		NULL		},
 };
 
@@ -2464,8 +2464,8 @@ sys_aiocancel(struct tcb *tcp)
 
 static const struct xlat xattrflags[] = {
 #ifdef XATTR_CREATE
-	{ XATTR_CREATE,	 "XATTR_CREATE" },
-	{ XATTR_REPLACE, "XATTR_REPLACE" },
+	XLAT(XATTR_CREATE),
+	XLAT(XATTR_REPLACE),
 #endif
 	{ 0,		 NULL }
 };
@@ -2632,12 +2632,12 @@ sys_fremovexattr(struct tcb *tcp)
 }
 
 static const struct xlat advise[] = {
-	{ POSIX_FADV_NORMAL,		"POSIX_FADV_NORMAL"	},
-	{ POSIX_FADV_RANDOM,		"POSIX_FADV_RANDOM"	},
-	{ POSIX_FADV_SEQUENTIAL,	"POSIX_FADV_SEQUENTIAL"	},
-	{ POSIX_FADV_WILLNEED,		"POSIX_FADV_WILLNEED"	},
-	{ POSIX_FADV_DONTNEED,		"POSIX_FADV_DONTNEED"	},
-	{ POSIX_FADV_NOREUSE,		"POSIX_FADV_NOREUSE"	},
+	XLAT(POSIX_FADV_NORMAL),
+	XLAT(POSIX_FADV_RANDOM),
+	XLAT(POSIX_FADV_SEQUENTIAL),
+	XLAT(POSIX_FADV_WILLNEED),
+	XLAT(POSIX_FADV_DONTNEED),
+	XLAT(POSIX_FADV_NOREUSE),
 	{ 0,				NULL			}
 };
 
@@ -2672,9 +2672,9 @@ sys_fadvise64_64(struct tcb *tcp)
 }
 
 static const struct xlat sync_file_range_flags[] = {
-	{ SYNC_FILE_RANGE_WAIT_BEFORE,	"SYNC_FILE_RANGE_WAIT_BEFORE"	},
-	{ SYNC_FILE_RANGE_WRITE,	"SYNC_FILE_RANGE_WRITE"		},
-	{ SYNC_FILE_RANGE_WAIT_AFTER,	"SYNC_FILE_RANGE_WAIT_AFTER"	},
+	XLAT(SYNC_FILE_RANGE_WAIT_BEFORE),
+	XLAT(SYNC_FILE_RANGE_WRITE),
+	XLAT(SYNC_FILE_RANGE_WAIT_AFTER),
 	{ 0,				NULL				}
 };
 
@@ -2787,8 +2787,8 @@ sys_fallocate(struct tcb *tcp)
 # define SWAP_FLAG_DISCARD 0x10000
 #endif
 static const struct xlat swap_flags[] = {
-	{ SWAP_FLAG_PREFER,	"SWAP_FLAG_PREFER"	},
-	{ SWAP_FLAG_DISCARD,	"SWAP_FLAG_DISCARD"	},
+	XLAT(SWAP_FLAG_PREFER),
+	XLAT(SWAP_FLAG_DISCARD),
 	{ 0,			NULL			}
 };
 
diff --git a/io.c b/io.c
index b7bf832..2ed7fa5 100644
--- a/io.c
+++ b/io.c
@@ -319,16 +319,16 @@ sys_sendfile64(struct tcb *tcp)
 
 static const struct xlat splice_flags[] = {
 #ifdef SPLICE_F_MOVE
-	{ SPLICE_F_MOVE,     "SPLICE_F_MOVE"     },
+	XLAT(SPLICE_F_MOVE),
 #endif
 #ifdef SPLICE_F_NONBLOCK
-	{ SPLICE_F_NONBLOCK, "SPLICE_F_NONBLOCK" },
+	XLAT(SPLICE_F_NONBLOCK),
 #endif
 #ifdef SPLICE_F_MORE
-	{ SPLICE_F_MORE,     "SPLICE_F_MORE"     },
+	XLAT(SPLICE_F_MORE),
 #endif
 #ifdef SPLICE_F_GIFT
-	{ SPLICE_F_GIFT,     "SPLICE_F_GIFT"     },
+	XLAT(SPLICE_F_GIFT),
 #endif
 	{ 0,                 NULL                },
 };
diff --git a/ipc.c b/ipc.c
index 0b91a52..7f81cd3 100644
--- a/ipc.c
+++ b/ipc.c
@@ -64,81 +64,81 @@
 extern void printsigevent(struct tcb *tcp, long arg);
 
 static const struct xlat msgctl_flags[] = {
-	{ IPC_RMID,	"IPC_RMID"	},
-	{ IPC_SET,	"IPC_SET"	},
-	{ IPC_STAT,	"IPC_STAT"	},
-	{ IPC_INFO,	"IPC_INFO"	},
-	{ MSG_STAT,	"MSG_STAT"	},
-	{ MSG_INFO,	"MSG_INFO"	},
+	XLAT(IPC_RMID),
+	XLAT(IPC_SET),
+	XLAT(IPC_STAT),
+	XLAT(IPC_INFO),
+	XLAT(MSG_STAT),
+	XLAT(MSG_INFO),
 	{ 0,		NULL		},
 };
 
 static const struct xlat semctl_flags[] = {
-	{ IPC_RMID,	"IPC_RMID"	},
-	{ IPC_SET,	"IPC_SET"	},
-	{ IPC_STAT,	"IPC_STAT"	},
-	{ IPC_INFO,	"IPC_INFO"	},
-	{ SEM_STAT,	"SEM_STAT"	},
-	{ SEM_INFO,	"SEM_INFO"	},
-	{ GETPID,	"GETPID"	},
-	{ GETVAL,	"GETVAL"	},
-	{ GETALL,	"GETALL"	},
-	{ GETNCNT,	"GETNCNT"	},
-	{ GETZCNT,	"GETZCNT"	},
-	{ SETVAL,	"SETVAL"	},
-	{ SETALL,	"SETALL"	},
+	XLAT(IPC_RMID),
+	XLAT(IPC_SET),
+	XLAT(IPC_STAT),
+	XLAT(IPC_INFO),
+	XLAT(SEM_STAT),
+	XLAT(SEM_INFO),
+	XLAT(GETPID),
+	XLAT(GETVAL),
+	XLAT(GETALL),
+	XLAT(GETNCNT),
+	XLAT(GETZCNT),
+	XLAT(SETVAL),
+	XLAT(SETALL),
 	{ 0,		NULL		},
 };
 
 static const struct xlat shmctl_flags[] = {
-	{ IPC_RMID,	"IPC_RMID"	},
-	{ IPC_SET,	"IPC_SET"	},
-	{ IPC_STAT,	"IPC_STAT"	},
-	{ IPC_INFO,	"IPC_INFO"	},
-	{ SHM_STAT,	"SHM_STAT"	},
-	{ SHM_INFO,	"SHM_INFO"	},
+	XLAT(IPC_RMID),
+	XLAT(IPC_SET),
+	XLAT(IPC_STAT),
+	XLAT(IPC_INFO),
+	XLAT(SHM_STAT),
+	XLAT(SHM_INFO),
 #ifdef SHM_LOCK
-	{ SHM_LOCK,	"SHM_LOCK"	},
+	XLAT(SHM_LOCK),
 #endif
 #ifdef SHM_UNLOCK
-	{ SHM_UNLOCK,	"SHM_UNLOCK"	},
+	XLAT(SHM_UNLOCK),
 #endif
 	{ 0,		NULL		},
 };
 
 static const struct xlat resource_flags[] = {
-	{ IPC_CREAT,	"IPC_CREAT"	},
-	{ IPC_EXCL,	"IPC_EXCL"	},
-	{ IPC_NOWAIT,	"IPC_NOWAIT"	},
+	XLAT(IPC_CREAT),
+	XLAT(IPC_EXCL),
+	XLAT(IPC_NOWAIT),
 	{ 0,		NULL		},
 };
 
 static const struct xlat shm_resource_flags[] = {
-	{ IPC_CREAT,	"IPC_CREAT"	},
-	{ IPC_EXCL,	"IPC_EXCL"	},
+	XLAT(IPC_CREAT),
+	XLAT(IPC_EXCL),
 #ifdef SHM_HUGETLB
-	{ SHM_HUGETLB,	"SHM_HUGETLB"	},
+	XLAT(SHM_HUGETLB),
 #endif
 	{ 0,		NULL		},
 };
 
 static const struct xlat shm_flags[] = {
-	{ SHM_REMAP,	"SHM_REMAP"	},
-	{ SHM_RDONLY,	"SHM_RDONLY"	},
-	{ SHM_RND,	"SHM_RND"	},
+	XLAT(SHM_REMAP),
+	XLAT(SHM_RDONLY),
+	XLAT(SHM_RND),
 	{ 0,		NULL		},
 };
 
 static const struct xlat msg_flags[] = {
-	{ MSG_NOERROR,	"MSG_NOERROR"	},
-	{ MSG_EXCEPT,	"MSG_EXCEPT"	},
-	{ IPC_NOWAIT,	"IPC_NOWAIT"	},
+	XLAT(MSG_NOERROR),
+	XLAT(MSG_EXCEPT),
+	XLAT(IPC_NOWAIT),
 	{ 0,		NULL		},
 };
 
 static const struct xlat semop_flags[] = {
-	{ SEM_UNDO,	"SEM_UNDO"	},
-	{ IPC_NOWAIT,	"IPC_NOWAIT"	},
+	XLAT(SEM_UNDO),
+	XLAT(IPC_NOWAIT),
 	{ 0,		NULL		},
 };
 
diff --git a/loop.c b/loop.c
index a3f89e0..a94e13b 100644
--- a/loop.c
+++ b/loop.c
@@ -32,27 +32,27 @@
 #include <linux/loop.h>
 
 static const struct xlat loop_flags_options[] = {
-	{ LO_FLAGS_READ_ONLY,	"LO_FLAGS_READ_ONLY"	},
+	XLAT(LO_FLAGS_READ_ONLY),
 #if HAVE_DECL_LO_FLAGS_AUTOCLEAR
-	{ LO_FLAGS_AUTOCLEAR,	"LO_FLAGS_AUTOCLEAR"	},
+	XLAT(LO_FLAGS_AUTOCLEAR),
 #endif
 #if HAVE_DECL_LO_FLAGS_PARTSCAN
-	{ LO_FLAGS_PARTSCAN,	"LO_FLAGS_PARTSCAN"	},
+	XLAT(LO_FLAGS_PARTSCAN),
 #endif
 	{ 0,			NULL			},
 };
 
 static const struct xlat loop_crypt_type_options[] = {
-	{ LO_CRYPT_NONE,	"LO_CRYPT_NONE"		},
-	{ LO_CRYPT_XOR,		"LO_CRYPT_XOR"		},
-	{ LO_CRYPT_DES,		"LO_CRYPT_DES"		},
-	{ LO_CRYPT_FISH2,	"LO_CRYPT_FISH2"	},
-	{ LO_CRYPT_BLOW,	"LO_CRYPT_BLOW"		},
-	{ LO_CRYPT_CAST128,	"LO_CRYPT_CAST128"	},
-	{ LO_CRYPT_IDEA,	"LO_CRYPT_IDEA"		},
-	{ LO_CRYPT_DUMMY,	"LO_CRYPT_DUMMY"	},
-	{ LO_CRYPT_SKIPJACK,	"LO_CRYPT_SKIPJACK"	},
-	{ LO_CRYPT_CRYPTOAPI,	"LO_CRYPT_CRYPTOAPI"	},
+	XLAT(LO_CRYPT_NONE),
+	XLAT(LO_CRYPT_XOR),
+	XLAT(LO_CRYPT_DES),
+	XLAT(LO_CRYPT_FISH2),
+	XLAT(LO_CRYPT_BLOW),
+	XLAT(LO_CRYPT_CAST128),
+	XLAT(LO_CRYPT_IDEA),
+	XLAT(LO_CRYPT_DUMMY),
+	XLAT(LO_CRYPT_SKIPJACK),
+	XLAT(LO_CRYPT_CRYPTOAPI),
 	{ 0,			NULL			},
 };
 
diff --git a/mem.c b/mem.c
index 2c51cc7..6d2145c 100644
--- a/mem.c
+++ b/mem.c
@@ -60,46 +60,46 @@ sys_brk(struct tcb *tcp)
 }
 
 static const struct xlat mmap_prot[] = {
-	{ PROT_NONE,	"PROT_NONE",	},
-	{ PROT_READ,	"PROT_READ"	},
-	{ PROT_WRITE,	"PROT_WRITE"	},
-	{ PROT_EXEC,	"PROT_EXEC"	},
+	XLAT(PROT_NONE),
+	XLAT(PROT_READ),
+	XLAT(PROT_WRITE),
+	XLAT(PROT_EXEC),
 #ifdef PROT_SEM
-	{ PROT_SEM,	"PROT_SEM"	},
+	XLAT(PROT_SEM),
 #endif
 #ifdef PROT_GROWSDOWN
-	{ PROT_GROWSDOWN,"PROT_GROWSDOWN"},
+	XLAT(PROT_GROWSDOWN),
 #endif
 #ifdef PROT_GROWSUP
-	{ PROT_GROWSUP, "PROT_GROWSUP"	},
+	XLAT(PROT_GROWSUP),
 #endif
 #ifdef PROT_SAO
-	{ PROT_SAO,	"PROT_SAO"	},
+	XLAT(PROT_SAO),
 #endif
 	{ 0,		NULL		},
 };
 
 static const struct xlat mmap_flags[] = {
-	{ MAP_SHARED,	"MAP_SHARED"	},
-	{ MAP_PRIVATE,	"MAP_PRIVATE"	},
-	{ MAP_FIXED,	"MAP_FIXED"	},
+	XLAT(MAP_SHARED),
+	XLAT(MAP_PRIVATE),
+	XLAT(MAP_FIXED),
 #ifdef MAP_ANONYMOUS
-	{ MAP_ANONYMOUS,"MAP_ANONYMOUS"	},
+	XLAT(MAP_ANONYMOUS),
 #endif
 #ifdef MAP_32BIT
-	{ MAP_32BIT,	"MAP_32BIT"	},
+	XLAT(MAP_32BIT),
 #endif
 #ifdef MAP_RENAME
-	{ MAP_RENAME,	"MAP_RENAME"	},
+	XLAT(MAP_RENAME),
 #endif
 #ifdef MAP_NORESERVE
-	{ MAP_NORESERVE,"MAP_NORESERVE"	},
+	XLAT(MAP_NORESERVE),
 #endif
 #ifdef MAP_POPULATE
-	{ MAP_POPULATE, "MAP_POPULATE" },
+	XLAT(MAP_POPULATE),
 #endif
 #ifdef MAP_NONBLOCK
-	{ MAP_NONBLOCK, "MAP_NONBLOCK" },
+	XLAT(MAP_NONBLOCK),
 #endif
 	/*
 	 * XXX - this was introduced in SunOS 4.x to distinguish between
@@ -129,47 +129,47 @@ static const struct xlat mmap_flags[] = {
 	 * and calls with it as "mmap()".
 	 */
 #ifdef _MAP_NEW
-	{ _MAP_NEW,	"_MAP_NEW"	},
+	XLAT(_MAP_NEW),
 #endif
 #ifdef MAP_GROWSDOWN
-	{ MAP_GROWSDOWN,"MAP_GROWSDOWN"	},
+	XLAT(MAP_GROWSDOWN),
 #endif
 #ifdef MAP_DENYWRITE
-	{ MAP_DENYWRITE,"MAP_DENYWRITE"	},
+	XLAT(MAP_DENYWRITE),
 #endif
 #ifdef MAP_EXECUTABLE
-	{ MAP_EXECUTABLE,"MAP_EXECUTABLE"},
+	XLAT(MAP_EXECUTABLE),
 #endif
 #ifdef MAP_INHERIT
-	{ MAP_INHERIT,	"MAP_INHERIT"	},
+	XLAT(MAP_INHERIT),
 #endif
 #ifdef MAP_FILE
-	{ MAP_FILE,	"MAP_FILE"	},
+	XLAT(MAP_FILE),
 #endif
 #ifdef MAP_LOCKED
-	{ MAP_LOCKED,	"MAP_LOCKED"	},
+	XLAT(MAP_LOCKED),
 #endif
 	/* FreeBSD ones */
 #if defined(MAP_ANON) && (!defined(MAP_ANONYMOUS) || MAP_ANON != MAP_ANONYMOUS)
-	{ MAP_ANON,	"MAP_ANON"	},
+	XLAT(MAP_ANON),
 #endif
 #ifdef MAP_HASSEMAPHORE
-	{ MAP_HASSEMAPHORE,"MAP_HASSEMAPHORE"},
+	XLAT(MAP_HASSEMAPHORE),
 #endif
 #ifdef MAP_STACK
-	{ MAP_STACK,	"MAP_STACK"	},
+	XLAT(MAP_STACK),
 #endif
 #ifdef MAP_HUGETLB
-	{ MAP_HUGETLB,	"MAP_HUGETLB"	},
+	XLAT(MAP_HUGETLB),
 #endif
 #if defined MAP_UNINITIALIZED && MAP_UNINITIALIZED > 0
-	{ MAP_UNINITIALIZED,"MAP_UNINITIALIZED"},
+	XLAT(MAP_UNINITIALIZED),
 #endif
 #ifdef MAP_NOSYNC
-	{ MAP_NOSYNC,	"MAP_NOSYNC"	},
+	XLAT(MAP_NOSYNC),
 #endif
 #ifdef MAP_NOCORE
-	{ MAP_NOCORE,	"MAP_NOCORE"	},
+	XLAT(MAP_NOCORE),
 #endif
 	{ 0,		NULL		},
 };
@@ -322,9 +322,9 @@ sys_mprotect(struct tcb *tcp)
 }
 
 static const struct xlat mremap_flags[] = {
-	{ MREMAP_MAYMOVE,	"MREMAP_MAYMOVE"	},
+	XLAT(MREMAP_MAYMOVE),
 #ifdef MREMAP_FIXED
-	{ MREMAP_FIXED,		"MREMAP_FIXED"		},
+	XLAT(MREMAP_FIXED),
 #endif
 	{ 0,			NULL			}
 };
@@ -347,52 +347,52 @@ sys_mremap(struct tcb *tcp)
 
 static const struct xlat madvise_cmds[] = {
 #ifdef MADV_NORMAL
-	{ MADV_NORMAL,		"MADV_NORMAL" },
+	XLAT(MADV_NORMAL),
 #endif
 #ifdef MADV_RANDOM
-	{ MADV_RANDOM,		"MADV_RANDOM" },
+	XLAT(MADV_RANDOM),
 #endif
 #ifdef MADV_SEQUENTIAL
-	{ MADV_SEQUENTIAL,	"MADV_SEQUENTIAL" },
+	XLAT(MADV_SEQUENTIAL),
 #endif
 #ifdef MADV_WILLNEED
-	{ MADV_WILLNEED,	"MADV_WILLNEED" },
+	XLAT(MADV_WILLNEED),
 #endif
 #ifdef MADV_DONTNEED
-	{ MADV_DONTNEED,	"MADV_DONTNEED" },
+	XLAT(MADV_DONTNEED),
 #endif
 #ifdef MADV_REMOVE
-	{ MADV_REMOVE,		"MADV_REMOVE" },
+	XLAT(MADV_REMOVE),
 #endif
 #ifdef MADV_DONTFORK
-	{ MADV_DONTFORK,	"MADV_DONTFORK" },
+	XLAT(MADV_DONTFORK),
 #endif
 #ifdef MADV_DOFORK
-	{ MADV_DOFORK,		"MADV_DOFORK" },
+	XLAT(MADV_DOFORK),
 #endif
 #ifdef MADV_HWPOISON
-	{ MADV_HWPOISON,	"MADV_HWPOISON" },
+	XLAT(MADV_HWPOISON),
 #endif
 #ifdef MADV_SOFT_OFFLINE
-	{ MADV_SOFT_OFFLINE,	"MADV_SOFT_OFFLINE" },
+	XLAT(MADV_SOFT_OFFLINE),
 #endif
 #ifdef MADV_MERGEABLE
-	{ MADV_MERGEABLE,	"MADV_MERGEABLE" },
+	XLAT(MADV_MERGEABLE),
 #endif
 #ifdef MADV_UNMERGEABLE
-	{ MADV_UNMERGEABLE,	"MADV_UNMERGEABLE" },
+	XLAT(MADV_UNMERGEABLE),
 #endif
 #ifdef MADV_HUGEPAGE
-	{ MADV_HUGEPAGE,	"MADV_HUGEPAGE" },
+	XLAT(MADV_HUGEPAGE),
 #endif
 #ifdef MADV_NOHUGEPAGE
-	{ MADV_NOHUGEPAGE,	"MADV_NOHUGEPAGE" },
+	XLAT(MADV_NOHUGEPAGE),
 #endif
 #ifdef MADV_DONTDUMP
-	{ MADV_DONTDUMP,	"MADV_DONTDUMP" },
+	XLAT(MADV_DONTDUMP),
 #endif
 #ifdef MADV_DODUMP
-	{ MADV_DODUMP,		"MADV_DODUMP" },
+	XLAT(MADV_DODUMP),
 #endif
 	{ 0,			NULL },
 };
@@ -409,10 +409,10 @@ sys_madvise(struct tcb *tcp)
 
 static const struct xlat mlockall_flags[] = {
 #ifdef MCL_CURRENT
-	{ MCL_CURRENT,	"MCL_CURRENT" },
+	XLAT(MCL_CURRENT),
 #endif
 #ifdef MCL_FUTURE
-	{ MCL_FUTURE,	"MCL_FUTURE" },
+	XLAT(MCL_FUTURE),
 #endif
 	{ 0,		NULL}
 };
@@ -430,10 +430,10 @@ sys_mlockall(struct tcb *tcp)
 
 static const struct xlat mctl_sync[] = {
 #ifdef MS_SYNC
-	{ MS_SYNC,	"MS_SYNC"	},
+	XLAT(MS_SYNC),
 #endif
-	{ MS_ASYNC,	"MS_ASYNC"	},
-	{ MS_INVALIDATE,"MS_INVALIDATE"	},
+	XLAT(MS_ASYNC),
+	XLAT(MS_INVALIDATE),
 	{ 0,		NULL		},
 };
 
@@ -456,17 +456,17 @@ sys_msync(struct tcb *tcp)
 #ifdef MC_SYNC
 
 static const struct xlat mctl_funcs[] = {
-	{ MC_LOCK,	"MC_LOCK"	},
-	{ MC_LOCKAS,	"MC_LOCKAS"	},
-	{ MC_SYNC,	"MC_SYNC"	},
-	{ MC_UNLOCK,	"MC_UNLOCK"	},
-	{ MC_UNLOCKAS,	"MC_UNLOCKAS"	},
+	XLAT(MC_LOCK),
+	XLAT(MC_LOCKAS),
+	XLAT(MC_SYNC),
+	XLAT(MC_UNLOCK),
+	XLAT(MC_UNLOCKAS),
 	{ 0,		NULL		},
 };
 
 static const struct xlat mctl_lockas[] = {
-	{ MCL_CURRENT,	"MCL_CURRENT"	},
-	{ MCL_FUTURE,	"MCL_FUTURE"	},
+	XLAT(MCL_CURRENT),
+	XLAT(MCL_FUTURE),
 	{ 0,		NULL		},
 };
 
@@ -684,29 +684,29 @@ sys_remap_file_pages(struct tcb *tcp)
 #define MPOL_MF_MOVE_ALL (1<<2)
 
 static const struct xlat policies[] = {
-	{ MPOL_DEFAULT,		"MPOL_DEFAULT"		},
-	{ MPOL_PREFERRED,	"MPOL_PREFERRED"	},
-	{ MPOL_BIND,		"MPOL_BIND"		},
-	{ MPOL_INTERLEAVE,	"MPOL_INTERLEAVE"	},
+	XLAT(MPOL_DEFAULT),
+	XLAT(MPOL_PREFERRED),
+	XLAT(MPOL_BIND),
+	XLAT(MPOL_INTERLEAVE),
 	{ 0,			NULL			}
 };
 
 static const struct xlat mbindflags[] = {
-	{ MPOL_MF_STRICT,	"MPOL_MF_STRICT"	},
-	{ MPOL_MF_MOVE,		"MPOL_MF_MOVE"		},
-	{ MPOL_MF_MOVE_ALL,	"MPOL_MF_MOVE_ALL"	},
+	XLAT(MPOL_MF_STRICT),
+	XLAT(MPOL_MF_MOVE),
+	XLAT(MPOL_MF_MOVE_ALL),
 	{ 0,			NULL			}
 };
 
 static const struct xlat mempolicyflags[] = {
-	{ MPOL_F_NODE,		"MPOL_F_NODE"		},
-	{ MPOL_F_ADDR,		"MPOL_F_ADDR"		},
+	XLAT(MPOL_F_NODE),
+	XLAT(MPOL_F_ADDR),
 	{ 0,			NULL			}
 };
 
 static const struct xlat move_pages_flags[] = {
-	{ MPOL_MF_MOVE,		"MPOL_MF_MOVE"		},
-	{ MPOL_MF_MOVE_ALL,	"MPOL_MF_MOVE_ALL"	},
+	XLAT(MPOL_MF_MOVE),
+	XLAT(MPOL_MF_MOVE_ALL),
 	{ 0,			NULL			}
 };
 
diff --git a/mtd.c b/mtd.c
index 5385147..219f676 100644
--- a/mtd.c
+++ b/mtd.c
@@ -42,45 +42,45 @@
 #endif
 
 static const struct xlat mtd_mode_options[] = {
-	{ MTD_OPS_PLACE_OOB,	"MTD_OPS_PLACE_OOB"	},
-	{ MTD_OPS_AUTO_OOB,	"MTD_OPS_AUTO_OOB"	},
-	{ MTD_OPS_RAW,		"MTD_OPS_RAW"		},
+	XLAT(MTD_OPS_PLACE_OOB),
+	XLAT(MTD_OPS_AUTO_OOB),
+	XLAT(MTD_OPS_RAW),
 	{ 0,			NULL			},
 };
 
 static const struct xlat mtd_type_options[] = {
-	{ MTD_ABSENT,		"MTD_ABSENT"		},
-	{ MTD_RAM,		"MTD_RAM"		},
-	{ MTD_ROM,		"MTD_ROM"		},
-	{ MTD_NORFLASH,		"MTD_NORFLASH"		},
-	{ MTD_NANDFLASH,	"MTD_NANDFLASH"		},
-	{ MTD_DATAFLASH,	"MTD_DATAFLASH"		},
-	{ MTD_UBIVOLUME,	"MTD_UBIVOLUME"		},
-	{ MTD_MLCNANDFLASH,	"MTD_MLCNANDFLASH"	},
+	XLAT(MTD_ABSENT),
+	XLAT(MTD_RAM),
+	XLAT(MTD_ROM),
+	XLAT(MTD_NORFLASH),
+	XLAT(MTD_NANDFLASH),
+	XLAT(MTD_DATAFLASH),
+	XLAT(MTD_UBIVOLUME),
+	XLAT(MTD_MLCNANDFLASH),
 	{ 0,			NULL			},
 };
 
 static const struct xlat mtd_flags_options[] = {
-	{ MTD_WRITEABLE,	"MTD_WRITEABLE"		},
-	{ MTD_BIT_WRITEABLE,	"MTD_BIT_WRITEABLE"	},
-	{ MTD_NO_ERASE,		"MTD_NO_ERASE"		},
-	{ MTD_POWERUP_LOCK,	"MTD_POWERUP_LOCK"	},
+	XLAT(MTD_WRITEABLE),
+	XLAT(MTD_BIT_WRITEABLE),
+	XLAT(MTD_NO_ERASE),
+	XLAT(MTD_POWERUP_LOCK),
 	{ 0,			NULL			},
 };
 
 static const struct xlat mtd_otp_options[] = {
-	{ MTD_OTP_OFF,		"MTD_OTP_OFF"		},
-	{ MTD_OTP_FACTORY,	"MTD_OTP_FACTORY"	},
-	{ MTD_OTP_USER,		"MTD_OTP_USER"		},
+	XLAT(MTD_OTP_OFF),
+	XLAT(MTD_OTP_FACTORY),
+	XLAT(MTD_OTP_USER),
 	{ 0,			NULL			},
 };
 
 static const struct xlat mtd_nandecc_options[] = {
-	{ MTD_NANDECC_OFF,		"MTD_NANDECC_OFF"		},
-	{ MTD_NANDECC_PLACE,		"MTD_NANDECC_PLACE"		},
-	{ MTD_NANDECC_AUTOPLACE,	"MTD_NANDECC_AUTOPLACE"		},
-	{ MTD_NANDECC_PLACEONLY,	"MTD_NANDECC_PLACEONLY"		},
-	{ MTD_NANDECC_AUTOPL_USR,	"MTD_NANDECC_AUTOPL_USR"	},
+	XLAT(MTD_NANDECC_OFF),
+	XLAT(MTD_NANDECC_PLACE),
+	XLAT(MTD_NANDECC_AUTOPLACE),
+	XLAT(MTD_NANDECC_PLACEONLY),
+	XLAT(MTD_NANDECC_AUTOPL_USR),
 	{ 0,				NULL				},
 };
 
@@ -287,13 +287,13 @@ int mtd_ioctl(struct tcb *tcp, long code, long arg)
 }
 
 static const struct xlat ubi_volume_types[] = {
-	{ UBI_DYNAMIC_VOLUME,	"UBI_DYNAMIC_VOLUME"	},
-	{ UBI_STATIC_VOLUME,	"UBI_STATIC_VOLUME"	},
+	XLAT(UBI_DYNAMIC_VOLUME),
+	XLAT(UBI_STATIC_VOLUME),
 	{ 0,			NULL			},
 };
 
 static const struct xlat ubi_volume_props[] = {
-	{ UBI_VOL_PROP_DIRECT_WRITE,	"UBI_VOL_PROP_DIRECT_WRITE"	},
+	XLAT(UBI_VOL_PROP_DIRECT_WRITE),
 	{ 0,			NULL			},
 };
 
diff --git a/net.c b/net.c
index b6c8cc9..cb328be 100644
--- a/net.c
+++ b/net.c
@@ -96,282 +96,282 @@
 
 static const struct xlat domains[] = {
 #ifdef PF_UNSPEC
-	{ PF_UNSPEC,	"PF_UNSPEC"	},
+	XLAT(PF_UNSPEC),
 #endif
 #ifdef PF_LOCAL
-	{ PF_LOCAL,	"PF_LOCAL"	},
+	XLAT(PF_LOCAL),
 #endif
 #ifdef PF_UNIX
-	{ PF_UNIX,	"PF_UNIX"	},
+	XLAT(PF_UNIX),
 #endif
 #ifdef PF_INET
-	{ PF_INET,	"PF_INET"	},
+	XLAT(PF_INET),
 #endif
 #ifdef PF_AX25
-	{ PF_AX25,	"PF_AX25"	},
+	XLAT(PF_AX25),
 #endif
 #ifdef PF_IPX
-	{ PF_IPX,	"PF_IPX"	},
+	XLAT(PF_IPX),
 #endif
 #ifdef PF_APPLETALK
-	{ PF_APPLETALK,	"PF_APPLETALK"	},
+	XLAT(PF_APPLETALK),
 #endif
 #ifdef PF_NETROM
-	{ PF_NETROM,	"PF_NETROM"	},
+	XLAT(PF_NETROM),
 #endif
 #ifdef PF_BRIDGE
-	{ PF_BRIDGE,	"PF_BRIDGE"	},
+	XLAT(PF_BRIDGE),
 #endif
 #ifdef PF_ATMPVC
-	{ PF_ATMPVC,	"PF_ATMPVC"	},
+	XLAT(PF_ATMPVC),
 #endif
 #ifdef PF_X25
-	{ PF_X25,	"PF_X25"	},
+	XLAT(PF_X25),
 #endif
 #ifdef PF_INET6
-	{ PF_INET6,	"PF_INET6"	},
+	XLAT(PF_INET6),
 #endif
 #ifdef PF_ROSE
-	{ PF_ROSE,	"PF_ROSE"	},
+	XLAT(PF_ROSE),
 #endif
 #ifdef PF_DECnet
-	{ PF_DECnet,	"PF_DECnet"	},
+	XLAT(PF_DECnet),
 #endif
 #ifdef PF_NETBEUI
-	{ PF_NETBEUI,	"PF_NETBEUI"	},
+	XLAT(PF_NETBEUI),
 #endif
 #ifdef PF_SECURITY
-	{ PF_SECURITY,	"PF_SECURITY"	},
+	XLAT(PF_SECURITY),
 #endif
 #ifdef PF_KEY
-	{ PF_KEY,	"PF_KEY"	},
+	XLAT(PF_KEY),
 #endif
 #ifdef PF_NETLINK
-	{ PF_NETLINK,	"PF_NETLINK"	},
+	XLAT(PF_NETLINK),
 #endif
 #ifdef PF_ROUTE
-	{ PF_ROUTE,	"PF_ROUTE"	},
+	XLAT(PF_ROUTE),
 #endif
 #ifdef PF_PACKET
-	{ PF_PACKET,	"PF_PACKET"	},
+	XLAT(PF_PACKET),
 #endif
 #ifdef PF_ASH
-	{ PF_ASH,	"PF_ASH"	},
+	XLAT(PF_ASH),
 #endif
 #ifdef PF_ECONET
-	{ PF_ECONET,	"PF_ECONET"	},
+	XLAT(PF_ECONET),
 #endif
 #ifdef PF_ATMSVC
-	{ PF_ATMSVC,	"PF_ATMSVC"	},
+	XLAT(PF_ATMSVC),
 #endif
 #ifdef PF_RDS
-	{ PF_RDS,	"PF_RDS"	},
+	XLAT(PF_RDS),
 #endif
 #ifdef PF_SNA
-	{ PF_SNA,	"PF_SNA"	},
+	XLAT(PF_SNA),
 #endif
 #ifdef PF_IRDA
-	{ PF_IRDA,	"PF_IRDA"	},
+	XLAT(PF_IRDA),
 #endif
 #ifdef PF_PPPOX
-	{ PF_PPPOX,	"PF_PPPOX"	},
+	XLAT(PF_PPPOX),
 #endif
 #ifdef PF_WANPIPE
-	{ PF_WANPIPE,	"PF_WANPIPE"	},
+	XLAT(PF_WANPIPE),
 #endif
 #ifdef PF_LLC
-	{ PF_LLC,	"PF_LLC"	},
+	XLAT(PF_LLC),
 #endif
 #ifdef PF_CAN
-	{ PF_CAN,	"PF_CAN"	},
+	XLAT(PF_CAN),
 #endif
 #ifdef PF_TIPC
-	{ PF_TIPC,	"PF_TIPC"	},
+	XLAT(PF_TIPC),
 #endif
 #ifdef PF_BLUETOOTH
-	{ PF_BLUETOOTH,	"PF_BLUETOOTH"	},
+	XLAT(PF_BLUETOOTH),
 #endif
 #ifdef PF_IUCV
-	{ PF_IUCV,	"PF_IUCV"	},
+	XLAT(PF_IUCV),
 #endif
 #ifdef PF_RXRPC
-	{ PF_RXRPC,	"PF_RXRPC"	},
+	XLAT(PF_RXRPC),
 #endif
 #ifdef PF_ISDN
-	{ PF_ISDN,	"PF_ISDN"	},
+	XLAT(PF_ISDN),
 #endif
 #ifdef PF_PHONET
-	{ PF_PHONET,	"PF_PHONET"	},
+	XLAT(PF_PHONET),
 #endif
 #ifdef PF_IEEE802154
-	{ PF_IEEE802154,"PF_IEEE802154"	},
+	XLAT(PF_IEEE802154),
 #endif
 #ifdef PF_CAIF
-	{ PF_CAIF,	"PF_CAIF"	},
+	XLAT(PF_CAIF),
 #endif
 #ifdef PF_ALG
-	{ PF_ALG,	"PF_ALG"	},
+	XLAT(PF_ALG),
 #endif
 #ifdef PF_NFC
-	{ PF_NFC,	"PF_NFC"	},
+	XLAT(PF_NFC),
 #endif
 #ifdef PF_VSOCK
-	{ PF_VSOCK,	"PF_VSOCK"	},
+	XLAT(PF_VSOCK),
 #endif
 	{ 0,		NULL		},
 };
 const struct xlat addrfams[] = {
 #ifdef AF_UNSPEC
-	{ AF_UNSPEC,	"AF_UNSPEC"	},
+	XLAT(AF_UNSPEC),
 #endif
 #ifdef AF_LOCAL
-	{ AF_LOCAL,	"AF_LOCAL"	},
+	XLAT(AF_LOCAL),
 #endif
 #ifdef AF_UNIX
-	{ AF_UNIX,	"AF_UNIX"	},
+	XLAT(AF_UNIX),
 #endif
 #ifdef AF_INET
-	{ AF_INET,	"AF_INET"	},
+	XLAT(AF_INET),
 #endif
 #ifdef AF_AX25
-	{ AF_AX25,	"AF_AX25"	},
+	XLAT(AF_AX25),
 #endif
 #ifdef AF_IPX
-	{ AF_IPX,	"AF_IPX"	},
+	XLAT(AF_IPX),
 #endif
 #ifdef AF_APPLETALK
-	{ AF_APPLETALK,	"AF_APPLETALK"	},
+	XLAT(AF_APPLETALK),
 #endif
 #ifdef AF_NETROM
-	{ AF_NETROM,	"AF_NETROM"	},
+	XLAT(AF_NETROM),
 #endif
 #ifdef AF_BRIDGE
-	{ AF_BRIDGE,	"AF_BRIDGE"	},
+	XLAT(AF_BRIDGE),
 #endif
 #ifdef AF_ATMPVC
-	{ AF_ATMPVC,	"AF_ATMPVC"	},
+	XLAT(AF_ATMPVC),
 #endif
 #ifdef AF_X25
-	{ AF_X25,	"AF_X25"	},
+	XLAT(AF_X25),
 #endif
 #ifdef AF_INET6
-	{ AF_INET6,	"AF_INET6"	},
+	XLAT(AF_INET6),
 #endif
 #ifdef AF_ROSE
-	{ AF_ROSE,	"AF_ROSE"	},
+	XLAT(AF_ROSE),
 #endif
 #ifdef AF_DECnet
-	{ AF_DECnet,	"AF_DECnet"	},
+	XLAT(AF_DECnet),
 #endif
 #ifdef AF_NETBEUI
-	{ AF_NETBEUI,	"AF_NETBEUI"	},
+	XLAT(AF_NETBEUI),
 #endif
 #ifdef AF_SECURITY
-	{ AF_SECURITY,	"AF_SECURITY"	},
+	XLAT(AF_SECURITY),
 #endif
 #ifdef AF_KEY
-	{ AF_KEY,	"AF_KEY"	},
+	XLAT(AF_KEY),
 #endif
 #ifdef AF_NETLINK
-	{ AF_NETLINK,	"AF_NETLINK"	},
+	XLAT(AF_NETLINK),
 #endif
 #ifdef AF_ROUTE
-	{ AF_ROUTE,	"AF_ROUTE"	},
+	XLAT(AF_ROUTE),
 #endif
 #ifdef AF_PACKET
-	{ AF_PACKET,	"AF_PACKET"	},
+	XLAT(AF_PACKET),
 #endif
 #ifdef AF_ASH
-	{ AF_ASH,	"AF_ASH"	},
+	XLAT(AF_ASH),
 #endif
 #ifdef AF_ECONET
-	{ AF_ECONET,	"AF_ECONET"	},
+	XLAT(AF_ECONET),
 #endif
 #ifdef AF_ATMSVC
-	{ AF_ATMSVC,	"AF_ATMSVC"	},
+	XLAT(AF_ATMSVC),
 #endif
 #ifdef AF_RDS
-	{ AF_RDS,	"AF_RDS"	},
+	XLAT(AF_RDS),
 #endif
 #ifdef AF_SNA
-	{ AF_SNA,	"AF_SNA"	},
+	XLAT(AF_SNA),
 #endif
 #ifdef AF_IRDA
-	{ AF_IRDA,	"AF_IRDA"	},
+	XLAT(AF_IRDA),
 #endif
 #ifdef AF_PPPOX
-	{ AF_PPPOX,	"AF_PPPOX"	},
+	XLAT(AF_PPPOX),
 #endif
 #ifdef AF_WANPIPE
-	{ AF_WANPIPE,	"AF_WANPIPE"	},
+	XLAT(AF_WANPIPE),
 #endif
 #ifdef AF_LLC
-	{ AF_LLC,	"AF_LLC"	},
+	XLAT(AF_LLC),
 #endif
 #ifdef AF_CAN
-	{ AF_CAN,	"AF_CAN"	},
+	XLAT(AF_CAN),
 #endif
 #ifdef AF_TIPC
-	{ AF_TIPC,	"AF_TIPC"	},
+	XLAT(AF_TIPC),
 #endif
 #ifdef AF_BLUETOOTH
-	{ AF_BLUETOOTH,	"AF_BLUETOOTH"	},
+	XLAT(AF_BLUETOOTH),
 #endif
 #ifdef AF_IUCV
-	{ AF_IUCV,	"AF_IUCV"	},
+	XLAT(AF_IUCV),
 #endif
 #ifdef AF_RXRPC
-	{ AF_RXRPC,	"AF_RXRPC"	},
+	XLAT(AF_RXRPC),
 #endif
 #ifdef AF_ISDN
-	{ AF_ISDN,	"AF_ISDN"	},
+	XLAT(AF_ISDN),
 #endif
 #ifdef AF_PHONET
-	{ AF_PHONET,	"AF_PHONET"	},
+	XLAT(AF_PHONET),
 #endif
 #ifdef AF_IEEE802154
-	{ AF_IEEE802154,"AF_IEEE802154"	},
+	XLAT(AF_IEEE802154),
 #endif
 #ifdef AF_CAIF
-	{ AF_CAIF,	"AF_CAIF"	},
+	XLAT(AF_CAIF),
 #endif
 #ifdef AF_ALG
-	{ AF_ALG,	"AF_ALG"	},
+	XLAT(AF_ALG),
 #endif
 #ifdef AF_NFC
-	{ AF_NFC,	"AF_NFC"	},
+	XLAT(AF_NFC),
 #endif
 #ifdef AF_VSOCK
-	{ AF_VSOCK,	"AF_VSOCK"	},
+	XLAT(AF_VSOCK),
 #endif
 	{ 0,		NULL		},
 };
 static const struct xlat socktypes[] = {
-	{ SOCK_STREAM,	"SOCK_STREAM"	},
-	{ SOCK_DGRAM,	"SOCK_DGRAM"	},
+	XLAT(SOCK_STREAM),
+	XLAT(SOCK_DGRAM),
 #ifdef SOCK_RAW
-	{ SOCK_RAW,	"SOCK_RAW"	},
+	XLAT(SOCK_RAW),
 #endif
 #ifdef SOCK_RDM
-	{ SOCK_RDM,	"SOCK_RDM"	},
+	XLAT(SOCK_RDM),
 #endif
 #ifdef SOCK_SEQPACKET
-	{ SOCK_SEQPACKET,"SOCK_SEQPACKET"},
+	XLAT(SOCK_SEQPACKET),
 #endif
 #ifdef SOCK_DCCP
-	{ SOCK_DCCP,	"SOCK_DCCP"	},
+	XLAT(SOCK_DCCP),
 #endif
 #ifdef SOCK_PACKET
-	{ SOCK_PACKET,	"SOCK_PACKET"	},
+	XLAT(SOCK_PACKET),
 #endif
 	{ 0,		NULL		},
 };
 static const struct xlat sock_type_flags[] = {
 #ifdef SOCK_CLOEXEC
-	{ SOCK_CLOEXEC,	"SOCK_CLOEXEC"	},
+	XLAT(SOCK_CLOEXEC),
 #endif
 #ifdef SOCK_NONBLOCK
-	{ SOCK_NONBLOCK,"SOCK_NONBLOCK"	},
+	XLAT(SOCK_NONBLOCK),
 #endif
 	{ 0,		NULL		},
 };
@@ -380,385 +380,385 @@ static const struct xlat sock_type_flags[] = {
 #endif
 static const struct xlat socketlayers[] = {
 #if defined(SOL_IP)
-	{ SOL_IP,	"SOL_IP"	},
+	XLAT(SOL_IP),
 #endif
 #if defined(SOL_ICMP)
-	{ SOL_ICMP,	"SOL_ICMP"	},
+	XLAT(SOL_ICMP),
 #endif
 #if defined(SOL_TCP)
-	{ SOL_TCP,	"SOL_TCP"	},
+	XLAT(SOL_TCP),
 #endif
 #if defined(SOL_UDP)
-	{ SOL_UDP,	"SOL_UDP"	},
+	XLAT(SOL_UDP),
 #endif
 #if defined(SOL_IPV6)
-	{ SOL_IPV6,	"SOL_IPV6"	},
+	XLAT(SOL_IPV6),
 #endif
 #if defined(SOL_ICMPV6)
-	{ SOL_ICMPV6,	"SOL_ICMPV6"	},
+	XLAT(SOL_ICMPV6),
 #endif
 #if defined(SOL_SCTP)
-	{ SOL_SCTP,	"SOL_SCTP"	},
+	XLAT(SOL_SCTP),
 #endif
 #if defined(SOL_UDPLITE)
-	{ SOL_UDPLITE,	"SOL_UDPLITE"	},
+	XLAT(SOL_UDPLITE),
 #endif
 #if defined(SOL_RAW)
-	{ SOL_RAW,	"SOL_RAW"	},
+	XLAT(SOL_RAW),
 #endif
 #if defined(SOL_IPX)
-	{ SOL_IPX,	"SOL_IPX"	},
+	XLAT(SOL_IPX),
 #endif
 #if defined(SOL_AX25)
-	{ SOL_AX25,	"SOL_AX25"	},
+	XLAT(SOL_AX25),
 #endif
 #if defined(SOL_ATALK)
-	{ SOL_ATALK,	"SOL_ATALK"	},
+	XLAT(SOL_ATALK),
 #endif
 #if defined(SOL_NETROM)
-	{ SOL_NETROM,	"SOL_NETROM"	},
+	XLAT(SOL_NETROM),
 #endif
 #if defined(SOL_ROSE)
-	{ SOL_ROSE,	"SOL_ROSE"	},
+	XLAT(SOL_ROSE),
 #endif
 #if defined(SOL_DECNET)
-	{ SOL_DECNET,	"SOL_DECNET"	},
+	XLAT(SOL_DECNET),
 #endif
 #if defined(SOL_X25)
-	{ SOL_X25,	"SOL_X25"	},
+	XLAT(SOL_X25),
 #endif
 #if defined(SOL_PACKET)
-	{ SOL_PACKET,	"SOL_PACKET"	},
+	XLAT(SOL_PACKET),
 #endif
 #if defined(SOL_ATM)
-	{ SOL_ATM,	"SOL_ATM"	},
+	XLAT(SOL_ATM),
 #endif
 #if defined(SOL_AAL)
-	{ SOL_AAL,	"SOL_AAL"	},
+	XLAT(SOL_AAL),
 #endif
 #if defined(SOL_IRDA)
-	{ SOL_IRDA,	"SOL_IRDA"	},
+	XLAT(SOL_IRDA),
 #endif
 #if defined(SOL_NETBEUI)
-	{ SOL_NETBEUI,	"SOL_NETBEUI"	},
+	XLAT(SOL_NETBEUI),
 #endif
 #if defined(SOL_LLC)
-	{ SOL_LLC,	"SOL_LLC"	},
+	XLAT(SOL_LLC),
 #endif
 #if defined(SOL_DCCP)
-	{ SOL_DCCP,	"SOL_DCCP"	},
+	XLAT(SOL_DCCP),
 #endif
 #if defined(SOL_NETLINK)
-	{ SOL_NETLINK,	"SOL_NETLINK"	},
+	XLAT(SOL_NETLINK),
 #endif
 #if defined(SOL_TIPC)
-	{ SOL_TIPC,	"SOL_TIPC"	},
+	XLAT(SOL_TIPC),
 #endif
 #if defined(SOL_RXRPC)
-	{ SOL_RXRPC,	"SOL_RXRPC"	},
+	XLAT(SOL_RXRPC),
 #endif
 #if defined(SOL_PPPOL2TP)
-	{ SOL_PPPOL2TP,	"SOL_PPPOL2TP"	},
+	XLAT(SOL_PPPOL2TP),
 #endif
 #if defined(SOL_BLUETOOTH)
-	{ SOL_BLUETOOTH,"SOL_BLUETOOTH" },
+	XLAT(SOL_BLUETOOTH),
 #endif
 #if defined(SOL_PNPIPE)
-	{ SOL_PNPIPE,	"SOL_PNPIPE"	},
+	XLAT(SOL_PNPIPE),
 #endif
 #if defined(SOL_RDS)
-	{ SOL_RDS,	"SOL_RDS"	},
+	XLAT(SOL_RDS),
 #endif
 #if defined(SOL_IUVC)
-	{ SOL_IUCV,	"SOL_IUCV"	},
+	XLAT(SOL_IUCV),
 #endif
 #if defined(SOL_CAIF)
-	{ SOL_CAIF,	"SOL_CAIF"	},
+	XLAT(SOL_CAIF),
 #endif
-	{ SOL_SOCKET,	"SOL_SOCKET"	},	/* Never used! */
+	XLAT(SOL_SOCKET),	/* Never used! */
 	/* The SOL_* array should remain not NULL-terminated. */
 };
 /*** WARNING: DANGER WILL ROBINSON: NOTE "socketlayers" array above
      falls into "protocols" array below!!!!   This is intended!!! ***/
 static const struct xlat protocols[] = {
-	{ IPPROTO_IP,	"IPPROTO_IP"	},
-	{ IPPROTO_ICMP,	"IPPROTO_ICMP"	},
-	{ IPPROTO_TCP,	"IPPROTO_TCP"	},
-	{ IPPROTO_UDP,	"IPPROTO_UDP"	},
+	XLAT(IPPROTO_IP),
+	XLAT(IPPROTO_ICMP),
+	XLAT(IPPROTO_TCP),
+	XLAT(IPPROTO_UDP),
 #ifdef IPPROTO_IGMP
-	{ IPPROTO_IGMP,	"IPPROTO_IGMP"	},
+	XLAT(IPPROTO_IGMP),
 #endif
 #ifdef IPPROTO_GGP
-	{ IPPROTO_GGP,	"IPPROTO_GGP"	},
+	XLAT(IPPROTO_GGP),
 #endif
 #ifdef IPPROTO_IPIP
-	{ IPPROTO_IPIP,	"IPPROTO_IPIP"	},
+	XLAT(IPPROTO_IPIP),
 #endif
 #ifdef IPPROTO_EGP
-	{ IPPROTO_EGP,	"IPPROTO_EGP"	},
+	XLAT(IPPROTO_EGP),
 #endif
 #ifdef IPPROTO_PUP
-	{ IPPROTO_PUP,	"IPPROTO_PUP"	},
+	XLAT(IPPROTO_PUP),
 #endif
 #ifdef IPPROTO_IDP
-	{ IPPROTO_IDP,	"IPPROTO_IDP"	},
+	XLAT(IPPROTO_IDP),
 #endif
 #ifdef IPPROTO_TP
-	{ IPPROTO_TP,	"IPPROTO_TP"	},
+	XLAT(IPPROTO_TP),
 #endif
 #ifdef IPPROTO_DCCP
-	{ IPPROTO_DCCP,	"IPPROTO_DCCP"	},
+	XLAT(IPPROTO_DCCP),
 #endif
 #ifdef IPPROTO_IPV6
-	{ IPPROTO_IPV6,	"IPPROTO_IPV6"	},
+	XLAT(IPPROTO_IPV6),
 #endif
 #ifdef IPPROTO_ROUTING
-	{ IPPROTO_ROUTING, "IPPROTO_ROUTING" },
+	XLAT(IPPROTO_ROUTING),
 #endif
 #ifdef IPPROTO_FRAGMENT
-	{ IPPROTO_FRAGMENT, "IPPROTO_FRAGMENT" },
+	XLAT(IPPROTO_FRAGMENT),
 #endif
 #ifdef IPPROTO_RSVP
-	{ IPPROTO_RSVP,	"IPPROTO_RSVP"	},
+	XLAT(IPPROTO_RSVP),
 #endif
 #ifdef IPPROTO_GRE
-	{ IPPROTO_GRE,	"IPPROTO_GRE"	},
+	XLAT(IPPROTO_GRE),
 #endif
 #ifdef IPPROTO_ESP
-	{ IPPROTO_ESP,	"IPPROTO_ESP"	},
+	XLAT(IPPROTO_ESP),
 #endif
 #ifdef IPPROTO_AH
-	{ IPPROTO_AH,	"IPPROTO_AH"	},
+	XLAT(IPPROTO_AH),
 #endif
 #ifdef IPPROTO_ICMPV6
-	{ IPPROTO_ICMPV6, "IPPROTO_ICMPV6" },
+	XLAT(IPPROTO_ICMPV6),
 #endif
 #ifdef IPPROTO_NONE
-	{ IPPROTO_NONE,	"IPPROTO_NONE"	},
+	XLAT(IPPROTO_NONE),
 #endif
 #ifdef IPPROTO_DSTOPTS
-	{ IPPROTO_DSTOPTS, "IPPROTO_DSTOPTS" },
+	XLAT(IPPROTO_DSTOPTS),
 #endif
 #ifdef IPPROTO_HELLO
-	{ IPPROTO_HELLO, "IPPROTO_HELLO" },
+	XLAT(IPPROTO_HELLO),
 #endif
 #ifdef IPPROTO_ND
-	{ IPPROTO_ND,	"IPPROTO_ND"	},
+	XLAT(IPPROTO_ND),
 #endif
 #ifdef IPPROTO_MTP
-	{ IPPROTO_MTP,	"IPPROTO_MTP"	},
+	XLAT(IPPROTO_MTP),
 #endif
 #ifdef IPPROTO_ENCAP
-	{ IPPROTO_ENCAP, "IPPROTO_ENCAP" },
+	XLAT(IPPROTO_ENCAP),
 #endif
 #ifdef IPPROTO_PIM
-	{ IPPROTO_PIM,	"IPPROTO_PIM"	},
+	XLAT(IPPROTO_PIM),
 #endif
 #ifdef IPPROTO_COMP
-	{ IPPROTO_COMP,	"IPPROTO_COMP"	},
+	XLAT(IPPROTO_COMP),
 #endif
 #ifdef IPPROTO_SCTP
-	{ IPPROTO_SCTP,	"IPPROTO_SCTP"	},
+	XLAT(IPPROTO_SCTP),
 #endif
 #ifdef IPPROTO_UDPLITE
-	{ IPPROTO_UDPLITE, "IPPROTO_UDPLITE" },
+	XLAT(IPPROTO_UDPLITE),
 #endif
 #ifdef IPPROTO_RAW
-	{ IPPROTO_RAW,	"IPPROTO_RAW"	},
+	XLAT(IPPROTO_RAW),
 #endif
 #ifdef IPPROTO_MAX
-	{ IPPROTO_MAX,	"IPPROTO_MAX"	},
+	XLAT(IPPROTO_MAX),
 #endif
 	{ 0,		NULL		},
 };
 static const struct xlat msg_flags[] = {
-	{ MSG_OOB,		"MSG_OOB"		},
+	XLAT(MSG_OOB),
 #ifdef MSG_PEEK
-	{ MSG_PEEK,		"MSG_PEEK"		},
+	XLAT(MSG_PEEK),
 #endif
 #ifdef MSG_DONTROUTE
-	{ MSG_DONTROUTE,	"MSG_DONTROUTE"		},
+	XLAT(MSG_DONTROUTE),
 #endif
 #ifdef MSG_CTRUNC
-	{ MSG_CTRUNC,		"MSG_CTRUNC"		},
+	XLAT(MSG_CTRUNC),
 #endif
 #ifdef MSG_PROBE
-	{ MSG_PROBE,		"MSG_PROBE"		},
+	XLAT(MSG_PROBE),
 #endif
 #ifdef MSG_TRUNC
-	{ MSG_TRUNC,		"MSG_TRUNC"		},
+	XLAT(MSG_TRUNC),
 #endif
 #ifdef MSG_DONTWAIT
-	{ MSG_DONTWAIT,		"MSG_DONTWAIT"		},
+	XLAT(MSG_DONTWAIT),
 #endif
 #ifdef MSG_EOR
-	{ MSG_EOR,		"MSG_EOR"		},
+	XLAT(MSG_EOR),
 #endif
 #ifdef MSG_WAITALL
-	{ MSG_WAITALL,		"MSG_WAITALL"		},
+	XLAT(MSG_WAITALL),
 #endif
 #ifdef MSG_FIN
-	{ MSG_FIN,		"MSG_FIN"		},
+	XLAT(MSG_FIN),
 #endif
 #ifdef MSG_SYN
-	{ MSG_SYN,		"MSG_SYN"		},
+	XLAT(MSG_SYN),
 #endif
 #ifdef MSG_CONFIRM
-	{ MSG_CONFIRM,		"MSG_CONFIRM"		},
+	XLAT(MSG_CONFIRM),
 #endif
 #ifdef MSG_RST
-	{ MSG_RST,		"MSG_RST"		},
+	XLAT(MSG_RST),
 #endif
 #ifdef MSG_ERRQUEUE
-	{ MSG_ERRQUEUE,		"MSG_ERRQUEUE"		},
+	XLAT(MSG_ERRQUEUE),
 #endif
 #ifdef MSG_NOSIGNAL
-	{ MSG_NOSIGNAL,		"MSG_NOSIGNAL"		},
+	XLAT(MSG_NOSIGNAL),
 #endif
 #ifdef MSG_MORE
-	{ MSG_MORE,		"MSG_MORE"		},
+	XLAT(MSG_MORE),
 #endif
 #ifdef MSG_WAITFORONE
-	{ MSG_WAITFORONE,	"MSG_WAITFORONE"	},
+	XLAT(MSG_WAITFORONE),
 #endif
 #ifdef MSG_EOF
-	{ MSG_EOF,		"MSG_EOF"		},
+	XLAT(MSG_EOF),
 #endif
 #ifdef MSG_FASTOPEN
-	{ MSG_FASTOPEN,		"MSG_FASTOPEN"		},
+	XLAT(MSG_FASTOPEN),
 #endif
 #ifdef MSG_CMSG_CLOEXEC
-	{ MSG_CMSG_CLOEXEC,	"MSG_CMSG_CLOEXEC"	},
+	XLAT(MSG_CMSG_CLOEXEC),
 #endif
 	{ 0,			NULL			},
 };
 
 static const struct xlat sockoptions[] = {
 #ifdef SO_ACCEPTCONN
-	{ SO_ACCEPTCONN,	"SO_ACCEPTCONN"	},
+	XLAT(SO_ACCEPTCONN),
 #endif
 #ifdef SO_ALLRAW
-	{ SO_ALLRAW,	"SO_ALLRAW"	},
+	XLAT(SO_ALLRAW),
 #endif
 #ifdef SO_ATTACH_FILTER
-	{ SO_ATTACH_FILTER,	"SO_ATTACH_FILTER"	},
+	XLAT(SO_ATTACH_FILTER),
 #endif
 #ifdef SO_BINDTODEVICE
-	{ SO_BINDTODEVICE,	"SO_BINDTODEVICE"	},
+	XLAT(SO_BINDTODEVICE),
 #endif
 #ifdef SO_BROADCAST
-	{ SO_BROADCAST,	"SO_BROADCAST"	},
+	XLAT(SO_BROADCAST),
 #endif
 #ifdef SO_BSDCOMPAT
-	{ SO_BSDCOMPAT,	"SO_BSDCOMPAT"	},
+	XLAT(SO_BSDCOMPAT),
 #endif
 #ifdef SO_DEBUG
-	{ SO_DEBUG,	"SO_DEBUG"	},
+	XLAT(SO_DEBUG),
 #endif
 #ifdef SO_DETACH_FILTER
-	{ SO_DETACH_FILTER,	"SO_DETACH_FILTER"	},
+	XLAT(SO_DETACH_FILTER),
 #endif
 #ifdef SO_DONTROUTE
-	{ SO_DONTROUTE,	"SO_DONTROUTE"	},
+	XLAT(SO_DONTROUTE),
 #endif
 #ifdef SO_ERROR
-	{ SO_ERROR,	"SO_ERROR"	},
+	XLAT(SO_ERROR),
 #endif
 #ifdef SO_ICS
-	{ SO_ICS,	"SO_ICS"	},
+	XLAT(SO_ICS),
 #endif
 #ifdef SO_IMASOCKET
-	{ SO_IMASOCKET,	"SO_IMASOCKET"	},
+	XLAT(SO_IMASOCKET),
 #endif
 #ifdef SO_KEEPALIVE
-	{ SO_KEEPALIVE,	"SO_KEEPALIVE"	},
+	XLAT(SO_KEEPALIVE),
 #endif
 #ifdef SO_LINGER
-	{ SO_LINGER,	"SO_LINGER"	},
+	XLAT(SO_LINGER),
 #endif
 #ifdef SO_LISTENING
-	{ SO_LISTENING,	"SO_LISTENING"	},
+	XLAT(SO_LISTENING),
 #endif
 #ifdef SO_MGMT
-	{ SO_MGMT,	"SO_MGMT"	},
+	XLAT(SO_MGMT),
 #endif
 #ifdef SO_NO_CHECK
-	{ SO_NO_CHECK,	"SO_NO_CHECK"	},
+	XLAT(SO_NO_CHECK),
 #endif
 #ifdef SO_OOBINLINE
-	{ SO_OOBINLINE,	"SO_OOBINLINE"	},
+	XLAT(SO_OOBINLINE),
 #endif
 #ifdef SO_ORDREL
-	{ SO_ORDREL,	"SO_ORDREL"	},
+	XLAT(SO_ORDREL),
 #endif
 #ifdef SO_PARALLELSVR
-	{ SO_PARALLELSVR,	"SO_PARALLELSVR"	},
+	XLAT(SO_PARALLELSVR),
 #endif
 #ifdef SO_PASSCRED
-	{ SO_PASSCRED,	"SO_PASSCRED"	},
+	XLAT(SO_PASSCRED),
 #endif
 #ifdef SO_PEERCRED
-	{ SO_PEERCRED,	"SO_PEERCRED"	},
+	XLAT(SO_PEERCRED),
 #endif
 #ifdef SO_PEERNAME
-	{ SO_PEERNAME,	"SO_PEERNAME"	},
+	XLAT(SO_PEERNAME),
 #endif
 #ifdef SO_PEERSEC
-	{ SO_PEERSEC,	"SO_PEERSEC"	},
+	XLAT(SO_PEERSEC),
 #endif
 #ifdef SO_PRIORITY
-	{ SO_PRIORITY,	"SO_PRIORITY"	},
+	XLAT(SO_PRIORITY),
 #endif
 #ifdef SO_PROTOTYPE
-	{ SO_PROTOTYPE,	"SO_PROTOTYPE"	},
+	XLAT(SO_PROTOTYPE),
 #endif
 #ifdef SO_RCVBUF
-	{ SO_RCVBUF,	"SO_RCVBUF"	},
+	XLAT(SO_RCVBUF),
 #endif
 #ifdef SO_RCVLOWAT
-	{ SO_RCVLOWAT,	"SO_RCVLOWAT"	},
+	XLAT(SO_RCVLOWAT),
 #endif
 #ifdef SO_RCVTIMEO
-	{ SO_RCVTIMEO,	"SO_RCVTIMEO"	},
+	XLAT(SO_RCVTIMEO),
 #endif
 #ifdef SO_RDWR
-	{ SO_RDWR,	"SO_RDWR"	},
+	XLAT(SO_RDWR),
 #endif
 #ifdef SO_REUSEADDR
-	{ SO_REUSEADDR,	"SO_REUSEADDR"	},
+	XLAT(SO_REUSEADDR),
 #endif
 #ifdef SO_REUSEPORT
-	{ SO_REUSEPORT,	"SO_REUSEPORT"	},
+	XLAT(SO_REUSEPORT),
 #endif
 #ifdef SO_SECURITY_AUTHENTICATION
-	{ SO_SECURITY_AUTHENTICATION,"SO_SECURITY_AUTHENTICATION"},
+	XLAT(SO_SECURITY_AUTHENTICATION),
 #endif
 #ifdef SO_SECURITY_ENCRYPTION_NETWORK
-	{ SO_SECURITY_ENCRYPTION_NETWORK,"SO_SECURITY_ENCRYPTION_NETWORK"},
+	XLAT(SO_SECURITY_ENCRYPTION_NETWORK),
 #endif
 #ifdef SO_SECURITY_ENCRYPTION_TRANSPORT
-	{ SO_SECURITY_ENCRYPTION_TRANSPORT,"SO_SECURITY_ENCRYPTION_TRANSPORT"},
+	XLAT(SO_SECURITY_ENCRYPTION_TRANSPORT),
 #endif
 #ifdef SO_SEMA
-	{ SO_SEMA,	"SO_SEMA"	},
+	XLAT(SO_SEMA),
 #endif
 #ifdef SO_SNDBUF
-	{ SO_SNDBUF,	"SO_SNDBUF"	},
+	XLAT(SO_SNDBUF),
 #endif
 #ifdef SO_SNDLOWAT
-	{ SO_SNDLOWAT,	"SO_SNDLOWAT"	},
+	XLAT(SO_SNDLOWAT),
 #endif
 #ifdef SO_SNDTIMEO
-	{ SO_SNDTIMEO,	"SO_SNDTIMEO"	},
+	XLAT(SO_SNDTIMEO),
 #endif
 #ifdef SO_TIMESTAMP
-	{ SO_TIMESTAMP,	"SO_TIMESTAMP"	},
+	XLAT(SO_TIMESTAMP),
 #endif
 #ifdef SO_TYPE
-	{ SO_TYPE,	"SO_TYPE"	},
+	XLAT(SO_TYPE),
 #endif
 #ifdef SO_USELOOPBACK
-	{ SO_USELOOPBACK,	"SO_USELOOPBACK"	},
+	XLAT(SO_USELOOPBACK),
 #endif
 	{ 0,		NULL		},
 };
@@ -770,145 +770,145 @@ static const struct xlat sockoptions[] = {
 #ifdef SOL_IP
 static const struct xlat sockipoptions[] = {
 #ifdef IP_TOS
-	{ IP_TOS,		"IP_TOS"		},
+	XLAT(IP_TOS),
 #endif
 #ifdef IP_TTL
-	{ IP_TTL,		"IP_TTL"		},
+	XLAT(IP_TTL),
 #endif
 #ifdef IP_HDRINCL
-	{ IP_HDRINCL,		"IP_HDRINCL"		},
+	XLAT(IP_HDRINCL),
 #endif
 #ifdef IP_OPTIONS
-	{ IP_OPTIONS,		"IP_OPTIONS"		},
+	XLAT(IP_OPTIONS),
 #endif
 #ifdef IP_ROUTER_ALERT
-	{ IP_ROUTER_ALERT,	"IP_ROUTER_ALERT"	},
+	XLAT(IP_ROUTER_ALERT),
 #endif
 #ifdef IP_RECVOPTIONS
-	{ IP_RECVOPTIONS,	"IP_RECVOPTIONS"	},
+	XLAT(IP_RECVOPTIONS),
 #endif
 #ifdef IP_RECVOPTS
-	{ IP_RECVOPTS,		"IP_RECVOPTS"		},
+	XLAT(IP_RECVOPTS),
 #endif
 #ifdef IP_RECVRETOPTS
-	{ IP_RECVRETOPTS,	"IP_RECVRETOPTS"	},
+	XLAT(IP_RECVRETOPTS),
 #endif
 #ifdef IP_RECVDSTADDR
-	{ IP_RECVDSTADDR,	"IP_RECVDSTADDR"	},
+	XLAT(IP_RECVDSTADDR),
 #endif
 #ifdef IP_RETOPTS
-	{ IP_RETOPTS,		"IP_RETOPTS"		},
+	XLAT(IP_RETOPTS),
 #endif
 #ifdef IP_PKTINFO
-	{ IP_PKTINFO,		"IP_PKTINFO"		},
+	XLAT(IP_PKTINFO),
 #endif
 #ifdef IP_PKTOPTIONS
-	{ IP_PKTOPTIONS,	"IP_PKTOPTIONS"		},
+	XLAT(IP_PKTOPTIONS),
 #endif
 #ifdef IP_MTU_DISCOVER
-	{ IP_MTU_DISCOVER,	"IP_MTU_DISCOVER"	},
+	XLAT(IP_MTU_DISCOVER),
 #endif
 #ifdef IP_RECVERR
-	{ IP_RECVERR,		"IP_RECVERR"		},
+	XLAT(IP_RECVERR),
 #endif
 #ifdef IP_RECVTTL
-	{ IP_RECVTTL,		"IP_RECVTTL"		},
+	XLAT(IP_RECVTTL),
 #endif
 #ifdef IP_RECVTOS
-	{ IP_RECVTOS,		"IP_RECVTOS"		},
+	XLAT(IP_RECVTOS),
 #endif
 #ifdef IP_MTU
-	{ IP_MTU,		"IP_MTU"		},
+	XLAT(IP_MTU),
 #endif
 #ifdef IP_MULTICAST_IF
-	{ IP_MULTICAST_IF,	"IP_MULTICAST_IF"	},
+	XLAT(IP_MULTICAST_IF),
 #endif
 #ifdef IP_MULTICAST_TTL
-	{ IP_MULTICAST_TTL,	"IP_MULTICAST_TTL"	},
+	XLAT(IP_MULTICAST_TTL),
 #endif
 #ifdef IP_MULTICAST_LOOP
-	{ IP_MULTICAST_LOOP,	"IP_MULTICAST_LOOP"	},
+	XLAT(IP_MULTICAST_LOOP),
 #endif
 #ifdef IP_ADD_MEMBERSHIP
-	{ IP_ADD_MEMBERSHIP,	"IP_ADD_MEMBERSHIP"	},
+	XLAT(IP_ADD_MEMBERSHIP),
 #endif
 #ifdef IP_DROP_MEMBERSHIP
-	{ IP_DROP_MEMBERSHIP,	"IP_DROP_MEMBERSHIP"	},
+	XLAT(IP_DROP_MEMBERSHIP),
 #endif
 #ifdef IP_BROADCAST_IF
-	{ IP_BROADCAST_IF,	"IP_BROADCAST_IF"	},
+	XLAT(IP_BROADCAST_IF),
 #endif
 #ifdef IP_RECVIFINDEX
-	{ IP_RECVIFINDEX,	"IP_RECVIFINDEX"	},
+	XLAT(IP_RECVIFINDEX),
 #endif
 #ifdef IP_MSFILTER
-	{ IP_MSFILTER,		"IP_MSFILTER"		},
+	XLAT(IP_MSFILTER),
 #endif
 #ifdef MCAST_MSFILTER
-	{ MCAST_MSFILTER,	"MCAST_MSFILTER"	},
+	XLAT(MCAST_MSFILTER),
 #endif
 #ifdef IP_FREEBIND
-	{ IP_FREEBIND,		"IP_FREEBIND"		},
+	XLAT(IP_FREEBIND),
 #endif
 #ifdef IP_IPSEC_POLICY
-	{ IP_IPSEC_POLICY,	"IP_IPSEC_POLICY"	},
+	XLAT(IP_IPSEC_POLICY),
 #endif
 #ifdef IP_XFRM_POLICY
-	{ IP_XFRM_POLICY,	"IP_XFRM_POLICY"	},
+	XLAT(IP_XFRM_POLICY),
 #endif
 #ifdef IP_PASSSEC
-	{ IP_PASSSEC,		"IP_PASSSEC"		},
+	XLAT(IP_PASSSEC),
 #endif
 #ifdef IP_TRANSPARENT
-	{ IP_TRANSPARENT,	"IP_TRANSPARENT"	},
+	XLAT(IP_TRANSPARENT),
 #endif
 #ifdef IP_ORIGDSTADDR
-	{ IP_ORIGDSTADDR,	"IP_ORIGDSTADDR"	},
+	XLAT(IP_ORIGDSTADDR),
 #endif
 #ifdef IP_RECVORIGDSTADDR
-	{ IP_RECVORIGDSTADDR,	"IP_RECVORIGDSTADDR"	},
+	XLAT(IP_RECVORIGDSTADDR),
 #endif
 #ifdef IP_MINTTL
-	{ IP_MINTTL,		"IP_MINTTL"		},
+	XLAT(IP_MINTTL),
 #endif
 #ifdef IP_NODEFRAG
-	{ IP_NODEFRAG,		"IP_NODEFRAG"		},
+	XLAT(IP_NODEFRAG),
 #endif
 #ifdef IP_UNBLOCK_SOURCE
-	{ IP_UNBLOCK_SOURCE,	"IP_UNBLOCK_SOURCE"	},
+	XLAT(IP_UNBLOCK_SOURCE),
 #endif
 #ifdef IP_BLOCK_SOURCE
-	{ IP_BLOCK_SOURCE,	"IP_BLOCK_SOURCE"	},
+	XLAT(IP_BLOCK_SOURCE),
 #endif
 #ifdef IP_ADD_SOURCE_MEMBERSHIP
-	{ IP_ADD_SOURCE_MEMBERSHIP, "IP_ADD_SOURCE_MEMBERSHIP"	},
+	XLAT(IP_ADD_SOURCE_MEMBERSHIP),
 #endif
 #ifdef IP_DROP_SOURCE_MEMBERSHIP
-	{ IP_DROP_SOURCE_MEMBERSHIP, "IP_DROP_SOURCE_MEMBERSHIP"	},
+	XLAT(IP_DROP_SOURCE_MEMBERSHIP),
 #endif
 #ifdef MCAST_JOIN_GROUP
-	{ MCAST_JOIN_GROUP,	"MCAST_JOIN_GROUP"	},
+	XLAT(MCAST_JOIN_GROUP),
 #endif
 #ifdef MCAST_BLOCK_SOURCE
-	{ MCAST_BLOCK_SOURCE,	"MCAST_BLOCK_SOURCE"	},
+	XLAT(MCAST_BLOCK_SOURCE),
 #endif
 #ifdef MCAST_UNBLOCK_SOURCE
-	{ MCAST_UNBLOCK_SOURCE,	"MCAST_UNBLOCK_SOURCE"	},
+	XLAT(MCAST_UNBLOCK_SOURCE),
 #endif
 #ifdef MCAST_LEAVE_GROUP
-	{ MCAST_LEAVE_GROUP,	"MCAST_LEAVE_GROUP"	},
+	XLAT(MCAST_LEAVE_GROUP),
 #endif
 #ifdef MCAST_JOIN_SOURCE_GROUP
-	{ MCAST_JOIN_SOURCE_GROUP, "MCAST_JOIN_SOURCE_GROUP"	},
+	XLAT(MCAST_JOIN_SOURCE_GROUP),
 #endif
 #ifdef MCAST_LEAVE_SOURCE_GROUP
-	{ MCAST_LEAVE_SOURCE_GROUP, "MCAST_LEAVE_SOURCE_GROUP"	},
+	XLAT(MCAST_LEAVE_SOURCE_GROUP),
 #endif
 #ifdef IP_MULTICAST_ALL
-	{ IP_MULTICAST_ALL,	"IP_MULTICAST_ALL"	},
+	XLAT(IP_MULTICAST_ALL),
 #endif
 #ifdef IP_UNICAST_IF
-	{ IP_UNICAST_IF,	"IP_UNICAST_IF"		},
+	XLAT(IP_UNICAST_IF),
 #endif
 	{ 0,			NULL			},
 };
@@ -917,67 +917,67 @@ static const struct xlat sockipoptions[] = {
 #ifdef SOL_IPV6
 static const struct xlat sockipv6options[] = {
 #ifdef IPV6_ADDRFORM
-	{ IPV6_ADDRFORM,	"IPV6_ADDRFORM"		},
+	XLAT(IPV6_ADDRFORM),
 #endif
 #ifdef MCAST_FILTER
-	{ MCAST_FILTER,		"MCAST_FILTER"		},
+	XLAT(MCAST_FILTER),
 #endif
 #ifdef IPV6_PKTOPTIONS
-	{ IPV6_PKTOPTIONS,	"IPV6_PKTOPTIONS"	},
+	XLAT(IPV6_PKTOPTIONS),
 #endif
 #ifdef IPV6_MTU
-	{ IPV6_MTU,		"IPV6_MTU"		},
+	XLAT(IPV6_MTU),
 #endif
 #ifdef IPV6_V6ONLY
-	{ IPV6_V6ONLY,		"IPV6_V6ONLY"		},
+	XLAT(IPV6_V6ONLY),
 #endif
 #ifdef IPV6_PKTINFO
-	{ IPV6_PKTINFO,		"IPV6_PKTINFO"		},
+	XLAT(IPV6_PKTINFO),
 #endif
 #ifdef IPV6_HOPLIMIT
-	{ IPV6_HOPLIMIT,	"IPV6_HOPLIMIT"		},
+	XLAT(IPV6_HOPLIMIT),
 #endif
 #ifdef IPV6_RTHDR
-	{ IPV6_RTHDR,		"IPV6_RTHDR"		},
+	XLAT(IPV6_RTHDR),
 #endif
 #ifdef IPV6_HOPOPTS
-	{ IPV6_HOPOPTS,		"IPV6_HOPOPTS"		},
+	XLAT(IPV6_HOPOPTS),
 #endif
 #ifdef IPV6_DSTOPTS
-	{ IPV6_DSTOPTS,		"IPV6_DSTOPTS"		},
+	XLAT(IPV6_DSTOPTS),
 #endif
 #ifdef IPV6_FLOWINFO
-	{ IPV6_FLOWINFO,	"IPV6_FLOWINFO"		},
+	XLAT(IPV6_FLOWINFO),
 #endif
 #ifdef IPV6_UNICAST_HOPS
-	{ IPV6_UNICAST_HOPS,	"IPV6_UNICAST_HOPS"	},
+	XLAT(IPV6_UNICAST_HOPS),
 #endif
 #ifdef IPV6_MULTICAST_HOPS
-	{ IPV6_MULTICAST_HOPS,	"IPV6_MULTICAST_HOPS"	},
+	XLAT(IPV6_MULTICAST_HOPS),
 #endif
 #ifdef IPV6_MULTICAST_LOOP
-	{ IPV6_MULTICAST_LOOP,	"IPV6_MULTICAST_LOOP"	},
+	XLAT(IPV6_MULTICAST_LOOP),
 #endif
 #ifdef IPV6_MULTICAST_IF
-	{ IPV6_MULTICAST_IF,	"IPV6_MULTICAST_IF"	},
+	XLAT(IPV6_MULTICAST_IF),
 #endif
 #ifdef IPV6_MTU_DISCOVER
-	{ IPV6_MTU_DISCOVER,	"IPV6_MTU_DISCOVER"	},
+	XLAT(IPV6_MTU_DISCOVER),
 #endif
 #ifdef IPV6_RECVERR
-	{ IPV6_RECVERR,		"IPV6_RECVERR"		},
+	XLAT(IPV6_RECVERR),
 #endif
 #ifdef IPV6_FLOWINFO_SEND
-	{ IPV6_FLOWINFO_SEND,	"IPV6_FLOWINFO_SEND"	},
+	XLAT(IPV6_FLOWINFO_SEND),
 #endif
 #ifdef IPV6_ADD_MEMBERSHIP
-	{ IPV6_ADD_MEMBERSHIP,	"IPV6_ADD_MEMBERSHIP"	},
+	XLAT(IPV6_ADD_MEMBERSHIP),
 #endif
 #ifdef IPV6_DROP_MEMBERSHIP
-	{ IPV6_DROP_MEMBERSHIP,	"IPV6_DROP_MEMBERSHIP"	},
+	XLAT(IPV6_DROP_MEMBERSHIP),
 #endif
 #ifdef IPV6_ROUTER_ALERT
-	{ IPV6_ROUTER_ALERT,	"IPV6_ROUTER_ALERT"	},
+	XLAT(IPV6_ROUTER_ALERT),
 #endif
 	{ 0,			NULL			},
 };
@@ -985,7 +985,7 @@ static const struct xlat sockipv6options[] = {
 
 #ifdef SOL_IPX
 static const struct xlat sockipxoptions[] = {
-	{ IPX_TYPE,	"IPX_TYPE"	},
+	XLAT(IPX_TYPE),
 	{ 0,		NULL		},
 };
 #endif /* SOL_IPX */
@@ -993,7 +993,7 @@ static const struct xlat sockipxoptions[] = {
 #ifdef SOL_RAW
 static const struct xlat sockrawoptions[] = {
 #if defined(ICMP_FILTER)
-	{ ICMP_FILTER,		"ICMP_FILTER"	},
+	XLAT(ICMP_FILTER),
 #endif
 	{ 0,			NULL		},
 };
@@ -1002,43 +1002,43 @@ static const struct xlat sockrawoptions[] = {
 #ifdef SOL_PACKET
 static const struct xlat sockpacketoptions[] = {
 #ifdef PACKET_ADD_MEMBERSHIP
-	{ PACKET_ADD_MEMBERSHIP,	"PACKET_ADD_MEMBERSHIP"	},
+	XLAT(PACKET_ADD_MEMBERSHIP),
 #endif
 #ifdef PACKET_DROP_MEMBERSHIP
-	{ PACKET_DROP_MEMBERSHIP,	"PACKET_DROP_MEMBERSHIP"},
+	XLAT(PACKET_DROP_MEMBERSHIP),
 #endif
 #if defined(PACKET_RECV_OUTPUT)
-	{ PACKET_RECV_OUTPUT,		"PACKET_RECV_OUTPUT"	},
+	XLAT(PACKET_RECV_OUTPUT),
 #endif
 #if defined(PACKET_RX_RING)
-	{ PACKET_RX_RING,		"PACKET_RX_RING"	},
+	XLAT(PACKET_RX_RING),
 #endif
 #if defined(PACKET_STATISTICS)
-	{ PACKET_STATISTICS,		"PACKET_STATISTICS"	},
+	XLAT(PACKET_STATISTICS),
 #endif
 #if defined(PACKET_COPY_THRESH)
-	{ PACKET_COPY_THRESH,		"PACKET_COPY_THRESH"	},
+	XLAT(PACKET_COPY_THRESH),
 #endif
 #if defined(PACKET_AUXDATA)
-	{ PACKET_AUXDATA,		"PACKET_AUXDATA"	},
+	XLAT(PACKET_AUXDATA),
 #endif
 #if defined(PACKET_ORIGDEV)
-	{ PACKET_ORIGDEV,		"PACKET_ORIGDEV"	},
+	XLAT(PACKET_ORIGDEV),
 #endif
 #if defined(PACKET_VERSION)
-	{ PACKET_VERSION,		"PACKET_VERSION"	},
+	XLAT(PACKET_VERSION),
 #endif
 #if defined(PACKET_HDRLEN)
-	{ PACKET_HDRLEN,		"PACKET_HDRLEN"	},
+	XLAT(PACKET_HDRLEN),
 #endif
 #if defined(PACKET_RESERVE)
-	{ PACKET_RESERVE,		"PACKET_RESERVE"	},
+	XLAT(PACKET_RESERVE),
 #endif
 #if defined(PACKET_TX_RING)
-	{ PACKET_TX_RING,		"PACKET_TX_RING"	},
+	XLAT(PACKET_TX_RING),
 #endif
 #if defined(PACKET_LOSS)
-	{ PACKET_LOSS,			"PACKET_LOSS"	},
+	XLAT(PACKET_LOSS),
 #endif
 	{ 0,				NULL			},
 };
@@ -1047,123 +1047,123 @@ static const struct xlat sockpacketoptions[] = {
 #ifdef SOL_SCTP
 static const struct xlat socksctpoptions[] = {
 #if defined(SCTP_RTOINFO)
-	{ SCTP_RTOINFO,			"SCTP_RTOINFO"	},
+	XLAT(SCTP_RTOINFO),
 #endif
 #if defined(SCTP_ASSOCINFO)
-	{ SCTP_ASSOCINFO,		"SCTP_ASSOCINFO"},
+	XLAT(SCTP_ASSOCINFO),
 #endif
 #if defined(SCTP_INITMSG)
-	{ SCTP_INITMSG,			"SCTP_INITMSG"	},
+	XLAT(SCTP_INITMSG),
 #endif
 #if defined(SCTP_NODELAY)
-	{ SCTP_NODELAY,			"SCTP_NODELAY"	},
+	XLAT(SCTP_NODELAY),
 #endif
 #if defined(SCTP_AUTOCLOSE)
-	{ SCTP_AUTOCLOSE,		"SCTP_AUTOCLOSE"},
+	XLAT(SCTP_AUTOCLOSE),
 #endif
 #if defined(SCTP_SET_PEER_PRIMARY_ADDR)
-	{ SCTP_SET_PEER_PRIMARY_ADDR,	"SCTP_SET_PEER_PRIMARY_ADDR"},
+	XLAT(SCTP_SET_PEER_PRIMARY_ADDR),
 #endif
 #if defined(SCTP_PRIMARY_ADDR)
-	{ SCTP_PRIMARY_ADDR,		"SCTP_PRIMARY_ADDR"	},
+	XLAT(SCTP_PRIMARY_ADDR),
 #endif
 #if defined(SCTP_ADAPTATION_LAYER)
-	{ SCTP_ADAPTATION_LAYER,	"SCTP_ADAPTATION_LAYER"	},
+	XLAT(SCTP_ADAPTATION_LAYER),
 #endif
 #if defined(SCTP_DISABLE_FRAGMENTS)
-	{ SCTP_DISABLE_FRAGMENTS,	"SCTP_DISABLE_FRAGMENTS"},
+	XLAT(SCTP_DISABLE_FRAGMENTS),
 #endif
 #if defined(SCTP_PEER_ADDR_PARAMS)
-	{ SCTP_PEER_ADDR_PARAMS,	"SCTP_PEER_ADDR_PARAMS"	},
+	XLAT(SCTP_PEER_ADDR_PARAMS),
 #endif
 #if defined(SCTP_DEFAULT_SEND_PARAM)
-	{ SCTP_DEFAULT_SEND_PARAM,	"SCTP_DEFAULT_SEND_PARAM"},
+	XLAT(SCTP_DEFAULT_SEND_PARAM),
 #endif
 #if defined(SCTP_EVENTS)
-	{ SCTP_EVENTS,			"SCTP_EVENTS"		},
+	XLAT(SCTP_EVENTS),
 #endif
 #if defined(SCTP_I_WANT_MAPPED_V4_ADDR)
-	{ SCTP_I_WANT_MAPPED_V4_ADDR,	"SCTP_I_WANT_MAPPED_V4_ADDR"},
+	XLAT(SCTP_I_WANT_MAPPED_V4_ADDR),
 #endif
 #if defined(SCTP_MAXSEG)
-	{ SCTP_MAXSEG,			"SCTP_MAXSEG"		},
+	XLAT(SCTP_MAXSEG),
 #endif
 #if defined(SCTP_STATUS)
-	{ SCTP_STATUS,			"SCTP_STATUS"		},
+	XLAT(SCTP_STATUS),
 #endif
 #if defined(SCTP_GET_PEER_ADDR_INFO)
-	{ SCTP_GET_PEER_ADDR_INFO,	"SCTP_GET_PEER_ADDR_INFO"},
+	XLAT(SCTP_GET_PEER_ADDR_INFO),
 #endif
 #if defined(SCTP_DELAYED_ACK)
-	{ SCTP_DELAYED_ACK,		"SCTP_DELAYED_ACK"	},
+	XLAT(SCTP_DELAYED_ACK),
 #endif
 #if defined(SCTP_CONTEXT)
-	{ SCTP_CONTEXT,			"SCTP_CONTEXT"		},
+	XLAT(SCTP_CONTEXT),
 #endif
 #if defined(SCTP_FRAGMENT_INTERLEAVE)
-	{ SCTP_FRAGMENT_INTERLEAVE,	"SCTP_FRAGMENT_INTERLEAVE"},
+	XLAT(SCTP_FRAGMENT_INTERLEAVE),
 #endif
 #if defined(SCTP_PARTIAL_DELIVERY_POINT)
-	{ SCTP_PARTIAL_DELIVERY_POINT,	"SCTP_PARTIAL_DELIVERY_POINT"},
+	XLAT(SCTP_PARTIAL_DELIVERY_POINT),
 #endif
 #if defined(SCTP_MAX_BURST)
-	{ SCTP_MAX_BURST,		"SCTP_MAX_BURST"	},
+	XLAT(SCTP_MAX_BURST),
 #endif
 #if defined(SCTP_AUTH_CHUNK)
-	{ SCTP_AUTH_CHUNK,		"SCTP_AUTH_CHUNK"	},
+	XLAT(SCTP_AUTH_CHUNK),
 #endif
 #if defined(SCTP_HMAC_IDENT)
-	{ SCTP_HMAC_IDENT,		"SCTP_HMAC_IDENT"	},
+	XLAT(SCTP_HMAC_IDENT),
 #endif
 #if defined(SCTP_AUTH_KEY)
-	{ SCTP_AUTH_KEY,		"SCTP_AUTH_KEY"		},
+	XLAT(SCTP_AUTH_KEY),
 #endif
 #if defined(SCTP_AUTH_ACTIVE_KEY)
-	{ SCTP_AUTH_ACTIVE_KEY,		"SCTP_AUTH_ACTIVE_KEY"	},
+	XLAT(SCTP_AUTH_ACTIVE_KEY),
 #endif
 #if defined(SCTP_AUTH_DELETE_KEY)
-	{ SCTP_AUTH_DELETE_KEY,		"SCTP_AUTH_DELETE_KEY"	},
+	XLAT(SCTP_AUTH_DELETE_KEY),
 #endif
 #if defined(SCTP_PEER_AUTH_CHUNKS)
-	{ SCTP_PEER_AUTH_CHUNKS,	"SCTP_PEER_AUTH_CHUNKS"	},
+	XLAT(SCTP_PEER_AUTH_CHUNKS),
 #endif
 #if defined(SCTP_LOCAL_AUTH_CHUNKS)
-	{ SCTP_LOCAL_AUTH_CHUNKS,	"SCTP_LOCAL_AUTH_CHUNKS"},
+	XLAT(SCTP_LOCAL_AUTH_CHUNKS),
 #endif
 #if defined(SCTP_GET_ASSOC_NUMBER)
-	{ SCTP_GET_ASSOC_NUMBER,	"SCTP_GET_ASSOC_NUMBER"	},
+	XLAT(SCTP_GET_ASSOC_NUMBER),
 #endif
 
 	/* linux specific things */
 #if defined(SCTP_SOCKOPT_BINDX_ADD)
-	{ SCTP_SOCKOPT_BINDX_ADD,	"SCTP_SOCKOPT_BINDX_ADD"	},
+	XLAT(SCTP_SOCKOPT_BINDX_ADD),
 #endif
 #if defined(SCTP_SOCKOPT_BINDX_REM)
-	{ SCTP_SOCKOPT_BINDX_REM,	"SCTP_SOCKOPT_BINDX_REM"	},
+	XLAT(SCTP_SOCKOPT_BINDX_REM),
 #endif
 #if defined(SCTP_SOCKOPT_PEELOFF)
-	{ SCTP_SOCKOPT_PEELOFF,		"SCTP_SOCKOPT_PEELOFF"		},
+	XLAT(SCTP_SOCKOPT_PEELOFF),
 #endif
 #if defined(SCTP_GET_PEER_ADDRS_NUM_OLD)
-	{ SCTP_GET_PEER_ADDRS_NUM_OLD,	"SCTP_GET_PEER_ADDRS_NUM_OLD"	},
+	XLAT(SCTP_GET_PEER_ADDRS_NUM_OLD),
 #endif
 #if defined(SCTP_GET_PEER_ADDRS_OLD)
-	{ SCTP_GET_PEER_ADDRS_OLD,	"SCTP_GET_PEER_ADDRS_OLD"	},
+	XLAT(SCTP_GET_PEER_ADDRS_OLD),
 #endif
 #if defined(SCTP_GET_LOCAL_ADDRS_NUM_OLD)
-	{ SCTP_GET_LOCAL_ADDRS_NUM_OLD,	"SCTP_GET_LOCAL_ADDRS_NUM_OLD"	},
+	XLAT(SCTP_GET_LOCAL_ADDRS_NUM_OLD),
 #endif
 #if defined(SCTP_GET_LOCAL_ADDRS_OLD)
-	{ SCTP_GET_LOCAL_ADDRS_OLD,	"SCTP_GET_LOCAL_ADDRS_OLD"	},
+	XLAT(SCTP_GET_LOCAL_ADDRS_OLD),
 #endif
 #if defined(SCTP_SOCKOPT_CONNECTX_OLD)
-	{ SCTP_SOCKOPT_CONNECTX_OLD,	"SCTP_SOCKOPT_CONNECTX_OLD"	},
+	XLAT(SCTP_SOCKOPT_CONNECTX_OLD),
 #endif
 #if defined(SCTP_GET_PEER_ADDRS)
-	{ SCTP_GET_PEER_ADDRS,		"SCTP_GET_PEER_ADDRS"		},
+	XLAT(SCTP_GET_PEER_ADDRS),
 #endif
 #if defined(SCTP_GET_LOCAL_ADDRS)
-	{ SCTP_GET_LOCAL_ADDRS,		"SCTP_GET_LOCAL_ADDRS"		},
+	XLAT(SCTP_GET_LOCAL_ADDRS),
 #endif
 
 	{ 0,	NULL	},
@@ -1176,73 +1176,73 @@ static const struct xlat socksctpoptions[] = {
 
 #ifdef SOL_TCP
 static const struct xlat socktcpoptions[] = {
-	{ TCP_NODELAY,		"TCP_NODELAY"	},
-	{ TCP_MAXSEG,		"TCP_MAXSEG"	},
+	XLAT(TCP_NODELAY),
+	XLAT(TCP_MAXSEG),
 #ifdef TCP_CORK
-	{ TCP_CORK,		"TCP_CORK"	},
+	XLAT(TCP_CORK),
 #endif
 #ifdef TCP_KEEPIDLE
-	{ TCP_KEEPIDLE,		"TCP_KEEPIDLE"	},
+	XLAT(TCP_KEEPIDLE),
 #endif
 #ifdef TCP_KEEPINTVL
-	{ TCP_KEEPINTVL,	"TCP_KEEPINTVL"	},
+	XLAT(TCP_KEEPINTVL),
 #endif
 #ifdef TCP_KEEPCNT
-	{ TCP_KEEPCNT,		"TCP_KEEPCNT"	},
+	XLAT(TCP_KEEPCNT),
 #endif
 #ifdef TCP_SYNCNT
-	{ TCP_SYNCNT,		"TCP_SYNCNT"	},
+	XLAT(TCP_SYNCNT),
 #endif
 #ifdef TCP_LINGER2
-	{ TCP_LINGER2,		"TCP_LINGER2"	},
+	XLAT(TCP_LINGER2),
 #endif
 #ifdef TCP_DEFER_ACCEPT
-	{ TCP_DEFER_ACCEPT,	"TCP_DEFER_ACCEPT"	},
+	XLAT(TCP_DEFER_ACCEPT),
 #endif
 #ifdef TCP_WINDOW_CLAMP
-	{ TCP_WINDOW_CLAMP,	"TCP_WINDOW_CLAMP"	},
+	XLAT(TCP_WINDOW_CLAMP),
 #endif
 #ifdef TCP_INFO
-	{ TCP_INFO,		"TCP_INFO"	},
+	XLAT(TCP_INFO),
 #endif
 #ifdef TCP_QUICKACK
-	{ TCP_QUICKACK,		"TCP_QUICKACK"	},
+	XLAT(TCP_QUICKACK),
 #endif
 #ifdef TCP_CONGESTION
-	{ TCP_CONGESTION,	"TCP_CONGESTION"	},
+	XLAT(TCP_CONGESTION),
 #endif
 #ifdef TCP_MD5SIG
-	{ TCP_MD5SIG,		"TCP_MD5SIG"	},
+	XLAT(TCP_MD5SIG),
 #endif
 #ifdef TCP_COOKIE_TRANSACTIONS
-	{ TCP_COOKIE_TRANSACTIONS,	"TCP_COOKIE_TRANSACTIONS"	},
+	XLAT(TCP_COOKIE_TRANSACTIONS),
 #endif
 #ifdef TCP_THIN_LINEAR_TIMEOUTS
-	{ TCP_THIN_LINEAR_TIMEOUTS,	"TCP_THIN_LINEAR_TIMEOUTS"	},
+	XLAT(TCP_THIN_LINEAR_TIMEOUTS),
 #endif
 #ifdef TCP_THIN_DUPACK
-	{ TCP_THIN_DUPACK,	"TCP_THIN_DUPACK"	},
+	XLAT(TCP_THIN_DUPACK),
 #endif
 #ifdef TCP_USER_TIMEOUT
-	{ TCP_USER_TIMEOUT,	"TCP_USER_TIMEOUT"	},
+	XLAT(TCP_USER_TIMEOUT),
 #endif
 #ifdef TCP_REPAIR
-	{ TCP_REPAIR,		"TCP_REPAIR"	},
+	XLAT(TCP_REPAIR),
 #endif
 #ifdef TCP_REPAIR_QUEUE
-	{ TCP_REPAIR_QUEUE,	"TCP_REPAIR_QUEUE"	},
+	XLAT(TCP_REPAIR_QUEUE),
 #endif
 #ifdef TCP_QUEUE_SEQ
-	{ TCP_QUEUE_SEQ,	"TCP_QUEUE_SEQ"	},
+	XLAT(TCP_QUEUE_SEQ),
 #endif
 #ifdef TCP_REPAIR_OPTIONS
-	{ TCP_REPAIR_OPTIONS,	"TCP_REPAIR_OPTIONS"	},
+	XLAT(TCP_REPAIR_OPTIONS),
 #endif
 #ifdef TCP_FASTOPEN
-	{ TCP_FASTOPEN,		"TCP_FASTOPEN"	},
+	XLAT(TCP_FASTOPEN),
 #endif
 #ifdef TCP_TIMESTAMP
-	{ TCP_TIMESTAMP,	"TCP_TIMESTAMP"	},
+	XLAT(TCP_TIMESTAMP),
 #endif
 	{ 0,			NULL		},
 };
@@ -1296,25 +1296,25 @@ static const struct xlat icmpfilterflags[] = {
 #if defined(AF_PACKET) /* from e.g. linux/if_packet.h */
 static const struct xlat af_packet_types[] = {
 #if defined(PACKET_HOST)
-	{ PACKET_HOST,			"PACKET_HOST"		},
+	XLAT(PACKET_HOST),
 #endif
 #if defined(PACKET_BROADCAST)
-	{ PACKET_BROADCAST,		"PACKET_BROADCAST"	},
+	XLAT(PACKET_BROADCAST),
 #endif
 #if defined(PACKET_MULTICAST)
-	{ PACKET_MULTICAST,		"PACKET_MULTICAST"	},
+	XLAT(PACKET_MULTICAST),
 #endif
 #if defined(PACKET_OTHERHOST)
-	{ PACKET_OTHERHOST,		"PACKET_OTHERHOST"	},
+	XLAT(PACKET_OTHERHOST),
 #endif
 #if defined(PACKET_OUTGOING)
-	{ PACKET_OUTGOING,		"PACKET_OUTGOING"	},
+	XLAT(PACKET_OUTGOING),
 #endif
 #if defined(PACKET_LOOPBACK)
-	{ PACKET_LOOPBACK,		"PACKET_LOOPBACK"	},
+	XLAT(PACKET_LOOPBACK),
 #endif
 #if defined(PACKET_FASTROUTE)
-	{ PACKET_FASTROUTE,		"PACKET_FASTROUTE"	},
+	XLAT(PACKET_FASTROUTE),
 #endif
 	{ 0,				NULL			},
 };
@@ -1466,10 +1466,10 @@ printsock(struct tcb *tcp, long addr, int addrlen)
 #if HAVE_SENDMSG
 static const struct xlat scmvals[] = {
 #ifdef SCM_RIGHTS
-	{ SCM_RIGHTS,		"SCM_RIGHTS"		},
+	XLAT(SCM_RIGHTS),
 #endif
 #ifdef SCM_CREDENTIALS
-	{ SCM_CREDENTIALS,	"SCM_CREDENTIALS"	},
+	XLAT(SCM_CREDENTIALS),
 #endif
 	{ 0,			NULL			}
 };
diff --git a/process.c b/process.c
index 5a648a9..883f5b8 100644
--- a/process.c
+++ b/process.c
@@ -107,173 +107,173 @@
 
 static const struct xlat prctl_options[] = {
 #ifdef PR_MAXPROCS
-	{ PR_MAXPROCS,		"PR_MAXPROCS"		},
+	XLAT(PR_MAXPROCS),
 #endif
 #ifdef PR_ISBLOCKED
-	{ PR_ISBLOCKED,		"PR_ISBLOCKED"		},
+	XLAT(PR_ISBLOCKED),
 #endif
 #ifdef PR_SETSTACKSIZE
-	{ PR_SETSTACKSIZE,	"PR_SETSTACKSIZE"	},
+	XLAT(PR_SETSTACKSIZE),
 #endif
 #ifdef PR_GETSTACKSIZE
-	{ PR_GETSTACKSIZE,	"PR_GETSTACKSIZE"	},
+	XLAT(PR_GETSTACKSIZE),
 #endif
 #ifdef PR_MAXPPROCS
-	{ PR_MAXPPROCS,		"PR_MAXPPROCS"		},
+	XLAT(PR_MAXPPROCS),
 #endif
 #ifdef PR_UNBLKONEXEC
-	{ PR_UNBLKONEXEC,	"PR_UNBLKONEXEC"	},
+	XLAT(PR_UNBLKONEXEC),
 #endif
 #ifdef PR_ATOMICSIM
-	{ PR_ATOMICSIM,		"PR_ATOMICSIM"		},
+	XLAT(PR_ATOMICSIM),
 #endif
 #ifdef PR_SETEXITSIG
-	{ PR_SETEXITSIG,	"PR_SETEXITSIG"		},
+	XLAT(PR_SETEXITSIG),
 #endif
 #ifdef PR_RESIDENT
-	{ PR_RESIDENT,		"PR_RESIDENT"		},
+	XLAT(PR_RESIDENT),
 #endif
 #ifdef PR_ATTACHADDR
-	{ PR_ATTACHADDR,	"PR_ATTACHADDR"		},
+	XLAT(PR_ATTACHADDR),
 #endif
 #ifdef PR_DETACHADDR
-	{ PR_DETACHADDR,	"PR_DETACHADDR"		},
+	XLAT(PR_DETACHADDR),
 #endif
 #ifdef PR_TERMCHILD
-	{ PR_TERMCHILD,		"PR_TERMCHILD"		},
+	XLAT(PR_TERMCHILD),
 #endif
 #ifdef PR_GETSHMASK
-	{ PR_GETSHMASK,		"PR_GETSHMASK"		},
+	XLAT(PR_GETSHMASK),
 #endif
 #ifdef PR_GETNSHARE
-	{ PR_GETNSHARE,		"PR_GETNSHARE"		},
+	XLAT(PR_GETNSHARE),
 #endif
 #ifdef PR_COREPID
-	{ PR_COREPID,		"PR_COREPID"		},
+	XLAT(PR_COREPID),
 #endif
 #ifdef PR_ATTACHADDRPERM
-	{ PR_ATTACHADDRPERM,	"PR_ATTACHADDRPERM"	},
+	XLAT(PR_ATTACHADDRPERM),
 #endif
 #ifdef PR_PTHREADEXIT
-	{ PR_PTHREADEXIT,	"PR_PTHREADEXIT"	},
+	XLAT(PR_PTHREADEXIT),
 #endif
 
 #ifdef PR_SET_PDEATHSIG
-	{ PR_SET_PDEATHSIG,	"PR_SET_PDEATHSIG"	},
+	XLAT(PR_SET_PDEATHSIG),
 #endif
 #ifdef PR_GET_PDEATHSIG
-	{ PR_GET_PDEATHSIG,	"PR_GET_PDEATHSIG"	},
+	XLAT(PR_GET_PDEATHSIG),
 #endif
 #ifdef PR_GET_DUMPABLE
-	{ PR_GET_DUMPABLE,	"PR_GET_DUMPABLE"	},
+	XLAT(PR_GET_DUMPABLE),
 #endif
 #ifdef PR_SET_DUMPABLE
-	{ PR_SET_DUMPABLE,	"PR_SET_DUMPABLE"	},
+	XLAT(PR_SET_DUMPABLE),
 #endif
 #ifdef PR_GET_UNALIGN
-	{ PR_GET_UNALIGN,	"PR_GET_UNALIGN"	},
+	XLAT(PR_GET_UNALIGN),
 #endif
 #ifdef PR_SET_UNALIGN
-	{ PR_SET_UNALIGN,	"PR_SET_UNALIGN"	},
+	XLAT(PR_SET_UNALIGN),
 #endif
 #ifdef PR_GET_KEEPCAPS
-	{ PR_GET_KEEPCAPS,	"PR_GET_KEEPCAPS"	},
+	XLAT(PR_GET_KEEPCAPS),
 #endif
 #ifdef PR_SET_KEEPCAPS
-	{ PR_SET_KEEPCAPS,	"PR_SET_KEEPCAPS"	},
+	XLAT(PR_SET_KEEPCAPS),
 #endif
 #ifdef PR_GET_FPEMU
-	{ PR_GET_FPEMU,		"PR_GET_FPEMU"		},
+	XLAT(PR_GET_FPEMU),
 #endif
 #ifdef PR_SET_FPEMU
-	{ PR_SET_FPEMU,		"PR_SET_FPEMU"		},
+	XLAT(PR_SET_FPEMU),
 #endif
 #ifdef PR_GET_FPEXC
-	{ PR_GET_FPEXC,		"PR_GET_FPEXC"		},
+	XLAT(PR_GET_FPEXC),
 #endif
 #ifdef PR_SET_FPEXC
-	{ PR_SET_FPEXC,		"PR_SET_FPEXC"		},
+	XLAT(PR_SET_FPEXC),
 #endif
 #ifdef PR_GET_TIMING
-	{ PR_GET_TIMING,	"PR_GET_TIMING"		},
+	XLAT(PR_GET_TIMING),
 #endif
 #ifdef PR_SET_TIMING
-	{ PR_SET_TIMING,	"PR_SET_TIMING"		},
+	XLAT(PR_SET_TIMING),
 #endif
 #ifdef PR_SET_NAME
-	{ PR_SET_NAME,		"PR_SET_NAME"		},
+	XLAT(PR_SET_NAME),
 #endif
 #ifdef PR_GET_NAME
-	{ PR_GET_NAME,		"PR_GET_NAME"		},
+	XLAT(PR_GET_NAME),
 #endif
 #ifdef PR_GET_ENDIAN
-	{ PR_GET_ENDIAN,	"PR_GET_ENDIAN"		},
+	XLAT(PR_GET_ENDIAN),
 #endif
 #ifdef PR_SET_ENDIAN
-	{ PR_SET_ENDIAN,	"PR_SET_ENDIAN"		},
+	XLAT(PR_SET_ENDIAN),
 #endif
 #ifdef PR_GET_SECCOMP
-	{ PR_GET_SECCOMP,	"PR_GET_SECCOMP"	},
+	XLAT(PR_GET_SECCOMP),
 #endif
 #ifdef PR_SET_SECCOMP
-	{ PR_SET_SECCOMP,	"PR_SET_SECCOMP"	},
+	XLAT(PR_SET_SECCOMP),
 #endif
 #ifdef PR_CAPBSET_READ
-	{ PR_CAPBSET_READ,	"PR_CAPBSET_READ"	},
+	XLAT(PR_CAPBSET_READ),
 #endif
 #ifdef PR_CAPBSET_DROP
-	{ PR_CAPBSET_DROP,	"PR_CAPBSET_DROP"	},
+	XLAT(PR_CAPBSET_DROP),
 #endif
 #ifdef PR_GET_TSC
-	{ PR_GET_TSC,		"PR_GET_TSC"		},
+	XLAT(PR_GET_TSC),
 #endif
 #ifdef PR_SET_TSC
-	{ PR_SET_TSC,		"PR_SET_TSC"		},
+	XLAT(PR_SET_TSC),
 #endif
 #ifdef PR_GET_SECUREBITS
-	{ PR_GET_SECUREBITS,	"PR_GET_SECUREBITS"	},
+	XLAT(PR_GET_SECUREBITS),
 #endif
 #ifdef PR_SET_SECUREBITS
-	{ PR_SET_SECUREBITS,	"PR_SET_SECUREBITS"	},
+	XLAT(PR_SET_SECUREBITS),
 #endif
 #ifdef PR_SET_TIMERSLACK
-	{ PR_SET_TIMERSLACK,	"PR_SET_TIMERSLACK"	},
+	XLAT(PR_SET_TIMERSLACK),
 #endif
 #ifdef PR_GET_TIMERSLACK
-	{ PR_GET_TIMERSLACK,	"PR_GET_TIMERSLACK"	},
+	XLAT(PR_GET_TIMERSLACK),
 #endif
 #ifdef PR_TASK_PERF_EVENTS_DISABLE
-	{ PR_TASK_PERF_EVENTS_DISABLE,	"PR_TASK_PERF_EVENTS_DISABLE"	},
+	XLAT(PR_TASK_PERF_EVENTS_DISABLE),
 #endif
 #ifdef PR_TASK_PERF_EVENTS_ENABLE
-	{ PR_TASK_PERF_EVENTS_ENABLE,	"PR_TASK_PERF_EVENTS_ENABLE"	},
+	XLAT(PR_TASK_PERF_EVENTS_ENABLE),
 #endif
 #ifdef PR_MCE_KILL
-	{ PR_MCE_KILL,		"PR_MCE_KILL"		},
+	XLAT(PR_MCE_KILL),
 #endif
 #ifdef PR_MCE_KILL_GET
-	{ PR_MCE_KILL_GET,	"PR_MCE_KILL_GET"	},
+	XLAT(PR_MCE_KILL_GET),
 #endif
 #ifdef PR_SET_MM
-	{ PR_SET_MM,		"PR_SET_MM"		},
+	XLAT(PR_SET_MM),
 #endif
 #ifdef PR_SET_PTRACER
-	{ PR_SET_PTRACER,	"PR_SET_PTRACER"	},
+	XLAT(PR_SET_PTRACER),
 #endif
 #ifdef PR_SET_CHILD_SUBREAPER
-	{ PR_SET_CHILD_SUBREAPER,	"PR_SET_CHILD_SUBREAPER"	},
+	XLAT(PR_SET_CHILD_SUBREAPER),
 #endif
 #ifdef PR_GET_CHILD_SUBREAPER
-	{ PR_GET_CHILD_SUBREAPER,	"PR_GET_CHILD_SUBREAPER"	},
+	XLAT(PR_GET_CHILD_SUBREAPER),
 #endif
 #ifdef PR_SET_NO_NEW_PRIVS
-	{ PR_SET_NO_NEW_PRIVS,	"PR_SET_NO_NEW_PRIVS"	},
+	XLAT(PR_SET_NO_NEW_PRIVS),
 #endif
 #ifdef PR_GET_NO_NEW_PRIVS
-	{ PR_GET_NO_NEW_PRIVS,	"PR_GET_NO_NEW_PRIVS"	},
+	XLAT(PR_GET_NO_NEW_PRIVS),
 #endif
 #ifdef PR_GET_TID_ADDRESS
-	{ PR_GET_TID_ADDRESS,	"PR_GET_TID_ADDRESS"	},
+	XLAT(PR_GET_TID_ADDRESS),
 #endif
 	{ 0,			NULL			},
 };
@@ -465,29 +465,29 @@ sys_exit(struct tcb *tcp)
 #define CLONE_IO		0x80000000	/* Clone io context */
 
 static const struct xlat clone_flags[] = {
-	{ CLONE_VM,		"CLONE_VM"	},
-	{ CLONE_FS,		"CLONE_FS"	},
-	{ CLONE_FILES,		"CLONE_FILES"	},
-	{ CLONE_SIGHAND,	"CLONE_SIGHAND"	},
-	{ CLONE_IDLETASK,	"CLONE_IDLETASK" },
-	{ CLONE_PTRACE,		"CLONE_PTRACE"	},
-	{ CLONE_VFORK,		"CLONE_VFORK"	},
-	{ CLONE_PARENT,		"CLONE_PARENT"	},
-	{ CLONE_THREAD,		"CLONE_THREAD"	},
-	{ CLONE_NEWNS,		"CLONE_NEWNS"	},
-	{ CLONE_SYSVSEM,	"CLONE_SYSVSEM"	},
-	{ CLONE_SETTLS,		"CLONE_SETTLS"	},
-	{ CLONE_PARENT_SETTID,	"CLONE_PARENT_SETTID" },
-	{ CLONE_CHILD_CLEARTID,	"CLONE_CHILD_CLEARTID" },
-	{ CLONE_UNTRACED,	"CLONE_UNTRACED" },
-	{ CLONE_CHILD_SETTID,	"CLONE_CHILD_SETTID" },
-	{ CLONE_STOPPED,	"CLONE_STOPPED"	},
-	{ CLONE_NEWUTS,		"CLONE_NEWUTS"	},
-	{ CLONE_NEWIPC,		"CLONE_NEWIPC"	},
-	{ CLONE_NEWUSER,	"CLONE_NEWUSER"	},
-	{ CLONE_NEWPID,		"CLONE_NEWPID"	},
-	{ CLONE_NEWNET,		"CLONE_NEWNET"	},
-	{ CLONE_IO,		"CLONE_IO"	},
+	XLAT(CLONE_VM),
+	XLAT(CLONE_FS),
+	XLAT(CLONE_FILES),
+	XLAT(CLONE_SIGHAND),
+	XLAT(CLONE_IDLETASK),
+	XLAT(CLONE_PTRACE),
+	XLAT(CLONE_VFORK),
+	XLAT(CLONE_PARENT),
+	XLAT(CLONE_THREAD),
+	XLAT(CLONE_NEWNS),
+	XLAT(CLONE_SYSVSEM),
+	XLAT(CLONE_SETTLS),
+	XLAT(CLONE_PARENT_SETTID),
+	XLAT(CLONE_CHILD_CLEARTID),
+	XLAT(CLONE_UNTRACED),
+	XLAT(CLONE_CHILD_SETTID),
+	XLAT(CLONE_STOPPED),
+	XLAT(CLONE_NEWUTS),
+	XLAT(CLONE_NEWIPC),
+	XLAT(CLONE_NEWUSER),
+	XLAT(CLONE_NEWPID),
+	XLAT(CLONE_NEWNET),
+	XLAT(CLONE_IO),
 	{ 0,			NULL		},
 };
 
@@ -1004,33 +1004,33 @@ sys_execve(struct tcb *tcp)
 #endif
 
 static const struct xlat wait4_options[] = {
-	{ WNOHANG,	"WNOHANG"	},
+	XLAT(WNOHANG),
 #ifndef WSTOPPED
-	{ WUNTRACED,	"WUNTRACED"	},
+	XLAT(WUNTRACED),
 #endif
 #ifdef WEXITED
-	{ WEXITED,	"WEXITED"	},
+	XLAT(WEXITED),
 #endif
 #ifdef WTRAPPED
-	{ WTRAPPED,	"WTRAPPED"	},
+	XLAT(WTRAPPED),
 #endif
 #ifdef WSTOPPED
-	{ WSTOPPED,	"WSTOPPED"	},
+	XLAT(WSTOPPED),
 #endif
 #ifdef WCONTINUED
-	{ WCONTINUED,	"WCONTINUED"	},
+	XLAT(WCONTINUED),
 #endif
 #ifdef WNOWAIT
-	{ WNOWAIT,	"WNOWAIT"	},
+	XLAT(WNOWAIT),
 #endif
 #ifdef __WCLONE
-	{ __WCLONE,	"__WCLONE"	},
+	XLAT(__WCLONE),
 #endif
 #ifdef __WALL
-	{ __WALL,	"__WALL"	},
+	XLAT(__WALL),
 #endif
 #ifdef __WNOTHREAD
-	{ __WNOTHREAD,	"__WNOTHREAD"	},
+	XLAT(__WNOTHREAD),
 #endif
 	{ 0,		NULL		},
 };
@@ -1159,26 +1159,26 @@ sys_osf_wait4(struct tcb *tcp)
 #endif
 
 static const struct xlat waitid_types[] = {
-	{ P_PID,	"P_PID"		},
+	XLAT(P_PID),
 #ifdef P_PPID
-	{ P_PPID,	"P_PPID"	},
+	XLAT(P_PPID),
 #endif
-	{ P_PGID,	"P_PGID"	},
+	XLAT(P_PGID),
 #ifdef P_SID
-	{ P_SID,	"P_SID"		},
+	XLAT(P_SID),
 #endif
 #ifdef P_CID
-	{ P_CID,	"P_CID"		},
+	XLAT(P_CID),
 #endif
 #ifdef P_UID
-	{ P_UID,	"P_UID"		},
+	XLAT(P_UID),
 #endif
 #ifdef P_GID
-	{ P_GID,	"P_GID"		},
+	XLAT(P_GID),
 #endif
-	{ P_ALL,	"P_ALL"		},
+	XLAT(P_ALL),
 #ifdef P_LWPID
-	{ P_LWPID,	"P_LWPID"	},
+	XLAT(P_LWPID),
 #endif
 	{ 0,		NULL		},
 };
@@ -1239,73 +1239,73 @@ sys_uname(struct tcb *tcp)
 }
 
 static const struct xlat ptrace_cmds[] = {
-	{ PTRACE_TRACEME,	"PTRACE_TRACEME"	},
-	{ PTRACE_PEEKTEXT,	"PTRACE_PEEKTEXT"	},
-	{ PTRACE_PEEKDATA,	"PTRACE_PEEKDATA"	},
-	{ PTRACE_PEEKUSER,	"PTRACE_PEEKUSER"	},
-	{ PTRACE_POKETEXT,	"PTRACE_POKETEXT"	},
-	{ PTRACE_POKEDATA,	"PTRACE_POKEDATA"	},
-	{ PTRACE_POKEUSER,	"PTRACE_POKEUSER"	},
-	{ PTRACE_CONT,		"PTRACE_CONT"		},
-	{ PTRACE_KILL,		"PTRACE_KILL"		},
-	{ PTRACE_SINGLESTEP,	"PTRACE_SINGLESTEP"	},
-	{ PTRACE_ATTACH,	"PTRACE_ATTACH"		},
-	{ PTRACE_DETACH,	"PTRACE_DETACH"		},
+	XLAT(PTRACE_TRACEME),
+	XLAT(PTRACE_PEEKTEXT),
+	XLAT(PTRACE_PEEKDATA),
+	XLAT(PTRACE_PEEKUSER),
+	XLAT(PTRACE_POKETEXT),
+	XLAT(PTRACE_POKEDATA),
+	XLAT(PTRACE_POKEUSER),
+	XLAT(PTRACE_CONT),
+	XLAT(PTRACE_KILL),
+	XLAT(PTRACE_SINGLESTEP),
+	XLAT(PTRACE_ATTACH),
+	XLAT(PTRACE_DETACH),
 #ifdef PTRACE_GETREGS
-	{ PTRACE_GETREGS,	"PTRACE_GETREGS"	},
+	XLAT(PTRACE_GETREGS),
 #endif
 #ifdef PTRACE_SETREGS
-	{ PTRACE_SETREGS,	"PTRACE_SETREGS"	},
+	XLAT(PTRACE_SETREGS),
 #endif
 #ifdef PTRACE_GETFPREGS
-	{ PTRACE_GETFPREGS,	"PTRACE_GETFPREGS"	},
+	XLAT(PTRACE_GETFPREGS),
 #endif
 #ifdef PTRACE_SETFPREGS
-	{ PTRACE_SETFPREGS,	"PTRACE_SETFPREGS"	},
+	XLAT(PTRACE_SETFPREGS),
 #endif
 #ifdef PTRACE_GETFPXREGS
-	{ PTRACE_GETFPXREGS,	"PTRACE_GETFPXREGS"	},
+	XLAT(PTRACE_GETFPXREGS),
 #endif
 #ifdef PTRACE_SETFPXREGS
-	{ PTRACE_SETFPXREGS,	"PTRACE_SETFPXREGS"	},
+	XLAT(PTRACE_SETFPXREGS),
 #endif
 #ifdef PTRACE_GETVRREGS
-	{ PTRACE_GETVRREGS,	"PTRACE_GETVRREGS"	},
+	XLAT(PTRACE_GETVRREGS),
 #endif
 #ifdef PTRACE_SETVRREGS
-	{ PTRACE_SETVRREGS,	"PTRACE_SETVRREGS"	},
+	XLAT(PTRACE_SETVRREGS),
 #endif
 #ifdef PTRACE_SETOPTIONS
-	{ PTRACE_SETOPTIONS,	"PTRACE_SETOPTIONS"	},
+	XLAT(PTRACE_SETOPTIONS),
 #endif
 #ifdef PTRACE_GETEVENTMSG
-	{ PTRACE_GETEVENTMSG,	"PTRACE_GETEVENTMSG"	},
+	XLAT(PTRACE_GETEVENTMSG),
 #endif
 #ifdef PTRACE_GETSIGINFO
-	{ PTRACE_GETSIGINFO,	"PTRACE_GETSIGINFO"	},
+	XLAT(PTRACE_GETSIGINFO),
 #endif
 #ifdef PTRACE_SETSIGINFO
-	{ PTRACE_SETSIGINFO,	"PTRACE_SETSIGINFO"	},
+	XLAT(PTRACE_SETSIGINFO),
 #endif
 #ifdef PTRACE_GETREGSET
-	{ PTRACE_GETREGSET,	"PTRACE_GETREGSET"	},
+	XLAT(PTRACE_GETREGSET),
 #endif
 #ifdef PTRACE_SETREGSET
-	{ PTRACE_SETREGSET,	"PTRACE_SETREGSET"	},
+	XLAT(PTRACE_SETREGSET),
 #endif
 #ifdef PTRACE_SET_SYSCALL
-	{ PTRACE_SET_SYSCALL,	"PTRACE_SET_SYSCALL"	},
+	XLAT(PTRACE_SET_SYSCALL),
 #endif
 #ifdef PTRACE_SEIZE
-	{ PTRACE_SEIZE,		"PTRACE_SEIZE"		},
+	XLAT(PTRACE_SEIZE),
 #endif
 #ifdef PTRACE_INTERRUPT
-	{ PTRACE_INTERRUPT,	"PTRACE_INTERRUPT"	},
+	XLAT(PTRACE_INTERRUPT),
 #endif
 #ifdef PTRACE_LISTEN
-	{ PTRACE_LISTEN,	"PTRACE_LISTEN"		},
+	XLAT(PTRACE_LISTEN),
 #endif
-	{ PTRACE_SYSCALL,	"PTRACE_SYSCALL"	},
+	XLAT(PTRACE_SYSCALL),
 
 	{ 0,			NULL			},
 };
@@ -1313,31 +1313,31 @@ static const struct xlat ptrace_cmds[] = {
 #ifdef PTRACE_SETOPTIONS
 static const struct xlat ptrace_setoptions_flags[] = {
 # ifdef PTRACE_O_TRACESYSGOOD
-	{ PTRACE_O_TRACESYSGOOD,"PTRACE_O_TRACESYSGOOD"	},
+	XLAT(PTRACE_O_TRACESYSGOOD),
 # endif
 # ifdef PTRACE_O_TRACEFORK
-	{ PTRACE_O_TRACEFORK,	"PTRACE_O_TRACEFORK"	},
+	XLAT(PTRACE_O_TRACEFORK),
 # endif
 # ifdef PTRACE_O_TRACEVFORK
-	{ PTRACE_O_TRACEVFORK,	"PTRACE_O_TRACEVFORK"	},
+	XLAT(PTRACE_O_TRACEVFORK),
 # endif
 # ifdef PTRACE_O_TRACECLONE
-	{ PTRACE_O_TRACECLONE,	"PTRACE_O_TRACECLONE"	},
+	XLAT(PTRACE_O_TRACECLONE),
 # endif
 # ifdef PTRACE_O_TRACEEXEC
-	{ PTRACE_O_TRACEEXEC,	"PTRACE_O_TRACEEXEC"	},
+	XLAT(PTRACE_O_TRACEEXEC),
 # endif
 # ifdef PTRACE_O_TRACEVFORKDONE
-	{ PTRACE_O_TRACEVFORKDONE,"PTRACE_O_TRACEVFORKDONE"},
+	XLAT(PTRACE_O_TRACEVFORKDONE),
 # endif
 # ifdef PTRACE_O_TRACEEXIT
-	{ PTRACE_O_TRACEEXIT,	"PTRACE_O_TRACEEXIT"	},
+	XLAT(PTRACE_O_TRACEEXIT),
 # endif
 # ifdef PTRACE_O_TRACESECCOMP
-	{ PTRACE_O_TRACESECCOMP,"PTRACE_O_TRACESECCOMP"	},
+	XLAT(PTRACE_O_TRACESECCOMP),
 # endif
 # ifdef PTRACE_O_EXITKILL
-	{ PTRACE_O_EXITKILL,	"PTRACE_O_EXITKILL"	},
+	XLAT(PTRACE_O_EXITKILL),
 # endif
 	{ 0,			NULL			},
 };
@@ -1345,73 +1345,73 @@ static const struct xlat ptrace_setoptions_flags[] = {
 
 static const struct xlat nt_descriptor_types[] = {
 #ifdef NT_PRSTATUS
-	{ NT_PRSTATUS,		"NT_PRSTATUS" },
+	XLAT(NT_PRSTATUS),
 #endif
 #ifdef NT_FPREGSET
-	{ NT_FPREGSET,		"NT_FPREGSET" },
+	XLAT(NT_FPREGSET),
 #endif
 #ifdef NT_PRPSINFO
-	{ NT_PRPSINFO,		"NT_PRPSINFO" },
+	XLAT(NT_PRPSINFO),
 #endif
 #ifdef NT_PRXREG
-	{ NT_PRXREG,		"NT_PRXREG" },
+	XLAT(NT_PRXREG),
 #endif
 #ifdef NT_TASKSTRUCT
-	{ NT_TASKSTRUCT,	"NT_TASKSTRUCT" },
+	XLAT(NT_TASKSTRUCT),
 #endif
 #ifdef NT_PLATFORM
-	{ NT_PLATFORM,		"NT_PLATFORM" },
+	XLAT(NT_PLATFORM),
 #endif
 #ifdef NT_AUXV
-	{ NT_AUXV,		"NT_AUXV" },
+	XLAT(NT_AUXV),
 #endif
 #ifdef NT_GWINDOWS
-	{ NT_GWINDOWS,		"NT_GWINDOWS" },
+	XLAT(NT_GWINDOWS),
 #endif
 #ifdef NT_ASRS
-	{ NT_ASRS,		"NT_ASRS" },
+	XLAT(NT_ASRS),
 #endif
 #ifdef NT_PSTATUS
-	{ NT_PSTATUS,		"NT_PSTATUS" },
+	XLAT(NT_PSTATUS),
 #endif
 #ifdef NT_PSINFO
-	{ NT_PSINFO,		"NT_PSINFO" },
+	XLAT(NT_PSINFO),
 #endif
 #ifdef NT_PRCRED
-	{ NT_PRCRED,		"NT_PRCRED" },
+	XLAT(NT_PRCRED),
 #endif
 #ifdef NT_UTSNAME
-	{ NT_UTSNAME,		"NT_UTSNAME" },
+	XLAT(NT_UTSNAME),
 #endif
 #ifdef NT_LWPSTATUS
-	{ NT_LWPSTATUS,		"NT_LWPSTATUS" },
+	XLAT(NT_LWPSTATUS),
 #endif
 #ifdef NT_LWPSINFO
-	{ NT_LWPSINFO,		"NT_LWPSINFO" },
+	XLAT(NT_LWPSINFO),
 #endif
 #ifdef NT_PRFPXREG
-	{ NT_PRFPXREG,		"NT_PRFPXREG" },
+	XLAT(NT_PRFPXREG),
 #endif
 #ifdef NT_PRXFPREG
-	{ NT_PRXFPREG,		"NT_PRXFPREG" },
+	XLAT(NT_PRXFPREG),
 #endif
 #ifdef NT_PPC_VMX
-	{ NT_PPC_VMX,		"NT_PPC_VMX" },
+	XLAT(NT_PPC_VMX),
 #endif
 #ifdef NT_PPC_SPE
-	{ NT_PPC_SPE,		"NT_PPC_SPE" },
+	XLAT(NT_PPC_SPE),
 #endif
 #ifdef NT_PPC_VSX
-	{ NT_PPC_VSX,		"NT_PPC_VSX" },
+	XLAT(NT_PPC_VSX),
 #endif
 #ifdef NT_386_TLS
-	{ NT_386_TLS,		"NT_386_TLS" },
+	XLAT(NT_386_TLS),
 #endif
 #ifdef NT_386_IOPERM
-	{ NT_386_IOPERM,	"NT_386_IOPERM" },
+	XLAT(NT_386_IOPERM),
 #endif
 #ifdef NT_X86_XSTATE
-	{ NT_X86_XSTATE,	"NT_X86_XSTATE" },
+	XLAT(NT_X86_XSTATE),
 #endif
 	{ 0,			NULL },
 };
@@ -1701,67 +1701,67 @@ const struct xlat struct_user_offsets[] = {
 # endif
 	{ PT_DBR, "dbr" }, { PT_IBR, "ibr" }, { PT_PMD, "pmd" },
 #elif defined(I386)
-	{ 4*EBX,		"4*EBX"					},
-	{ 4*ECX,		"4*ECX"					},
-	{ 4*EDX,		"4*EDX"					},
-	{ 4*ESI,		"4*ESI"					},
-	{ 4*EDI,		"4*EDI"					},
-	{ 4*EBP,		"4*EBP"					},
-	{ 4*EAX,		"4*EAX"					},
-	{ 4*DS,			"4*DS"					},
-	{ 4*ES,			"4*ES"					},
-	{ 4*FS,			"4*FS"					},
-	{ 4*GS,			"4*GS"					},
-	{ 4*ORIG_EAX,		"4*ORIG_EAX"				},
-	{ 4*EIP,		"4*EIP"					},
-	{ 4*CS,			"4*CS"					},
-	{ 4*EFL,		"4*EFL"					},
-	{ 4*UESP,		"4*UESP"				},
-	{ 4*SS,			"4*SS"					},
+	XLAT(4*EBX),
+	XLAT(4*ECX),
+	XLAT(4*EDX),
+	XLAT(4*ESI),
+	XLAT(4*EDI),
+	XLAT(4*EBP),
+	XLAT(4*EAX),
+	XLAT(4*DS),
+	XLAT(4*ES),
+	XLAT(4*FS),
+	XLAT(4*GS),
+	XLAT(4*ORIG_EAX),
+	XLAT(4*EIP),
+	XLAT(4*CS),
+	XLAT(4*EFL),
+	XLAT(4*UESP),
+	XLAT(4*SS),
 #elif defined(X86_64) || defined(X32)
-	{ 8*R15,		"8*R15"					},
-	{ 8*R14,		"8*R14"					},
-	{ 8*R13,		"8*R13"					},
-	{ 8*R12,		"8*R12"					},
-	{ 8*RBP,		"8*RBP"					},
-	{ 8*RBX,		"8*RBX"					},
-	{ 8*R11,		"8*R11"					},
-	{ 8*R10,		"8*R10"					},
-	{ 8*R9,			"8*R9"					},
-	{ 8*R8,			"8*R8"					},
-	{ 8*RAX,		"8*RAX"					},
-	{ 8*RCX,		"8*RCX"					},
-	{ 8*RDX,		"8*RDX"					},
-	{ 8*RSI,		"8*RSI"					},
-	{ 8*RDI,		"8*RDI"					},
-	{ 8*ORIG_RAX,		"8*ORIG_RAX"				},
-	{ 8*RIP,		"8*RIP"					},
-	{ 8*CS,			"8*CS"					},
+	XLAT(8*R15),
+	XLAT(8*R14),
+	XLAT(8*R13),
+	XLAT(8*R12),
+	XLAT(8*RBP),
+	XLAT(8*RBX),
+	XLAT(8*R11),
+	XLAT(8*R10),
+	XLAT(8*R9),
+	XLAT(8*R8),
+	XLAT(8*RAX),
+	XLAT(8*RCX),
+	XLAT(8*RDX),
+	XLAT(8*RSI),
+	XLAT(8*RDI),
+	XLAT(8*ORIG_RAX),
+	XLAT(8*RIP),
+	XLAT(8*CS),
 	{ 8*EFLAGS,		"8*EFL"					},
-	{ 8*RSP,		"8*RSP"					},
-	{ 8*SS,			"8*SS"					},
+	XLAT(8*RSP),
+	XLAT(8*SS),
 #elif defined(M68K)
-	{ 4*PT_D1,		"4*PT_D1"				},
-	{ 4*PT_D2,		"4*PT_D2"				},
-	{ 4*PT_D3,		"4*PT_D3"				},
-	{ 4*PT_D4,		"4*PT_D4"				},
-	{ 4*PT_D5,		"4*PT_D5"				},
-	{ 4*PT_D6,		"4*PT_D6"				},
-	{ 4*PT_D7,		"4*PT_D7"				},
-	{ 4*PT_A0,		"4*PT_A0"				},
-	{ 4*PT_A1,		"4*PT_A1"				},
-	{ 4*PT_A2,		"4*PT_A2"				},
-	{ 4*PT_A3,		"4*PT_A3"				},
-	{ 4*PT_A4,		"4*PT_A4"				},
-	{ 4*PT_A5,		"4*PT_A5"				},
-	{ 4*PT_A6,		"4*PT_A6"				},
-	{ 4*PT_D0,		"4*PT_D0"				},
-	{ 4*PT_USP,		"4*PT_USP"				},
-	{ 4*PT_ORIG_D0,		"4*PT_ORIG_D0"				},
-	{ 4*PT_SR,		"4*PT_SR"				},
-	{ 4*PT_PC,		"4*PT_PC"				},
+	XLAT(4*PT_D1),
+	XLAT(4*PT_D2),
+	XLAT(4*PT_D3),
+	XLAT(4*PT_D4),
+	XLAT(4*PT_D5),
+	XLAT(4*PT_D6),
+	XLAT(4*PT_D7),
+	XLAT(4*PT_A0),
+	XLAT(4*PT_A1),
+	XLAT(4*PT_A2),
+	XLAT(4*PT_A3),
+	XLAT(4*PT_A4),
+	XLAT(4*PT_A5),
+	XLAT(4*PT_A6),
+	XLAT(4*PT_D0),
+	XLAT(4*PT_USP),
+	XLAT(4*PT_ORIG_D0),
+	XLAT(4*PT_SR),
+	XLAT(4*PT_PC),
 #elif defined(SH)
-	{ 4*REG_REG0,		"4*REG_REG0"				},
+	XLAT(4*REG_REG0),
 	{ 4*(REG_REG0+1),	"4*REG_REG1"				},
 	{ 4*(REG_REG0+2),	"4*REG_REG2"				},
 	{ 4*(REG_REG0+3),	"4*REG_REG3"				},
@@ -1776,16 +1776,16 @@ const struct xlat struct_user_offsets[] = {
 	{ 4*(REG_REG0+12),	"4*REG_REG12"				},
 	{ 4*(REG_REG0+13),	"4*REG_REG13"				},
 	{ 4*(REG_REG0+14),	"4*REG_REG14"				},
-	{ 4*REG_REG15,		"4*REG_REG15"				},
-	{ 4*REG_PC,		"4*REG_PC"				},
-	{ 4*REG_PR,		"4*REG_PR"				},
-	{ 4*REG_SR,		"4*REG_SR"				},
-	{ 4*REG_GBR,		"4*REG_GBR"				},
-	{ 4*REG_MACH,		"4*REG_MACH"				},
-	{ 4*REG_MACL,		"4*REG_MACL"				},
-	{ 4*REG_SYSCALL,	"4*REG_SYSCALL"				},
-	{ 4*REG_FPUL,		"4*REG_FPUL"				},
-	{ 4*REG_FPREG0,		"4*REG_FPREG0"				},
+	XLAT(4*REG_REG15),
+	XLAT(4*REG_PC),
+	XLAT(4*REG_PR),
+	XLAT(4*REG_SR),
+	XLAT(4*REG_GBR),
+	XLAT(4*REG_MACH),
+	XLAT(4*REG_MACL),
+	XLAT(4*REG_SYSCALL),
+	XLAT(4*REG_FPUL),
+	XLAT(4*REG_FPREG0),
 	{ 4*(REG_FPREG0+1),	"4*REG_FPREG1"				},
 	{ 4*(REG_FPREG0+2),	"4*REG_FPREG2"				},
 	{ 4*(REG_FPREG0+3),	"4*REG_FPREG3"				},
@@ -1800,18 +1800,18 @@ const struct xlat struct_user_offsets[] = {
 	{ 4*(REG_FPREG0+12),	"4*REG_FPREG12"				},
 	{ 4*(REG_FPREG0+13),	"4*REG_FPREG13"				},
 	{ 4*(REG_FPREG0+14),	"4*REG_FPREG14"				},
-	{ 4*REG_FPREG15,	"4*REG_FPREG15"				},
+	XLAT(4*REG_FPREG15),
 # ifdef REG_XDREG0
-	{ 4*REG_XDREG0,		"4*REG_XDREG0"				},
+	XLAT(4*REG_XDREG0),
 	{ 4*(REG_XDREG0+2),	"4*REG_XDREG2"				},
 	{ 4*(REG_XDREG0+4),	"4*REG_XDREG4"				},
 	{ 4*(REG_XDREG0+6),	"4*REG_XDREG6"				},
 	{ 4*(REG_XDREG0+8),	"4*REG_XDREG8"				},
 	{ 4*(REG_XDREG0+10),	"4*REG_XDREG10"				},
 	{ 4*(REG_XDREG0+12),	"4*REG_XDREG12"				},
-	{ 4*REG_XDREG14,	"4*REG_XDREG14"				},
+	XLAT(4*REG_XDREG14),
 # endif
-	{ 4*REG_FPSCR,		"4*REG_FPSCR"				},
+	XLAT(4*REG_FPSCR),
 #elif defined(SH64)
 	{ 0,			"PC(L)"					},
 	{ 4,			"PC(U)"					},
@@ -2138,73 +2138,73 @@ const struct xlat struct_user_offsets[] = {
 	{ PTREGS_OFFSET_FLAGS, "flags" },
 #endif
 #ifdef CRISV10
-	{ 4*PT_FRAMETYPE, "4*PT_FRAMETYPE" },
-	{ 4*PT_ORIG_R10, "4*PT_ORIG_R10" },
-	{ 4*PT_R13, "4*PT_R13" },
-	{ 4*PT_R12, "4*PT_R12" },
-	{ 4*PT_R11, "4*PT_R11" },
-	{ 4*PT_R10, "4*PT_R10" },
-	{ 4*PT_R9, "4*PT_R9" },
-	{ 4*PT_R8, "4*PT_R8" },
-	{ 4*PT_R7, "4*PT_R7" },
-	{ 4*PT_R6, "4*PT_R6" },
-	{ 4*PT_R5, "4*PT_R5" },
-	{ 4*PT_R4, "4*PT_R4" },
-	{ 4*PT_R3, "4*PT_R3" },
-	{ 4*PT_R2, "4*PT_R2" },
-	{ 4*PT_R1, "4*PT_R1" },
-	{ 4*PT_R0, "4*PT_R0" },
-	{ 4*PT_MOF, "4*PT_MOF" },
-	{ 4*PT_DCCR, "4*PT_DCCR" },
-	{ 4*PT_SRP, "4*PT_SRP" },
-	{ 4*PT_IRP, "4*PT_IRP" },
-	{ 4*PT_CSRINSTR, "4*PT_CSRINSTR" },
-	{ 4*PT_CSRADDR, "4*PT_CSRADDR" },
-	{ 4*PT_CSRDATA, "4*PT_CSRDATA" },
-	{ 4*PT_USP, "4*PT_USP" },
+	XLAT(4*PT_FRAMETYPE),
+	XLAT(4*PT_ORIG_R10),
+	XLAT(4*PT_R13),
+	XLAT(4*PT_R12),
+	XLAT(4*PT_R11),
+	XLAT(4*PT_R10),
+	XLAT(4*PT_R9),
+	XLAT(4*PT_R8),
+	XLAT(4*PT_R7),
+	XLAT(4*PT_R6),
+	XLAT(4*PT_R5),
+	XLAT(4*PT_R4),
+	XLAT(4*PT_R3),
+	XLAT(4*PT_R2),
+	XLAT(4*PT_R1),
+	XLAT(4*PT_R0),
+	XLAT(4*PT_MOF),
+	XLAT(4*PT_DCCR),
+	XLAT(4*PT_SRP),
+	XLAT(4*PT_IRP),
+	XLAT(4*PT_CSRINSTR),
+	XLAT(4*PT_CSRADDR),
+	XLAT(4*PT_CSRDATA),
+	XLAT(4*PT_USP),
 #endif
 #ifdef CRISV32
-	{ 4*PT_ORIG_R10, "4*PT_ORIG_R10" },
-	{ 4*PT_R0, "4*PT_R0" },
-	{ 4*PT_R1, "4*PT_R1" },
-	{ 4*PT_R2, "4*PT_R2" },
-	{ 4*PT_R3, "4*PT_R3" },
-	{ 4*PT_R4, "4*PT_R4" },
-	{ 4*PT_R5, "4*PT_R5" },
-	{ 4*PT_R6, "4*PT_R6" },
-	{ 4*PT_R7, "4*PT_R7" },
-	{ 4*PT_R8, "4*PT_R8" },
-	{ 4*PT_R9, "4*PT_R9" },
-	{ 4*PT_R10, "4*PT_R10" },
-	{ 4*PT_R11, "4*PT_R11" },
-	{ 4*PT_R12, "4*PT_R12" },
-	{ 4*PT_R13, "4*PT_R13" },
-	{ 4*PT_ACR, "4*PT_ACR" },
-	{ 4*PT_SRS, "4*PT_SRS" },
-	{ 4*PT_MOF, "4*PT_MOF" },
-	{ 4*PT_SPC, "4*PT_SPC" },
-	{ 4*PT_CCS, "4*PT_CCS" },
-	{ 4*PT_SRP, "4*PT_SRP" },
-	{ 4*PT_ERP, "4*PT_ERP" },
-	{ 4*PT_EXS, "4*PT_EXS" },
-	{ 4*PT_EDA, "4*PT_EDA" },
-	{ 4*PT_USP, "4*PT_USP" },
-	{ 4*PT_PPC, "4*PT_PPC" },
-	{ 4*PT_BP_CTRL, "4*PT_BP_CTRL" },
-	{ 4*PT_BP+4, "4*PT_BP+4" },
-	{ 4*PT_BP+8, "4*PT_BP+8" },
-	{ 4*PT_BP+12, "4*PT_BP+12" },
-	{ 4*PT_BP+16, "4*PT_BP+16" },
-	{ 4*PT_BP+20, "4*PT_BP+20" },
-	{ 4*PT_BP+24, "4*PT_BP+24" },
-	{ 4*PT_BP+28, "4*PT_BP+28" },
-	{ 4*PT_BP+32, "4*PT_BP+32" },
-	{ 4*PT_BP+36, "4*PT_BP+36" },
-	{ 4*PT_BP+40, "4*PT_BP+40" },
-	{ 4*PT_BP+44, "4*PT_BP+44" },
-	{ 4*PT_BP+48, "4*PT_BP+48" },
-	{ 4*PT_BP+52, "4*PT_BP+52" },
-	{ 4*PT_BP+56, "4*PT_BP+56" },
+	XLAT(4*PT_ORIG_R10),
+	XLAT(4*PT_R0),
+	XLAT(4*PT_R1),
+	XLAT(4*PT_R2),
+	XLAT(4*PT_R3),
+	XLAT(4*PT_R4),
+	XLAT(4*PT_R5),
+	XLAT(4*PT_R6),
+	XLAT(4*PT_R7),
+	XLAT(4*PT_R8),
+	XLAT(4*PT_R9),
+	XLAT(4*PT_R10),
+	XLAT(4*PT_R11),
+	XLAT(4*PT_R12),
+	XLAT(4*PT_R13),
+	XLAT(4*PT_ACR),
+	XLAT(4*PT_SRS),
+	XLAT(4*PT_MOF),
+	XLAT(4*PT_SPC),
+	XLAT(4*PT_CCS),
+	XLAT(4*PT_SRP),
+	XLAT(4*PT_ERP),
+	XLAT(4*PT_EXS),
+	XLAT(4*PT_EDA),
+	XLAT(4*PT_USP),
+	XLAT(4*PT_PPC),
+	XLAT(4*PT_BP_CTRL),
+	XLAT(4*PT_BP+4),
+	XLAT(4*PT_BP+8),
+	XLAT(4*PT_BP+12),
+	XLAT(4*PT_BP+16),
+	XLAT(4*PT_BP+20),
+	XLAT(4*PT_BP+24),
+	XLAT(4*PT_BP+28),
+	XLAT(4*PT_BP+32),
+	XLAT(4*PT_BP+36),
+	XLAT(4*PT_BP+40),
+	XLAT(4*PT_BP+44),
+	XLAT(4*PT_BP+48),
+	XLAT(4*PT_BP+52),
+	XLAT(4*PT_BP+56),
 #endif
 #ifdef MICROBLAZE
 	{ PT_GPR(0),		"r0"					},
@@ -2652,19 +2652,19 @@ sys_ptrace(struct tcb *tcp)
 # define FUTEX_CLOCK_REALTIME 256
 #endif
 static const struct xlat futexops[] = {
-	{ FUTEX_WAIT,					"FUTEX_WAIT" },
-	{ FUTEX_WAKE,					"FUTEX_WAKE" },
-	{ FUTEX_FD,					"FUTEX_FD" },
-	{ FUTEX_REQUEUE,				"FUTEX_REQUEUE" },
-	{ FUTEX_CMP_REQUEUE,				"FUTEX_CMP_REQUEUE" },
-	{ FUTEX_WAKE_OP,				"FUTEX_WAKE_OP" },
-	{ FUTEX_LOCK_PI,				"FUTEX_LOCK_PI" },
-	{ FUTEX_UNLOCK_PI,				"FUTEX_UNLOCK_PI" },
-	{ FUTEX_TRYLOCK_PI,				"FUTEX_TRYLOCK_PI" },
-	{ FUTEX_WAIT_BITSET,				"FUTEX_WAIT_BITSET" },
-	{ FUTEX_WAKE_BITSET,				"FUTEX_WAKE_BITSET" },
-	{ FUTEX_WAIT_REQUEUE_PI,			"FUTEX_WAIT_REQUEUE_PI" },
-	{ FUTEX_CMP_REQUEUE_PI,				"FUTEX_CMP_REQUEUE_PI" },
+	XLAT(FUTEX_WAIT),
+	XLAT(FUTEX_WAKE),
+	XLAT(FUTEX_FD),
+	XLAT(FUTEX_REQUEUE),
+	XLAT(FUTEX_CMP_REQUEUE),
+	XLAT(FUTEX_WAKE_OP),
+	XLAT(FUTEX_LOCK_PI),
+	XLAT(FUTEX_UNLOCK_PI),
+	XLAT(FUTEX_TRYLOCK_PI),
+	XLAT(FUTEX_WAIT_BITSET),
+	XLAT(FUTEX_WAKE_BITSET),
+	XLAT(FUTEX_WAIT_REQUEUE_PI),
+	XLAT(FUTEX_CMP_REQUEUE_PI),
 	{ FUTEX_WAIT|FUTEX_PRIVATE_FLAG,		"FUTEX_WAIT_PRIVATE" },
 	{ FUTEX_WAKE|FUTEX_PRIVATE_FLAG,		"FUTEX_WAKE_PRIVATE" },
 	{ FUTEX_FD|FUTEX_PRIVATE_FLAG,			"FUTEX_FD_PRIVATE" },
@@ -2678,9 +2678,9 @@ static const struct xlat futexops[] = {
 	{ FUTEX_WAKE_BITSET|FUTEX_PRIVATE_FLAG,		"FUTEX_WAKE_BITSET_PRIVATE" },
 	{ FUTEX_WAIT_REQUEUE_PI|FUTEX_PRIVATE_FLAG,	"FUTEX_WAIT_REQUEUE_PI_PRIVATE" },
 	{ FUTEX_CMP_REQUEUE_PI|FUTEX_PRIVATE_FLAG,	"FUTEX_CMP_REQUEUE_PI_PRIVATE" },
-	{ FUTEX_WAIT_BITSET|FUTEX_CLOCK_REALTIME,	"FUTEX_WAIT_BITSET|FUTEX_CLOCK_REALTIME" },
+	XLAT(FUTEX_WAIT_BITSET|FUTEX_CLOCK_REALTIME),
 	{ FUTEX_WAIT_BITSET|FUTEX_PRIVATE_FLAG|FUTEX_CLOCK_REALTIME,	"FUTEX_WAIT_BITSET_PRIVATE|FUTEX_CLOCK_REALTIME" },
-	{ FUTEX_WAIT_REQUEUE_PI|FUTEX_CLOCK_REALTIME,	"FUTEX_WAIT_REQUEUE_PI|FUTEX_CLOCK_REALTIME" },
+	XLAT(FUTEX_WAIT_REQUEUE_PI|FUTEX_CLOCK_REALTIME),
 	{ FUTEX_WAIT_REQUEUE_PI|FUTEX_PRIVATE_FLAG|FUTEX_CLOCK_REALTIME,	"FUTEX_WAIT_REQUEUE_PI_PRIVATE|FUTEX_CLOCK_REALTIME" },
 	{ 0,						NULL }
 };
@@ -2698,20 +2698,20 @@ static const struct xlat futexops[] = {
 # define FUTEX_OP_CMP_GE	5
 #endif
 static const struct xlat futexwakeops[] = {
-	{ FUTEX_OP_SET,		"FUTEX_OP_SET" },
-	{ FUTEX_OP_ADD,		"FUTEX_OP_ADD" },
-	{ FUTEX_OP_OR,		"FUTEX_OP_OR" },
-	{ FUTEX_OP_ANDN,	"FUTEX_OP_ANDN" },
-	{ FUTEX_OP_XOR,		"FUTEX_OP_XOR" },
+	XLAT(FUTEX_OP_SET),
+	XLAT(FUTEX_OP_ADD),
+	XLAT(FUTEX_OP_OR),
+	XLAT(FUTEX_OP_ANDN),
+	XLAT(FUTEX_OP_XOR),
 	{ 0,			NULL }
 };
 static const struct xlat futexwakecmps[] = {
-	{ FUTEX_OP_CMP_EQ,	"FUTEX_OP_CMP_EQ" },
-	{ FUTEX_OP_CMP_NE,	"FUTEX_OP_CMP_NE" },
-	{ FUTEX_OP_CMP_LT,	"FUTEX_OP_CMP_LT" },
-	{ FUTEX_OP_CMP_LE,	"FUTEX_OP_CMP_LE" },
-	{ FUTEX_OP_CMP_GT,	"FUTEX_OP_CMP_GT" },
-	{ FUTEX_OP_CMP_GE,	"FUTEX_OP_CMP_GE" },
+	XLAT(FUTEX_OP_CMP_EQ),
+	XLAT(FUTEX_OP_CMP_NE),
+	XLAT(FUTEX_OP_CMP_LT),
+	XLAT(FUTEX_OP_CMP_LE),
+	XLAT(FUTEX_OP_CMP_GT),
+	XLAT(FUTEX_OP_CMP_GE),
 	{ 0,			NULL }
 };
 
@@ -2840,9 +2840,9 @@ sys_get_robust_list(struct tcb *tcp)
 }
 
 static const struct xlat schedulers[] = {
-	{ SCHED_OTHER,	"SCHED_OTHER" },
-	{ SCHED_RR,	"SCHED_RR" },
-	{ SCHED_FIFO,	"SCHED_FIFO" },
+	XLAT(SCHED_OTHER),
+	XLAT(SCHED_RR),
+	XLAT(SCHED_FIFO),
 	{ 0,		NULL }
 };
 
@@ -2929,10 +2929,10 @@ sys_sched_rr_get_interval(struct tcb *tcp)
 # include <asm/prctl.h>
 
 static const struct xlat archvals[] = {
-	{ ARCH_SET_GS,		"ARCH_SET_GS"		},
-	{ ARCH_SET_FS,		"ARCH_SET_FS"		},
-	{ ARCH_GET_FS,		"ARCH_GET_FS"		},
-	{ ARCH_GET_GS,		"ARCH_GET_GS"		},
+	XLAT(ARCH_SET_GS),
+	XLAT(ARCH_SET_FS),
+	XLAT(ARCH_GET_FS),
+	XLAT(ARCH_GET_GS),
 	{ 0,			NULL			},
 };
 
diff --git a/ptp.c b/ptp.c
index 119b167..35cf685 100644
--- a/ptp.c
+++ b/ptp.c
@@ -3,9 +3,9 @@
 #include <linux/ptp_clock.h>
 
 static const struct xlat ptp_flags_options[] = {
-	{ PTP_ENABLE_FEATURE,	"PTP_ENABLE_FEATURE"	},
-	{ PTP_RISING_EDGE,	"PTP_RISING_EDGE"	},
-	{ PTP_FALLING_EDGE,	"PTP_FALLING_EDGE"	},
+	XLAT(PTP_ENABLE_FEATURE),
+	XLAT(PTP_RISING_EDGE),
+	XLAT(PTP_FALLING_EDGE),
 	{ 0,			NULL			}
 };
 
diff --git a/quota.c b/quota.c
index 780abf9..d48a443 100644
--- a/quota.c
+++ b/quota.c
@@ -77,41 +77,41 @@
 #define Q_XQUOTASYNC	XQM_CMD(0x7)
 
 static const struct xlat quotacmds[] = {
-	{Q_V1_QUOTAON, "Q_V1_QUOTAON"},
-	{Q_V1_QUOTAOFF, "Q_V1_QUOTAOFF"},
-	{Q_V1_GETQUOTA, "Q_V1_GETQUOTA"},
-	{Q_V1_SETQUOTA, "Q_V1_SETQUOTA"},
-	{Q_V1_SETUSE, "Q_V1_SETUSE"},
-	{Q_V1_SYNC, "Q_V1_SYNC"},
-	{Q_SETQLIM, "Q_SETQLIM"},
-	{Q_V1_GETSTATS, "Q_V1_GETSTATS"},
-	{Q_V1_RSQUASH, "Q_V1_RSQUASH"},
-
-	{Q_V2_GETQUOTA, "Q_V2_GETQUOTA"},
-	{Q_V2_SETQUOTA, "Q_V2_SETQUOTA"},
-	{Q_V2_SETUSE, "Q_V2_SETUSE"},
-	{Q_V2_GETINFO, "Q_V2_GETINFO"},
-	{Q_V2_SETINFO, "Q_V2_SETINFO"},
-	{Q_V2_SETGRACE, "Q_V2_SETGRACE"},
-	{Q_V2_SETFLAGS, "Q_V2_SETFLAGS"},
-	{Q_V2_GETSTATS, "Q_V2_GETSTATS"},
-
-	{Q_SYNC, "Q_SYNC"},
-	{Q_QUOTAON, "Q_QUOTAON"},
-	{Q_QUOTAOFF, "Q_QUOTAOFF"},
-	{Q_GETFMT, "Q_GETFMT"},
-	{Q_GETINFO, "Q_GETINFO"},
-	{Q_SETINFO, "Q_SETINFO"},
-	{Q_GETQUOTA, "Q_GETQUOTA"},
-	{Q_SETQUOTA, "Q_SETQUOTA"},
-
-	{Q_XQUOTAON, "Q_XQUOTAON"},
-	{Q_XQUOTAOFF, "Q_XQUOTAOFF"},
-	{Q_XGETQUOTA, "Q_XGETQUOTA"},
-	{Q_XSETQLIM, "Q_XSETQLIM"},
-	{Q_XGETQSTAT, "Q_XGETQSTAT"},
-	{Q_XQUOTARM, "Q_XQUOTARM"},
-	{Q_XQUOTASYNC, "Q_XQUOTASYNC"},
+	XLAT(Q_V1_QUOTAON),
+	XLAT(Q_V1_QUOTAOFF),
+	XLAT(Q_V1_GETQUOTA),
+	XLAT(Q_V1_SETQUOTA),
+	XLAT(Q_V1_SETUSE),
+	XLAT(Q_V1_SYNC),
+	XLAT(Q_SETQLIM),
+	XLAT(Q_V1_GETSTATS),
+	XLAT(Q_V1_RSQUASH),
+
+	XLAT(Q_V2_GETQUOTA),
+	XLAT(Q_V2_SETQUOTA),
+	XLAT(Q_V2_SETUSE),
+	XLAT(Q_V2_GETINFO),
+	XLAT(Q_V2_SETINFO),
+	XLAT(Q_V2_SETGRACE),
+	XLAT(Q_V2_SETFLAGS),
+	XLAT(Q_V2_GETSTATS),
+
+	XLAT(Q_SYNC),
+	XLAT(Q_QUOTAON),
+	XLAT(Q_QUOTAOFF),
+	XLAT(Q_GETFMT),
+	XLAT(Q_GETINFO),
+	XLAT(Q_SETINFO),
+	XLAT(Q_GETQUOTA),
+	XLAT(Q_SETQUOTA),
+
+	XLAT(Q_XQUOTAON),
+	XLAT(Q_XQUOTAOFF),
+	XLAT(Q_XGETQUOTA),
+	XLAT(Q_XSETQLIM),
+	XLAT(Q_XGETQSTAT),
+	XLAT(Q_XQUOTARM),
+	XLAT(Q_XQUOTASYNC),
 
 	{0, NULL},
 };
@@ -120,8 +120,8 @@ static const struct xlat quotacmds[] = {
 #define GRPQUOTA 1
 
 static const struct xlat quotatypes[] = {
-	{USRQUOTA, "USRQUOTA"},
-	{GRPQUOTA, "GRPQUOTA"},
+	XLAT(USRQUOTA),
+	XLAT(GRPQUOTA),
 	{0, NULL},
 };
 
@@ -130,8 +130,8 @@ static const struct xlat quotatypes[] = {
 #define QFMT_VFS_V0  2
 
 static const struct xlat quota_formats[] = {
-	{QFMT_VFS_OLD, "QFMT_VFS_OLD"},
-	{QFMT_VFS_V0, "QFMT_VFS_V0"},
+	XLAT(QFMT_VFS_OLD),
+	XLAT(QFMT_VFS_V0),
 	{0, NULL},
 };
 
@@ -145,17 +145,17 @@ static const struct xlat quota_formats[] = {
 #define XFS_GROUP_QUOTA		(1<<2)	/* group quota type */
 
 static const struct xlat xfs_quota_flags[] = {
-	{XFS_QUOTA_UDQ_ACCT, "XFS_QUOTA_UDQ_ACCT"},
-	{XFS_QUOTA_UDQ_ENFD, "XFS_QUOTA_UDQ_ENFD"},
-	{XFS_QUOTA_GDQ_ACCT, "XFS_QUOTA_GDQ_ACCT"},
-	{XFS_QUOTA_GDQ_ENFD, "XFS_QUOTA_GDQ_ENFD"},
+	XLAT(XFS_QUOTA_UDQ_ACCT),
+	XLAT(XFS_QUOTA_UDQ_ENFD),
+	XLAT(XFS_QUOTA_GDQ_ACCT),
+	XLAT(XFS_QUOTA_GDQ_ENFD),
 	{0, NULL}
 };
 
 static const struct xlat xfs_dqblk_flags[] = {
-	{XFS_USER_QUOTA, "XFS_USER_QUOTA"},
-	{XFS_PROJ_QUOTA, "XFS_PROJ_QUOTA"},
-	{XFS_GROUP_QUOTA, "XFS_GROUP_QUOTA"},
+	XLAT(XFS_USER_QUOTA),
+	XLAT(XFS_PROJ_QUOTA),
+	XLAT(XFS_GROUP_QUOTA),
 	{0, NULL}
 };
 
@@ -170,12 +170,12 @@ static const struct xlat xfs_dqblk_flags[] = {
 #define QIF_ITIME	32
 
 static const struct xlat if_dqblk_valid[] = {
-	{QIF_BLIMITS, "QIF_BLIMITS"},
-	{QIF_SPACE, "QIF_SPACE"},
-	{QIF_ILIMITS, "QIF_ILIMITS"},
-	{QIF_INODES, "QIF_INODES"},
-	{QIF_BTIME, "QIF_BTIME"},
-	{QIF_ITIME, "QIF_ITIME"},
+	XLAT(QIF_BLIMITS),
+	XLAT(QIF_SPACE),
+	XLAT(QIF_ILIMITS),
+	XLAT(QIF_INODES),
+	XLAT(QIF_BTIME),
+	XLAT(QIF_ITIME),
 	{0, NULL}
 };
 
@@ -250,9 +250,9 @@ struct xfs_dqblk
 #define IIF_FLAGS	4
 
 static const struct xlat if_dqinfo_valid[] = {
-	{IIF_BGRACE, "IIF_BGRACE"},
-	{IIF_IGRACE, "IIF_IGRACE"},
-	{IIF_FLAGS, "IIF_FLAGS"},
+	XLAT(IIF_BGRACE),
+	XLAT(IIF_IGRACE),
+	XLAT(IIF_FLAGS),
 	{0, NULL}
 };
 
diff --git a/resource.c b/resource.c
index 657e63d..24158b3 100644
--- a/resource.c
+++ b/resource.c
@@ -35,55 +35,55 @@
 
 static const struct xlat resources[] = {
 #ifdef RLIMIT_AS
-	{ RLIMIT_AS,		"RLIMIT_AS"		},
+	XLAT(RLIMIT_AS),
 #endif
 #ifdef RLIMIT_CORE
-	{ RLIMIT_CORE,		"RLIMIT_CORE"		},
+	XLAT(RLIMIT_CORE),
 #endif
 #ifdef RLIMIT_CPU
-	{ RLIMIT_CPU,		"RLIMIT_CPU"		},
+	XLAT(RLIMIT_CPU),
 #endif
 #ifdef RLIMIT_DATA
-	{ RLIMIT_DATA,		"RLIMIT_DATA"		},
+	XLAT(RLIMIT_DATA),
 #endif
 #ifdef RLIMIT_FSIZE
-	{ RLIMIT_FSIZE,		"RLIMIT_FSIZE"		},
+	XLAT(RLIMIT_FSIZE),
 #endif
 #ifdef RLIMIT_LOCKS
-	{ RLIMIT_LOCKS,		"RLIMIT_LOCKS"		},
+	XLAT(RLIMIT_LOCKS),
 #endif
 #ifdef RLIMIT_MEMLOCK
-	{ RLIMIT_MEMLOCK,	"RLIMIT_MEMLOCK"	},
+	XLAT(RLIMIT_MEMLOCK),
 #endif
 #ifdef RLIMIT_MSGQUEUE
-	{ RLIMIT_MSGQUEUE,	"RLIMIT_MSGQUEUE"	},
+	XLAT(RLIMIT_MSGQUEUE),
 #endif
 #ifdef RLIMIT_NICE
-	{ RLIMIT_NICE,		"RLIMIT_NICE"		},
+	XLAT(RLIMIT_NICE),
 #endif
 #ifdef RLIMIT_NOFILE
-	{ RLIMIT_NOFILE,	"RLIMIT_NOFILE"		},
+	XLAT(RLIMIT_NOFILE),
 #endif
 #ifdef RLIMIT_NPROC
-	{ RLIMIT_NPROC,		"RLIMIT_NPROC"		},
+	XLAT(RLIMIT_NPROC),
 #endif
 #ifdef RLIMIT_RSS
-	{ RLIMIT_RSS,		"RLIMIT_RSS"		},
+	XLAT(RLIMIT_RSS),
 #endif
 #ifdef RLIMIT_RTPRIO
-	{ RLIMIT_RTPRIO,	"RLIMIT_RTPRIO"		},
+	XLAT(RLIMIT_RTPRIO),
 #endif
 #ifdef RLIMIT_RTTIME
-	{ RLIMIT_RTTIME,	"RLIMIT_RTTIME"		},
+	XLAT(RLIMIT_RTTIME),
 #endif
 #ifdef RLIMIT_SIGPENDING
-	{ RLIMIT_SIGPENDING,	"RLIMIT_SIGPENDING"	},
+	XLAT(RLIMIT_SIGPENDING),
 #endif
 #ifdef RLIMIT_STACK
-	{ RLIMIT_STACK,		"RLIMIT_STACK"		},
+	XLAT(RLIMIT_STACK),
 #endif
 #ifdef RLIMIT_VMEM
-	{ RLIMIT_VMEM,		"RLIMIT_VMEM"		},
+	XLAT(RLIMIT_VMEM),
 #endif
 	{ 0,			NULL			}
 };
@@ -233,10 +233,10 @@ sys_prlimit64(struct tcb *tcp)
 }
 
 static const struct xlat usagewho[] = {
-	{ RUSAGE_SELF,		"RUSAGE_SELF"		},
-	{ RUSAGE_CHILDREN,	"RUSAGE_CHILDREN"	},
+	XLAT(RUSAGE_SELF),
+	XLAT(RUSAGE_CHILDREN),
 #ifdef RUSAGE_BOTH
-	{ RUSAGE_BOTH,		"RUSAGE_BOTH"		},
+	XLAT(RUSAGE_BOTH),
 #endif
 	{ 0,			NULL			},
 };
@@ -387,9 +387,9 @@ sys_sysinfo(struct tcb *tcp)
 }
 
 static const struct xlat priorities[] = {
-	{ PRIO_PROCESS,	"PRIO_PROCESS"	},
-	{ PRIO_PGRP,	"PRIO_PGRP"	},
-	{ PRIO_USER,	"PRIO_USER"	},
+	XLAT(PRIO_PROCESS),
+	XLAT(PRIO_PGRP),
+	XLAT(PRIO_USER),
 	{ 0,		NULL		},
 };
 
diff --git a/scsi.c b/scsi.c
index 682016e..f4b6f78 100644
--- a/scsi.c
+++ b/scsi.c
@@ -31,10 +31,10 @@
 #include <scsi/sg.h>
 
 static const struct xlat sg_io_dxfer_direction[] = {
-	{SG_DXFER_NONE,        "SG_DXFER_NONE"},
-	{SG_DXFER_TO_DEV,      "SG_DXFER_TO_DEV"},
-	{SG_DXFER_FROM_DEV,    "SG_DXFER_FROM_DEV"},
-	{SG_DXFER_TO_FROM_DEV, "SG_DXFER_TO_FROM_DEV"},
+	XLAT(SG_DXFER_NONE),
+	XLAT(SG_DXFER_TO_DEV),
+	XLAT(SG_DXFER_FROM_DEV),
+	XLAT(SG_DXFER_TO_FROM_DEV),
 	{0, NULL}
 };
 
diff --git a/signal.c b/signal.c
index 9a7e47f..7a25b05 100644
--- a/signal.c
+++ b/signal.c
@@ -100,62 +100,62 @@ struct sigcontext {
 
 static const struct xlat sigact_flags[] = {
 #ifdef SA_RESTORER
-	{ SA_RESTORER,	"SA_RESTORER"	},
+	XLAT(SA_RESTORER),
 #endif
 #ifdef SA_STACK
-	{ SA_STACK,	"SA_STACK"	},
+	XLAT(SA_STACK),
 #endif
 #ifdef SA_RESTART
-	{ SA_RESTART,	"SA_RESTART"	},
+	XLAT(SA_RESTART),
 #endif
 #ifdef SA_INTERRUPT
-	{ SA_INTERRUPT,	"SA_INTERRUPT"	},
+	XLAT(SA_INTERRUPT),
 #endif
 #ifdef SA_NODEFER
-	{ SA_NODEFER,	"SA_NODEFER"	},
+	XLAT(SA_NODEFER),
 #endif
 #if defined SA_NOMASK && SA_NODEFER != SA_NOMASK
-	{ SA_NOMASK,	"SA_NOMASK"	},
+	XLAT(SA_NOMASK),
 #endif
 #ifdef SA_RESETHAND
-	{ SA_RESETHAND,	"SA_RESETHAND"	},
+	XLAT(SA_RESETHAND),
 #endif
 #if defined SA_ONESHOT && SA_ONESHOT != SA_RESETHAND
-	{ SA_ONESHOT,	"SA_ONESHOT"	},
+	XLAT(SA_ONESHOT),
 #endif
 #ifdef SA_SIGINFO
-	{ SA_SIGINFO,	"SA_SIGINFO"	},
+	XLAT(SA_SIGINFO),
 #endif
 #ifdef SA_RESETHAND
-	{ SA_RESETHAND,	"SA_RESETHAND"	},
+	XLAT(SA_RESETHAND),
 #endif
 #ifdef SA_ONSTACK
-	{ SA_ONSTACK,	"SA_ONSTACK"	},
+	XLAT(SA_ONSTACK),
 #endif
 #ifdef SA_NODEFER
-	{ SA_NODEFER,	"SA_NODEFER"	},
+	XLAT(SA_NODEFER),
 #endif
 #ifdef SA_NOCLDSTOP
-	{ SA_NOCLDSTOP,	"SA_NOCLDSTOP"	},
+	XLAT(SA_NOCLDSTOP),
 #endif
 #ifdef SA_NOCLDWAIT
-	{ SA_NOCLDWAIT,	"SA_NOCLDWAIT"	},
+	XLAT(SA_NOCLDWAIT),
 #endif
 #ifdef _SA_BSDCALL
-	{ _SA_BSDCALL,	"_SA_BSDCALL"	},
+	XLAT(_SA_BSDCALL),
 #endif
 #ifdef SA_NOPTRACE
-	{ SA_NOPTRACE,	"SA_NOPTRACE"	},
+	XLAT(SA_NOPTRACE),
 #endif
 	{ 0,		NULL		},
 };
 
 static const struct xlat sigprocmaskcmds[] = {
-	{ SIG_BLOCK,	"SIG_BLOCK"	},
-	{ SIG_UNBLOCK,	"SIG_UNBLOCK"	},
-	{ SIG_SETMASK,	"SIG_SETMASK"	},
+	XLAT(SIG_BLOCK),
+	XLAT(SIG_UNBLOCK),
+	XLAT(SIG_SETMASK),
 #ifdef SIG_SETMASK32
-	{ SIG_SETMASK32,"SIG_SETMASK32"	},
+	XLAT(SIG_SETMASK32),
 #endif
 	{ 0,		NULL		},
 };
@@ -376,94 +376,94 @@ print_sigset_addr_len(struct tcb *tcp, long addr, long len)
 
 static const struct xlat siginfo_codes[] = {
 #ifdef SI_KERNEL
-	{ SI_KERNEL,	"SI_KERNEL"	},
+	XLAT(SI_KERNEL),
 #endif
 #ifdef SI_USER
-	{ SI_USER,	"SI_USER"	},
+	XLAT(SI_USER),
 #endif
 #ifdef SI_QUEUE
-	{ SI_QUEUE,	"SI_QUEUE"	},
+	XLAT(SI_QUEUE),
 #endif
 #ifdef SI_TIMER
-	{ SI_TIMER,	"SI_TIMER"	},
+	XLAT(SI_TIMER),
 #endif
 #ifdef SI_MESGQ
-	{ SI_MESGQ,	"SI_MESGQ"	},
+	XLAT(SI_MESGQ),
 #endif
 #ifdef SI_ASYNCIO
-	{ SI_ASYNCIO,	"SI_ASYNCIO"	},
+	XLAT(SI_ASYNCIO),
 #endif
 #ifdef SI_SIGIO
-	{ SI_SIGIO,	"SI_SIGIO"	},
+	XLAT(SI_SIGIO),
 #endif
 #ifdef SI_TKILL
-	{ SI_TKILL,	"SI_TKILL"	},
+	XLAT(SI_TKILL),
 #endif
 #ifdef SI_ASYNCNL
-	{ SI_ASYNCNL,	"SI_ASYNCNL"	},
+	XLAT(SI_ASYNCNL),
 #endif
 #ifdef SI_NOINFO
-	{ SI_NOINFO,	"SI_NOINFO"	},
+	XLAT(SI_NOINFO),
 #endif
 #ifdef SI_LWP
-	{ SI_LWP,	"SI_LWP"	},
+	XLAT(SI_LWP),
 #endif
 	{ 0,		NULL		},
 };
 
 static const struct xlat sigill_codes[] = {
-	{ ILL_ILLOPC,	"ILL_ILLOPC"	},
-	{ ILL_ILLOPN,	"ILL_ILLOPN"	},
-	{ ILL_ILLADR,	"ILL_ILLADR"	},
-	{ ILL_ILLTRP,	"ILL_ILLTRP"	},
-	{ ILL_PRVOPC,	"ILL_PRVOPC"	},
-	{ ILL_PRVREG,	"ILL_PRVREG"	},
-	{ ILL_COPROC,	"ILL_COPROC"	},
-	{ ILL_BADSTK,	"ILL_BADSTK"	},
+	XLAT(ILL_ILLOPC),
+	XLAT(ILL_ILLOPN),
+	XLAT(ILL_ILLADR),
+	XLAT(ILL_ILLTRP),
+	XLAT(ILL_PRVOPC),
+	XLAT(ILL_PRVREG),
+	XLAT(ILL_COPROC),
+	XLAT(ILL_BADSTK),
 	{ 0,		NULL		},
 };
 
 static const struct xlat sigfpe_codes[] = {
-	{ FPE_INTDIV,	"FPE_INTDIV"	},
-	{ FPE_INTOVF,	"FPE_INTOVF"	},
-	{ FPE_FLTDIV,	"FPE_FLTDIV"	},
-	{ FPE_FLTOVF,	"FPE_FLTOVF"	},
-	{ FPE_FLTUND,	"FPE_FLTUND"	},
-	{ FPE_FLTRES,	"FPE_FLTRES"	},
-	{ FPE_FLTINV,	"FPE_FLTINV"	},
-	{ FPE_FLTSUB,	"FPE_FLTSUB"	},
+	XLAT(FPE_INTDIV),
+	XLAT(FPE_INTOVF),
+	XLAT(FPE_FLTDIV),
+	XLAT(FPE_FLTOVF),
+	XLAT(FPE_FLTUND),
+	XLAT(FPE_FLTRES),
+	XLAT(FPE_FLTINV),
+	XLAT(FPE_FLTSUB),
 	{ 0,		NULL		},
 };
 
 static const struct xlat sigtrap_codes[] = {
-	{ TRAP_BRKPT,	"TRAP_BRKPT"	},
-	{ TRAP_TRACE,	"TRAP_TRACE"	},
+	XLAT(TRAP_BRKPT),
+	XLAT(TRAP_TRACE),
 	{ 0,		NULL		},
 };
 
 static const struct xlat sigchld_codes[] = {
-	{ CLD_EXITED,	"CLD_EXITED"	},
-	{ CLD_KILLED,	"CLD_KILLED"	},
-	{ CLD_DUMPED,	"CLD_DUMPED"	},
-	{ CLD_TRAPPED,	"CLD_TRAPPED"	},
-	{ CLD_STOPPED,	"CLD_STOPPED"	},
-	{ CLD_CONTINUED,"CLD_CONTINUED"	},
+	XLAT(CLD_EXITED),
+	XLAT(CLD_KILLED),
+	XLAT(CLD_DUMPED),
+	XLAT(CLD_TRAPPED),
+	XLAT(CLD_STOPPED),
+	XLAT(CLD_CONTINUED),
 	{ 0,		NULL		},
 };
 
 static const struct xlat sigpoll_codes[] = {
-	{ POLL_IN,	"POLL_IN"	},
-	{ POLL_OUT,	"POLL_OUT"	},
-	{ POLL_MSG,	"POLL_MSG"	},
-	{ POLL_ERR,	"POLL_ERR"	},
-	{ POLL_PRI,	"POLL_PRI"	},
-	{ POLL_HUP,	"POLL_HUP"	},
+	XLAT(POLL_IN),
+	XLAT(POLL_OUT),
+	XLAT(POLL_MSG),
+	XLAT(POLL_ERR),
+	XLAT(POLL_PRI),
+	XLAT(POLL_HUP),
 	{ 0,		NULL		},
 };
 
 static const struct xlat sigprof_codes[] = {
 #ifdef PROF_SIG
-	{ PROF_SIG,	"PROF_SIG"	},
+	XLAT(PROF_SIG),
 #endif
 	{ 0,		NULL		},
 };
@@ -471,22 +471,22 @@ static const struct xlat sigprof_codes[] = {
 #ifdef SIGEMT
 static const struct xlat sigemt_codes[] = {
 #ifdef EMT_TAGOVF
-	{ EMT_TAGOVF,	"EMT_TAGOVF"	},
+	XLAT(EMT_TAGOVF),
 #endif
 	{ 0,		NULL		},
 };
 #endif
 
 static const struct xlat sigsegv_codes[] = {
-	{ SEGV_MAPERR,	"SEGV_MAPERR"	},
-	{ SEGV_ACCERR,	"SEGV_ACCERR"	},
+	XLAT(SEGV_MAPERR),
+	XLAT(SEGV_ACCERR),
 	{ 0,		NULL		},
 };
 
 static const struct xlat sigbus_codes[] = {
-	{ BUS_ADRALN,	"BUS_ADRALN"	},
-	{ BUS_ADRERR,	"BUS_ADRERR"	},
-	{ BUS_OBJERR,	"BUS_OBJERR"	},
+	XLAT(BUS_ADRALN),
+	XLAT(BUS_ADRERR),
+	XLAT(BUS_OBJERR),
 	{ 0,		NULL		},
 };
 
@@ -1081,8 +1081,8 @@ sys_sigsuspend(struct tcb *tcp)
 #endif
 
 static const struct xlat sigaltstack_flags[] = {
-	{ SS_ONSTACK,	"SS_ONSTACK"	},
-	{ SS_DISABLE,	"SS_DISABLE"	},
+	XLAT(SS_ONSTACK),
+	XLAT(SS_DISABLE),
 	{ 0,		NULL		},
 };
 
diff --git a/sock.c b/sock.c
index 9c6fe96..68a662f 100644
--- a/sock.c
+++ b/sock.c
@@ -39,21 +39,21 @@
 #include <net/if.h>
 
 static const struct xlat iffflags[] = {
-	{ IFF_UP,		"IFF_UP"		},
-	{ IFF_BROADCAST,	"IFF_BROADCAST"		},
-	{ IFF_DEBUG,		"IFF_DEBUG"		},
-	{ IFF_LOOPBACK,		"IFF_LOOPBACK"		},
-	{ IFF_POINTOPOINT,	"IFF_POINTOPOINT"	},
-	{ IFF_NOTRAILERS,	"IFF_NOTRAILERS"	},
-	{ IFF_RUNNING,		"IFF_RUNNING"		},
-	{ IFF_NOARP,		"IFF_NOARP"		},
-	{ IFF_PROMISC,		"IFF_PROMISC"		},
-	{ IFF_ALLMULTI,		"IFF_ALLMULTI"		},
-	{ IFF_MASTER,		"IFF_MASTER"		},
-	{ IFF_SLAVE,		"IFF_SLAVE"		},
-	{ IFF_MULTICAST,	"IFF_MULTICAST"		},
-	{ IFF_PORTSEL,		"IFF_PORTSEL"		},
-	{ IFF_AUTOMEDIA,	"IFF_AUTOMEDIA"		},
+	XLAT(IFF_UP),
+	XLAT(IFF_BROADCAST),
+	XLAT(IFF_DEBUG),
+	XLAT(IFF_LOOPBACK),
+	XLAT(IFF_POINTOPOINT),
+	XLAT(IFF_NOTRAILERS),
+	XLAT(IFF_RUNNING),
+	XLAT(IFF_NOARP),
+	XLAT(IFF_PROMISC),
+	XLAT(IFF_ALLMULTI),
+	XLAT(IFF_MASTER),
+	XLAT(IFF_SLAVE),
+	XLAT(IFF_MULTICAST),
+	XLAT(IFF_PORTSEL),
+	XLAT(IFF_AUTOMEDIA),
 	{ 0,			NULL			}
 };
 
diff --git a/stream.c b/stream.c
index f0c2af4..99d0897 100644
--- a/stream.c
+++ b/stream.c
@@ -56,7 +56,7 @@ struct strbuf {
 # endif
 
 static const struct xlat msgflags[] = {
-	{ RS_HIPRI,	"RS_HIPRI"	},
+	XLAT(RS_HIPRI),
 	{ 0,		NULL		},
 };
 
@@ -155,13 +155,13 @@ sys_getmsg(struct tcb *tcp)
 # if defined SYS_putpmsg || defined SYS_getpmsg
 static const struct xlat pmsgflags[] = {
 #  ifdef MSG_HIPRI
-	{ MSG_HIPRI,	"MSG_HIPRI"	},
+	XLAT(MSG_HIPRI),
 #  endif
 #  ifdef MSG_AND
-	{ MSG_ANY,	"MSG_ANY"	},
+	XLAT(MSG_ANY),
 #  endif
 #  ifdef MSG_BAND
-	{ MSG_BAND,	"MSG_BAND"	},
+	XLAT(MSG_BAND),
 #  endif
 	{ 0,		NULL		},
 };
@@ -244,24 +244,24 @@ sys_getpmsg(struct tcb *tcp)
 
 static const struct xlat pollflags[] = {
 # ifdef POLLIN
-	{ POLLIN,	"POLLIN"	},
-	{ POLLPRI,	"POLLPRI"	},
-	{ POLLOUT,	"POLLOUT"	},
+	XLAT(POLLIN),
+	XLAT(POLLPRI),
+	XLAT(POLLOUT),
 #  ifdef POLLRDNORM
-	{ POLLRDNORM,	"POLLRDNORM"	},
+	XLAT(POLLRDNORM),
 #  endif
 #  ifdef POLLWRNORM
-	{ POLLWRNORM,	"POLLWRNORM"	},
+	XLAT(POLLWRNORM),
 #  endif
 #  ifdef POLLRDBAND
-	{ POLLRDBAND,	"POLLRDBAND"	},
+	XLAT(POLLRDBAND),
 #  endif
 #  ifdef POLLWRBAND
-	{ POLLWRBAND,	"POLLWRBAND"	},
+	XLAT(POLLWRBAND),
 #  endif
-	{ POLLERR,	"POLLERR"	},
-	{ POLLHUP,	"POLLHUP"	},
-	{ POLLNVAL,	"POLLNVAL"	},
+	XLAT(POLLERR),
+	XLAT(POLLHUP),
+	XLAT(POLLNVAL),
 # endif
 	{ 0,		NULL		},
 };
diff --git a/system.c b/system.c
index 26d0d7f..08cf359 100644
--- a/system.c
+++ b/system.c
@@ -81,33 +81,33 @@
 #include <linux/sysctl.h>
 
 static const struct xlat mount_flags[] = {
-	{ MS_MGC_VAL,	"MS_MGC_VAL"	},
-	{ MS_RDONLY,	"MS_RDONLY"	},
-	{ MS_NOSUID,	"MS_NOSUID"	},
-	{ MS_NODEV,	"MS_NODEV"	},
-	{ MS_NOEXEC,	"MS_NOEXEC"	},
-	{ MS_SYNCHRONOUS,"MS_SYNCHRONOUS"},
-	{ MS_REMOUNT,	"MS_REMOUNT"	},
-	{ MS_RELATIME,	"MS_RELATIME"	},
-	{ MS_KERNMOUNT,	"MS_KERNMOUNT"	},
-	{ MS_I_VERSION,	"MS_I_VERSION"	},
-	{ MS_STRICTATIME,"MS_STRICTATIME"},
-	{ MS_NOSEC,	"MS_NOSEC"	},
-	{ MS_BORN,	"MS_BORN"	},
-	{ MS_MANDLOCK,	"MS_MANDLOCK"	},
-	{ MS_NOATIME,	"MS_NOATIME"	},
-	{ MS_NODIRATIME,"MS_NODIRATIME"	},
-	{ MS_BIND,	"MS_BIND"	},
-	{ MS_MOVE,	"MS_MOVE"	},
-	{ MS_REC,	"MS_REC"	},
-	{ MS_SILENT,	"MS_SILENT"	},
-	{ MS_POSIXACL,	"MS_POSIXACL"	},
-	{ MS_UNBINDABLE,"MS_UNBINDABLE"	},
-	{ MS_PRIVATE,	"MS_PRIVATE"	},
-	{ MS_SLAVE,	"MS_SLAVE"	},
-	{ MS_SHARED,	"MS_SHARED"	},
-	{ MS_ACTIVE,	"MS_ACTIVE"	},
-	{ MS_NOUSER,	"MS_NOUSER"	},
+	XLAT(MS_MGC_VAL),
+	XLAT(MS_RDONLY),
+	XLAT(MS_NOSUID),
+	XLAT(MS_NODEV),
+	XLAT(MS_NOEXEC),
+	XLAT(MS_SYNCHRONOUS),
+	XLAT(MS_REMOUNT),
+	XLAT(MS_RELATIME),
+	XLAT(MS_KERNMOUNT),
+	XLAT(MS_I_VERSION),
+	XLAT(MS_STRICTATIME),
+	XLAT(MS_NOSEC),
+	XLAT(MS_BORN),
+	XLAT(MS_MANDLOCK),
+	XLAT(MS_NOATIME),
+	XLAT(MS_NODIRATIME),
+	XLAT(MS_BIND),
+	XLAT(MS_MOVE),
+	XLAT(MS_REC),
+	XLAT(MS_SILENT),
+	XLAT(MS_POSIXACL),
+	XLAT(MS_UNBINDABLE),
+	XLAT(MS_PRIVATE),
+	XLAT(MS_SLAVE),
+	XLAT(MS_SHARED),
+	XLAT(MS_ACTIVE),
+	XLAT(MS_NOUSER),
 	{ 0,		NULL		},
 };
 
@@ -155,9 +155,9 @@ sys_mount(struct tcb *tcp)
 #define MNT_EXPIRE	0x00000004	/* Mark for expiry */
 
 static const struct xlat umount_flags[] = {
-	{ MNT_FORCE,	"MNT_FORCE"	},
-	{ MNT_DETACH,	"MNT_DETACH"	},
-	{ MNT_EXPIRE,	"MNT_EXPIRE"	},
+	XLAT(MNT_FORCE),
+	XLAT(MNT_DETACH),
+	XLAT(MNT_EXPIRE),
 	{ 0,		NULL		},
 };
 
@@ -222,17 +222,17 @@ enum {
 };
 
 static const struct xlat syslog_action_type[] = {
-	{ SYSLOG_ACTION_CLOSE,		"SYSLOG_ACTION_CLOSE"		},
-	{ SYSLOG_ACTION_OPEN,		"SYSLOG_ACTION_OPEN"		},
-	{ SYSLOG_ACTION_READ,		"SYSLOG_ACTION_READ"		},
-	{ SYSLOG_ACTION_READ_ALL,	"SYSLOG_ACTION_READ_ALL"	},
-	{ SYSLOG_ACTION_READ_CLEAR,	"SYSLOG_ACTION_READ_CLEAR"	},
-	{ SYSLOG_ACTION_CLEAR,		"SYSLOG_ACTION_CLEAR"		},
-	{ SYSLOG_ACTION_CONSOLE_OFF,	"SYSLOG_ACTION_CONSOLE_OFF"	},
-	{ SYSLOG_ACTION_CONSOLE_ON,	"SYSLOG_ACTION_CONSOLE_ON"	},
-	{ SYSLOG_ACTION_CONSOLE_LEVEL,	"SYSLOG_ACTION_CONSOLE_LEVEL"	},
-	{ SYSLOG_ACTION_SIZE_UNREAD,	"SYSLOG_ACTION_SIZE_UNREAD"	},
-	{ SYSLOG_ACTION_SIZE_BUFFER,	"SYSLOG_ACTION_SIZE_BUFFER"	},
+	XLAT(SYSLOG_ACTION_CLOSE),
+	XLAT(SYSLOG_ACTION_OPEN),
+	XLAT(SYSLOG_ACTION_READ),
+	XLAT(SYSLOG_ACTION_READ_ALL),
+	XLAT(SYSLOG_ACTION_READ_CLEAR),
+	XLAT(SYSLOG_ACTION_CLEAR),
+	XLAT(SYSLOG_ACTION_CONSOLE_OFF),
+	XLAT(SYSLOG_ACTION_CONSOLE_ON),
+	XLAT(SYSLOG_ACTION_CONSOLE_LEVEL),
+	XLAT(SYSLOG_ACTION_SIZE_UNREAD),
+	XLAT(SYSLOG_ACTION_SIZE_BUFFER),
 	{ 0,				NULL				}
 };
 
@@ -275,24 +275,24 @@ sys_syslog(struct tcb *tcp)
 
 #include <linux/reboot.h>
 static const struct xlat bootflags1[] = {
-	{ LINUX_REBOOT_MAGIC1,	"LINUX_REBOOT_MAGIC1"	},
+	XLAT(LINUX_REBOOT_MAGIC1),
 	{ 0,			NULL			},
 };
 
 static const struct xlat bootflags2[] = {
-	{ LINUX_REBOOT_MAGIC2,	"LINUX_REBOOT_MAGIC2"	},
-	{ LINUX_REBOOT_MAGIC2A,	"LINUX_REBOOT_MAGIC2A"	},
-	{ LINUX_REBOOT_MAGIC2B,	"LINUX_REBOOT_MAGIC2B"	},
+	XLAT(LINUX_REBOOT_MAGIC2),
+	XLAT(LINUX_REBOOT_MAGIC2A),
+	XLAT(LINUX_REBOOT_MAGIC2B),
 	{ 0,			NULL			},
 };
 
 static const struct xlat bootflags3[] = {
-	{ LINUX_REBOOT_CMD_CAD_OFF,	"LINUX_REBOOT_CMD_CAD_OFF"	},
-	{ LINUX_REBOOT_CMD_RESTART,	"LINUX_REBOOT_CMD_RESTART"	},
-	{ LINUX_REBOOT_CMD_HALT,	"LINUX_REBOOT_CMD_HALT"		},
-	{ LINUX_REBOOT_CMD_CAD_ON,	"LINUX_REBOOT_CMD_CAD_ON"	},
-	{ LINUX_REBOOT_CMD_POWER_OFF,	"LINUX_REBOOT_CMD_POWER_OFF"	},
-	{ LINUX_REBOOT_CMD_RESTART2,	"LINUX_REBOOT_CMD_RESTART2"	},
+	XLAT(LINUX_REBOOT_CMD_CAD_OFF),
+	XLAT(LINUX_REBOOT_CMD_RESTART),
+	XLAT(LINUX_REBOOT_CMD_HALT),
+	XLAT(LINUX_REBOOT_CMD_CAD_ON),
+	XLAT(LINUX_REBOOT_CMD_POWER_OFF),
+	XLAT(LINUX_REBOOT_CMD_RESTART2),
 	{ 0,				NULL				},
 };
 
@@ -316,26 +316,26 @@ sys_reboot(struct tcb *tcp)
 #ifdef M68K
 static const struct xlat cacheflush_scope[] = {
 #ifdef FLUSH_SCOPE_LINE
-	{ FLUSH_SCOPE_LINE,	"FLUSH_SCOPE_LINE" },
+	XLAT(FLUSH_SCOPE_LINE),
 #endif
 #ifdef FLUSH_SCOPE_PAGE
-	{ FLUSH_SCOPE_PAGE,	"FLUSH_SCOPE_PAGE" },
+	XLAT(FLUSH_SCOPE_PAGE),
 #endif
 #ifdef FLUSH_SCOPE_ALL
-	{ FLUSH_SCOPE_ALL,	"FLUSH_SCOPE_ALL" },
+	XLAT(FLUSH_SCOPE_ALL),
 #endif
 	{ 0,			NULL },
 };
 
 static const struct xlat cacheflush_flags[] = {
 #ifdef FLUSH_CACHE_BOTH
-	{ FLUSH_CACHE_BOTH,	"FLUSH_CACHE_BOTH" },
+	XLAT(FLUSH_CACHE_BOTH),
 #endif
 #ifdef FLUSH_CACHE_DATA
-	{ FLUSH_CACHE_DATA,	"FLUSH_CACHE_DATA" },
+	XLAT(FLUSH_CACHE_DATA),
 #endif
 #ifdef FLUSH_CACHE_INSN
-	{ FLUSH_CACHE_INSN,	"FLUSH_CACHE_INSN" },
+	XLAT(FLUSH_CACHE_INSN),
 #endif
 	{ 0,			NULL },
 };
@@ -363,11 +363,11 @@ sys_cacheflush(struct tcb *tcp)
 #include <bfin_sram.h>
 
 static const struct xlat sram_alloc_flags[] = {
-	{ L1_INST_SRAM,		"L1_INST_SRAM" },
-	{ L1_DATA_A_SRAM,	"L1_DATA_A_SRAM" },
-	{ L1_DATA_B_SRAM,	"L1_DATA_B_SRAM" },
-	{ L1_DATA_SRAM,		"L1_DATA_SRAM" },
-	{ L2_SRAM,		"L2_SRAM" },
+	XLAT(L1_INST_SRAM),
+	XLAT(L1_DATA_A_SRAM),
+	XLAT(L1_DATA_B_SRAM),
+	XLAT(L1_DATA_SRAM),
+	XLAT(L2_SRAM),
 	{ 0,			NULL },
 };
 
@@ -386,9 +386,9 @@ sys_sram_alloc(struct tcb *tcp)
 #include <asm/cachectl.h>
 
 static const struct xlat cacheflush_flags[] = {
-	{ ICACHE,	"ICACHE" },
-	{ DCACHE,	"DCACHE" },
-	{ BCACHE,	"BCACHE" },
+	XLAT(ICACHE),
+	XLAT(DCACHE),
+	XLAT(BCACHE),
 	{ 0,		NULL },
 };
 
@@ -411,16 +411,16 @@ sys_cacheflush(struct tcb *tcp)
 #ifdef SH
 static const struct xlat cacheflush_flags[] = {
 #ifdef CACHEFLUSH_D_INVAL
-	{ CACHEFLUSH_D_INVAL,	"CACHEFLUSH_D_INVAL" },
+	XLAT(CACHEFLUSH_D_INVAL),
 #endif
 #ifdef CACHEFLUSH_D_WB
-	{ CACHEFLUSH_D_WB,	"CACHEFLUSH_D_WB" },
+	XLAT(CACHEFLUSH_D_WB),
 #endif
 #ifdef CACHEFLUSH_D_PURGE
-	{ CACHEFLUSH_D_PURGE,	"CACHEFLUSH_D_PURGE" },
+	XLAT(CACHEFLUSH_D_PURGE),
 #endif
 #ifdef CACHEFLUSH_I
-	{ CACHEFLUSH_I,		"CACHEFLUSH_I" },
+	XLAT(CACHEFLUSH_I),
 #endif
 	{ 0,			NULL },
 };
@@ -499,9 +499,9 @@ static const struct xlat capabilities[] = {
 #endif
 
 static const struct xlat cap_version[] = {
-	{ _LINUX_CAPABILITY_VERSION_1,	"_LINUX_CAPABILITY_VERSION_1"	},
-	{ _LINUX_CAPABILITY_VERSION_2,	"_LINUX_CAPABILITY_VERSION_3"	},
-	{ _LINUX_CAPABILITY_VERSION_3,	"_LINUX_CAPABILITY_VERSION_3"	},
+	XLAT(_LINUX_CAPABILITY_VERSION_1),
+	XLAT(_LINUX_CAPABILITY_VERSION_2),
+	XLAT(_LINUX_CAPABILITY_VERSION_3),
 	{ 0,				NULL				}
 };
 
@@ -590,244 +590,244 @@ int sys_capset(struct tcb *tcp)
 # define CTL_PROC 4
 # define CTL_CPU 10		/* older headers lack */
 static const struct xlat sysctl_root[] = {
-	{ CTL_KERN, "CTL_KERN" },
-	{ CTL_VM, "CTL_VM" },
-	{ CTL_NET, "CTL_NET" },
-	{ CTL_PROC, "CTL_PROC" },
-	{ CTL_FS, "CTL_FS" },
-	{ CTL_DEBUG, "CTL_DEBUG" },
-	{ CTL_DEV, "CTL_DEV" },
-	{ CTL_BUS, "CTL_BUS" },
-	{ CTL_ABI, "CTL_ABI" },
-	{ CTL_CPU, "CTL_CPU" },
+	XLAT(CTL_KERN),
+	XLAT(CTL_VM),
+	XLAT(CTL_NET),
+	XLAT(CTL_PROC),
+	XLAT(CTL_FS),
+	XLAT(CTL_DEBUG),
+	XLAT(CTL_DEV),
+	XLAT(CTL_BUS),
+	XLAT(CTL_ABI),
+	XLAT(CTL_CPU),
 	{ 0, NULL }
 };
 
 static const struct xlat sysctl_kern[] = {
-	{ KERN_OSTYPE, "KERN_OSTYPE" },
-	{ KERN_OSRELEASE, "KERN_OSRELEASE" },
-	{ KERN_OSREV, "KERN_OSREV" },
-	{ KERN_VERSION, "KERN_VERSION" },
-	{ KERN_SECUREMASK, "KERN_SECUREMASK" },
-	{ KERN_PROF, "KERN_PROF" },
-	{ KERN_NODENAME, "KERN_NODENAME" },
-	{ KERN_DOMAINNAME, "KERN_DOMAINNAME" },
+	XLAT(KERN_OSTYPE),
+	XLAT(KERN_OSRELEASE),
+	XLAT(KERN_OSREV),
+	XLAT(KERN_VERSION),
+	XLAT(KERN_SECUREMASK),
+	XLAT(KERN_PROF),
+	XLAT(KERN_NODENAME),
+	XLAT(KERN_DOMAINNAME),
 #ifdef KERN_SECURELVL
-	{ KERN_SECURELVL, "KERN_SECURELVL" },
+	XLAT(KERN_SECURELVL),
 #endif
-	{ KERN_PANIC, "KERN_PANIC" },
+	XLAT(KERN_PANIC),
 #ifdef KERN_REALROOTDEV
-	{ KERN_REALROOTDEV, "KERN_REALROOTDEV" },
+	XLAT(KERN_REALROOTDEV),
 #endif
 #ifdef KERN_JAVA_INTERPRETER
-	{ KERN_JAVA_INTERPRETER, "KERN_JAVA_INTERPRETER" },
+	XLAT(KERN_JAVA_INTERPRETER),
 #endif
 #ifdef KERN_JAVA_APPLETVIEWER
-	{ KERN_JAVA_APPLETVIEWER, "KERN_JAVA_APPLETVIEWER" },
+	XLAT(KERN_JAVA_APPLETVIEWER),
 #endif
-	{ KERN_SPARC_REBOOT, "KERN_SPARC_REBOOT" },
-	{ KERN_CTLALTDEL, "KERN_CTLALTDEL" },
-	{ KERN_PRINTK, "KERN_PRINTK" },
-	{ KERN_NAMETRANS, "KERN_NAMETRANS" },
-	{ KERN_PPC_HTABRECLAIM, "KERN_PPC_HTABRECLAIM" },
-	{ KERN_PPC_ZEROPAGED, "KERN_PPC_ZEROPAGED" },
-	{ KERN_PPC_POWERSAVE_NAP, "KERN_PPC_POWERSAVE_NAP" },
-	{ KERN_MODPROBE, "KERN_MODPROBE" },
-	{ KERN_SG_BIG_BUFF, "KERN_SG_BIG_BUFF" },
-	{ KERN_ACCT, "KERN_ACCT" },
-	{ KERN_PPC_L2CR, "KERN_PPC_L2CR" },
-	{ KERN_RTSIGNR, "KERN_RTSIGNR" },
-	{ KERN_RTSIGMAX, "KERN_RTSIGMAX" },
-	{ KERN_SHMMAX, "KERN_SHMMAX" },
-	{ KERN_MSGMAX, "KERN_MSGMAX" },
-	{ KERN_MSGMNB, "KERN_MSGMNB" },
-	{ KERN_MSGPOOL, "KERN_MSGPOOL" },
+	XLAT(KERN_SPARC_REBOOT),
+	XLAT(KERN_CTLALTDEL),
+	XLAT(KERN_PRINTK),
+	XLAT(KERN_NAMETRANS),
+	XLAT(KERN_PPC_HTABRECLAIM),
+	XLAT(KERN_PPC_ZEROPAGED),
+	XLAT(KERN_PPC_POWERSAVE_NAP),
+	XLAT(KERN_MODPROBE),
+	XLAT(KERN_SG_BIG_BUFF),
+	XLAT(KERN_ACCT),
+	XLAT(KERN_PPC_L2CR),
+	XLAT(KERN_RTSIGNR),
+	XLAT(KERN_RTSIGMAX),
+	XLAT(KERN_SHMMAX),
+	XLAT(KERN_MSGMAX),
+	XLAT(KERN_MSGMNB),
+	XLAT(KERN_MSGPOOL),
 	{ 0, NULL }
 };
 
 static const struct xlat sysctl_vm[] = {
 #ifdef VM_SWAPCTL
-	{ VM_SWAPCTL, "VM_SWAPCTL" },
+	XLAT(VM_SWAPCTL),
 #endif
 #ifdef VM_UNUSED1
-	{ VM_UNUSED1, "VM_UNUSED1" },
+	XLAT(VM_UNUSED1),
 #endif
 #ifdef VM_SWAPOUT
-	{ VM_SWAPOUT, "VM_SWAPOUT" },
+	XLAT(VM_SWAPOUT),
 #endif
 #ifdef VM_UNUSED2
-	{ VM_UNUSED2, "VM_UNUSED2" },
+	XLAT(VM_UNUSED2),
 #endif
 #ifdef VM_FREEPG
-	{ VM_FREEPG, "VM_FREEPG" },
+	XLAT(VM_FREEPG),
 #endif
 #ifdef VM_UNUSED3
-	{ VM_UNUSED3, "VM_UNUSED3" },
+	XLAT(VM_UNUSED3),
 #endif
 #ifdef VM_BDFLUSH
-	{ VM_BDFLUSH, "VM_BDFLUSH" },
+	XLAT(VM_BDFLUSH),
 #endif
 #ifdef VM_UNUSED4
-	{ VM_UNUSED4, "VM_UNUSED4" },
+	XLAT(VM_UNUSED4),
 #endif
-	{ VM_OVERCOMMIT_MEMORY, "VM_OVERCOMMIT_MEMORY" },
+	XLAT(VM_OVERCOMMIT_MEMORY),
 #ifdef VM_BUFFERMEM
-	{ VM_BUFFERMEM, "VM_BUFFERMEM" },
+	XLAT(VM_BUFFERMEM),
 #endif
 #ifdef VM_UNUSED5
-	{ VM_UNUSED5, "VM_UNUSED5" },
+	XLAT(VM_UNUSED5),
 #endif
 #ifdef VM_PAGECACHE
-	{ VM_PAGECACHE, "VM_PAGECACHE" },
+	XLAT(VM_PAGECACHE),
 #endif
 #ifdef VM_UNUSED7
-	{ VM_UNUSED7, "VM_UNUSED7" },
+	XLAT(VM_UNUSED7),
 #endif
 #ifdef VM_PAGERDAEMON
-	{ VM_PAGERDAEMON, "VM_PAGERDAEMON" },
+	XLAT(VM_PAGERDAEMON),
 #endif
 #ifdef VM_UNUSED8
-	{ VM_UNUSED8, "VM_UNUSED8" },
+	XLAT(VM_UNUSED8),
 #endif
 #ifdef VM_PGT_CACHE
-	{ VM_PGT_CACHE, "VM_PGT_CACHE" },
+	XLAT(VM_PGT_CACHE),
 #endif
 #ifdef VM_UNUSED9
-	{ VM_UNUSED9, "VM_UNUSED9" },
+	XLAT(VM_UNUSED9),
 #endif
-	{ VM_PAGE_CLUSTER, "VM_PAGE_CLUSTER" },
+	XLAT(VM_PAGE_CLUSTER),
 	{ 0, NULL },
 };
 
 static const struct xlat sysctl_net[] = {
-	{ NET_CORE, "NET_CORE" },
-	{ NET_ETHER, "NET_ETHER" },
-	{ NET_802, "NET_802" },
-	{ NET_UNIX, "NET_UNIX" },
-	{ NET_IPV4, "NET_IPV4" },
-	{ NET_IPX, "NET_IPX" },
-	{ NET_ATALK, "NET_ATALK" },
-	{ NET_NETROM, "NET_NETROM" },
-	{ NET_AX25, "NET_AX25" },
-	{ NET_BRIDGE, "NET_BRIDGE" },
-	{ NET_ROSE, "NET_ROSE" },
-	{ NET_IPV6, "NET_IPV6" },
-	{ NET_X25, "NET_X25" },
-	{ NET_TR, "NET_TR" },
-	{ NET_DECNET, "NET_DECNET" },
+	XLAT(NET_CORE),
+	XLAT(NET_ETHER),
+	XLAT(NET_802),
+	XLAT(NET_UNIX),
+	XLAT(NET_IPV4),
+	XLAT(NET_IPX),
+	XLAT(NET_ATALK),
+	XLAT(NET_NETROM),
+	XLAT(NET_AX25),
+	XLAT(NET_BRIDGE),
+	XLAT(NET_ROSE),
+	XLAT(NET_IPV6),
+	XLAT(NET_X25),
+	XLAT(NET_TR),
+	XLAT(NET_DECNET),
 	{ 0, NULL }
 };
 
 static const struct xlat sysctl_net_core[] = {
-	{ NET_CORE_WMEM_MAX, "NET_CORE_WMEM_MAX" },
-	{ NET_CORE_RMEM_MAX, "NET_CORE_RMEM_MAX" },
-	{ NET_CORE_WMEM_DEFAULT, "NET_CORE_WMEM_DEFAULT" },
-	{ NET_CORE_RMEM_DEFAULT, "NET_CORE_RMEM_DEFAULT" },
-	{ NET_CORE_MAX_BACKLOG, "NET_CORE_MAX_BACKLOG" },
-	{ NET_CORE_FASTROUTE, "NET_CORE_FASTROUTE" },
-	{ NET_CORE_MSG_COST, "NET_CORE_MSG_COST" },
-	{ NET_CORE_MSG_BURST, "NET_CORE_MSG_BURST" },
-	{ NET_CORE_OPTMEM_MAX, "NET_CORE_OPTMEM_MAX" },
+	XLAT(NET_CORE_WMEM_MAX),
+	XLAT(NET_CORE_RMEM_MAX),
+	XLAT(NET_CORE_WMEM_DEFAULT),
+	XLAT(NET_CORE_RMEM_DEFAULT),
+	XLAT(NET_CORE_MAX_BACKLOG),
+	XLAT(NET_CORE_FASTROUTE),
+	XLAT(NET_CORE_MSG_COST),
+	XLAT(NET_CORE_MSG_BURST),
+	XLAT(NET_CORE_OPTMEM_MAX),
 	{ 0, NULL }
 };
 
 static const struct xlat sysctl_net_unix[] = {
-	{ NET_UNIX_DESTROY_DELAY, "NET_UNIX_DESTROY_DELAY" },
-	{ NET_UNIX_DELETE_DELAY, "NET_UNIX_DELETE_DELAY" },
+	XLAT(NET_UNIX_DESTROY_DELAY),
+	XLAT(NET_UNIX_DELETE_DELAY),
 	{ 0, NULL }
 };
 
 static const struct xlat sysctl_net_ipv4[] = {
-	{ NET_IPV4_FORWARD, "NET_IPV4_FORWARD" },
-	{ NET_IPV4_DYNADDR, "NET_IPV4_DYNADDR" },
-	{ NET_IPV4_CONF, "NET_IPV4_CONF" },
-	{ NET_IPV4_NEIGH, "NET_IPV4_NEIGH" },
-	{ NET_IPV4_ROUTE, "NET_IPV4_ROUTE" },
-	{ NET_IPV4_FIB_HASH, "NET_IPV4_FIB_HASH" },
-	{ NET_IPV4_TCP_TIMESTAMPS, "NET_IPV4_TCP_TIMESTAMPS" },
-	{ NET_IPV4_TCP_WINDOW_SCALING, "NET_IPV4_TCP_WINDOW_SCALING" },
-	{ NET_IPV4_TCP_SACK, "NET_IPV4_TCP_SACK" },
-	{ NET_IPV4_TCP_RETRANS_COLLAPSE, "NET_IPV4_TCP_RETRANS_COLLAPSE" },
-	{ NET_IPV4_DEFAULT_TTL, "NET_IPV4_DEFAULT_TTL" },
-	{ NET_IPV4_AUTOCONFIG, "NET_IPV4_AUTOCONFIG" },
-	{ NET_IPV4_NO_PMTU_DISC, "NET_IPV4_NO_PMTU_DISC" },
-	{ NET_IPV4_TCP_SYN_RETRIES, "NET_IPV4_TCP_SYN_RETRIES" },
-	{ NET_IPV4_IPFRAG_HIGH_THRESH, "NET_IPV4_IPFRAG_HIGH_THRESH" },
-	{ NET_IPV4_IPFRAG_LOW_THRESH, "NET_IPV4_IPFRAG_LOW_THRESH" },
-	{ NET_IPV4_IPFRAG_TIME, "NET_IPV4_IPFRAG_TIME" },
-	{ NET_IPV4_TCP_MAX_KA_PROBES, "NET_IPV4_TCP_MAX_KA_PROBES" },
-	{ NET_IPV4_TCP_KEEPALIVE_TIME, "NET_IPV4_TCP_KEEPALIVE_TIME" },
-	{ NET_IPV4_TCP_KEEPALIVE_PROBES, "NET_IPV4_TCP_KEEPALIVE_PROBES" },
-	{ NET_IPV4_TCP_RETRIES1, "NET_IPV4_TCP_RETRIES1" },
-	{ NET_IPV4_TCP_RETRIES2, "NET_IPV4_TCP_RETRIES2" },
-	{ NET_IPV4_TCP_FIN_TIMEOUT, "NET_IPV4_TCP_FIN_TIMEOUT" },
-	{ NET_IPV4_IP_MASQ_DEBUG, "NET_IPV4_IP_MASQ_DEBUG" },
-	{ NET_TCP_SYNCOOKIES, "NET_TCP_SYNCOOKIES" },
-	{ NET_TCP_STDURG, "NET_TCP_STDURG" },
-	{ NET_TCP_RFC1337, "NET_TCP_RFC1337" },
-	{ NET_TCP_SYN_TAILDROP, "NET_TCP_SYN_TAILDROP" },
-	{ NET_TCP_MAX_SYN_BACKLOG, "NET_TCP_MAX_SYN_BACKLOG" },
-	{ NET_IPV4_LOCAL_PORT_RANGE, "NET_IPV4_LOCAL_PORT_RANGE" },
-	{ NET_IPV4_ICMP_ECHO_IGNORE_ALL, "NET_IPV4_ICMP_ECHO_IGNORE_ALL" },
-	{ NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS, "NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS" },
-	{ NET_IPV4_ICMP_SOURCEQUENCH_RATE, "NET_IPV4_ICMP_SOURCEQUENCH_RATE" },
-	{ NET_IPV4_ICMP_DESTUNREACH_RATE, "NET_IPV4_ICMP_DESTUNREACH_RATE" },
-	{ NET_IPV4_ICMP_TIMEEXCEED_RATE, "NET_IPV4_ICMP_TIMEEXCEED_RATE" },
-	{ NET_IPV4_ICMP_PARAMPROB_RATE, "NET_IPV4_ICMP_PARAMPROB_RATE" },
-	{ NET_IPV4_ICMP_ECHOREPLY_RATE, "NET_IPV4_ICMP_ECHOREPLY_RATE" },
-	{ NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES, "NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES" },
-	{ NET_IPV4_IGMP_MAX_MEMBERSHIPS, "NET_IPV4_IGMP_MAX_MEMBERSHIPS" },
+	XLAT(NET_IPV4_FORWARD),
+	XLAT(NET_IPV4_DYNADDR),
+	XLAT(NET_IPV4_CONF),
+	XLAT(NET_IPV4_NEIGH),
+	XLAT(NET_IPV4_ROUTE),
+	XLAT(NET_IPV4_FIB_HASH),
+	XLAT(NET_IPV4_TCP_TIMESTAMPS),
+	XLAT(NET_IPV4_TCP_WINDOW_SCALING),
+	XLAT(NET_IPV4_TCP_SACK),
+	XLAT(NET_IPV4_TCP_RETRANS_COLLAPSE),
+	XLAT(NET_IPV4_DEFAULT_TTL),
+	XLAT(NET_IPV4_AUTOCONFIG),
+	XLAT(NET_IPV4_NO_PMTU_DISC),
+	XLAT(NET_IPV4_TCP_SYN_RETRIES),
+	XLAT(NET_IPV4_IPFRAG_HIGH_THRESH),
+	XLAT(NET_IPV4_IPFRAG_LOW_THRESH),
+	XLAT(NET_IPV4_IPFRAG_TIME),
+	XLAT(NET_IPV4_TCP_MAX_KA_PROBES),
+	XLAT(NET_IPV4_TCP_KEEPALIVE_TIME),
+	XLAT(NET_IPV4_TCP_KEEPALIVE_PROBES),
+	XLAT(NET_IPV4_TCP_RETRIES1),
+	XLAT(NET_IPV4_TCP_RETRIES2),
+	XLAT(NET_IPV4_TCP_FIN_TIMEOUT),
+	XLAT(NET_IPV4_IP_MASQ_DEBUG),
+	XLAT(NET_TCP_SYNCOOKIES),
+	XLAT(NET_TCP_STDURG),
+	XLAT(NET_TCP_RFC1337),
+	XLAT(NET_TCP_SYN_TAILDROP),
+	XLAT(NET_TCP_MAX_SYN_BACKLOG),
+	XLAT(NET_IPV4_LOCAL_PORT_RANGE),
+	XLAT(NET_IPV4_ICMP_ECHO_IGNORE_ALL),
+	XLAT(NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS),
+	XLAT(NET_IPV4_ICMP_SOURCEQUENCH_RATE),
+	XLAT(NET_IPV4_ICMP_DESTUNREACH_RATE),
+	XLAT(NET_IPV4_ICMP_TIMEEXCEED_RATE),
+	XLAT(NET_IPV4_ICMP_PARAMPROB_RATE),
+	XLAT(NET_IPV4_ICMP_ECHOREPLY_RATE),
+	XLAT(NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES),
+	XLAT(NET_IPV4_IGMP_MAX_MEMBERSHIPS),
 	{  0, NULL }
 };
 
 static const struct xlat sysctl_net_ipv4_route[] = {
-	{ NET_IPV4_ROUTE_FLUSH, "NET_IPV4_ROUTE_FLUSH" },
-	{ NET_IPV4_ROUTE_MIN_DELAY, "NET_IPV4_ROUTE_MIN_DELAY" },
-	{ NET_IPV4_ROUTE_MAX_DELAY, "NET_IPV4_ROUTE_MAX_DELAY" },
-	{ NET_IPV4_ROUTE_GC_THRESH, "NET_IPV4_ROUTE_GC_THRESH" },
-	{ NET_IPV4_ROUTE_MAX_SIZE, "NET_IPV4_ROUTE_MAX_SIZE" },
-	{ NET_IPV4_ROUTE_GC_MIN_INTERVAL, "NET_IPV4_ROUTE_GC_MIN_INTERVAL" },
-	{ NET_IPV4_ROUTE_GC_TIMEOUT, "NET_IPV4_ROUTE_GC_TIMEOUT" },
-	{ NET_IPV4_ROUTE_GC_INTERVAL, "NET_IPV4_ROUTE_GC_INTERVAL" },
-	{ NET_IPV4_ROUTE_REDIRECT_LOAD, "NET_IPV4_ROUTE_REDIRECT_LOAD" },
-	{ NET_IPV4_ROUTE_REDIRECT_NUMBER, "NET_IPV4_ROUTE_REDIRECT_NUMBER" },
-	{ NET_IPV4_ROUTE_REDIRECT_SILENCE, "NET_IPV4_ROUTE_REDIRECT_SILENCE" },
-	{ NET_IPV4_ROUTE_ERROR_COST, "NET_IPV4_ROUTE_ERROR_COST" },
-	{ NET_IPV4_ROUTE_ERROR_BURST, "NET_IPV4_ROUTE_ERROR_BURST" },
-	{ NET_IPV4_ROUTE_GC_ELASTICITY, "NET_IPV4_ROUTE_GC_ELASTICITY" },
+	XLAT(NET_IPV4_ROUTE_FLUSH),
+	XLAT(NET_IPV4_ROUTE_MIN_DELAY),
+	XLAT(NET_IPV4_ROUTE_MAX_DELAY),
+	XLAT(NET_IPV4_ROUTE_GC_THRESH),
+	XLAT(NET_IPV4_ROUTE_MAX_SIZE),
+	XLAT(NET_IPV4_ROUTE_GC_MIN_INTERVAL),
+	XLAT(NET_IPV4_ROUTE_GC_TIMEOUT),
+	XLAT(NET_IPV4_ROUTE_GC_INTERVAL),
+	XLAT(NET_IPV4_ROUTE_REDIRECT_LOAD),
+	XLAT(NET_IPV4_ROUTE_REDIRECT_NUMBER),
+	XLAT(NET_IPV4_ROUTE_REDIRECT_SILENCE),
+	XLAT(NET_IPV4_ROUTE_ERROR_COST),
+	XLAT(NET_IPV4_ROUTE_ERROR_BURST),
+	XLAT(NET_IPV4_ROUTE_GC_ELASTICITY),
 	{ 0, NULL }
 };
 
 static const struct xlat sysctl_net_ipv4_conf[] = {
-	{ NET_IPV4_CONF_FORWARDING, "NET_IPV4_CONF_FORWARDING" },
-	{ NET_IPV4_CONF_MC_FORWARDING, "NET_IPV4_CONF_MC_FORWARDING" },
-	{ NET_IPV4_CONF_PROXY_ARP, "NET_IPV4_CONF_PROXY_ARP" },
-	{ NET_IPV4_CONF_ACCEPT_REDIRECTS, "NET_IPV4_CONF_ACCEPT_REDIRECTS" },
-	{ NET_IPV4_CONF_SECURE_REDIRECTS, "NET_IPV4_CONF_SECURE_REDIRECTS" },
-	{ NET_IPV4_CONF_SEND_REDIRECTS, "NET_IPV4_CONF_SEND_REDIRECTS" },
-	{ NET_IPV4_CONF_SHARED_MEDIA, "NET_IPV4_CONF_SHARED_MEDIA" },
-	{ NET_IPV4_CONF_RP_FILTER, "NET_IPV4_CONF_RP_FILTER" },
-	{ NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE, "NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE" },
-	{ NET_IPV4_CONF_BOOTP_RELAY, "NET_IPV4_CONF_BOOTP_RELAY" },
-	{ NET_IPV4_CONF_LOG_MARTIANS, "NET_IPV4_CONF_LOG_MARTIANS" },
+	XLAT(NET_IPV4_CONF_FORWARDING),
+	XLAT(NET_IPV4_CONF_MC_FORWARDING),
+	XLAT(NET_IPV4_CONF_PROXY_ARP),
+	XLAT(NET_IPV4_CONF_ACCEPT_REDIRECTS),
+	XLAT(NET_IPV4_CONF_SECURE_REDIRECTS),
+	XLAT(NET_IPV4_CONF_SEND_REDIRECTS),
+	XLAT(NET_IPV4_CONF_SHARED_MEDIA),
+	XLAT(NET_IPV4_CONF_RP_FILTER),
+	XLAT(NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE),
+	XLAT(NET_IPV4_CONF_BOOTP_RELAY),
+	XLAT(NET_IPV4_CONF_LOG_MARTIANS),
 	{ 0, NULL }
 };
 
 static const struct xlat sysctl_net_ipv6[] = {
-	{ NET_IPV6_CONF, "NET_IPV6_CONF" },
-	{ NET_IPV6_NEIGH, "NET_IPV6_NEIGH" },
-	{ NET_IPV6_ROUTE, "NET_IPV6_ROUTE" },
+	XLAT(NET_IPV6_CONF),
+	XLAT(NET_IPV6_NEIGH),
+	XLAT(NET_IPV6_ROUTE),
 	{ 0, NULL }
 };
 
 static const struct xlat sysctl_net_ipv6_route[] = {
-	{ NET_IPV6_ROUTE_FLUSH, "NET_IPV6_ROUTE_FLUSH" },
-	{ NET_IPV6_ROUTE_GC_THRESH, "NET_IPV6_ROUTE_GC_THRESH" },
-	{ NET_IPV6_ROUTE_MAX_SIZE, "NET_IPV6_ROUTE_MAX_SIZE" },
-	{ NET_IPV6_ROUTE_GC_MIN_INTERVAL, "NET_IPV6_ROUTE_GC_MIN_INTERVAL" },
-	{ NET_IPV6_ROUTE_GC_TIMEOUT, "NET_IPV6_ROUTE_GC_TIMEOUT" },
-	{ NET_IPV6_ROUTE_GC_INTERVAL, "NET_IPV6_ROUTE_GC_INTERVAL" },
-	{ NET_IPV6_ROUTE_GC_ELASTICITY, "NET_IPV6_ROUTE_GC_ELASTICITY" },
+	XLAT(NET_IPV6_ROUTE_FLUSH),
+	XLAT(NET_IPV6_ROUTE_GC_THRESH),
+	XLAT(NET_IPV6_ROUTE_MAX_SIZE),
+	XLAT(NET_IPV6_ROUTE_GC_MIN_INTERVAL),
+	XLAT(NET_IPV6_ROUTE_GC_TIMEOUT),
+	XLAT(NET_IPV6_ROUTE_GC_INTERVAL),
+	XLAT(NET_IPV6_ROUTE_GC_ELASTICITY),
 	{ 0, NULL }
 };
 
@@ -993,11 +993,11 @@ sys_sysctl(struct tcb *tcp)
 #endif
 
 static const struct xlat sysmips_operations[] = {
-	{ SETNAME,		"SETNAME"	},
-	{ FLUSH_CACHE,		"FLUSH_CACHE"	},
-	{ MIPS_FIXADE,		"MIPS_FIXADE"	},
-	{ MIPS_RDNVRAM,		"MIPS_RDNVRAM"	},
-	{ MIPS_ATOMIC_SET,	"MIPS_ATOMIC_SET"	},
+	XLAT(SETNAME),
+	XLAT(FLUSH_CACHE),
+	XLAT(MIPS_FIXADE),
+	XLAT(MIPS_RDNVRAM),
+	XLAT(MIPS_ATOMIC_SET),
 	{ 0, NULL }
 };
 
diff --git a/term.c b/term.c
index 7b7de74..2c3db0d 100644
--- a/term.c
+++ b/term.c
@@ -36,130 +36,130 @@
 #endif
 
 static const struct xlat tcxonc_options[] = {
-	{ TCOOFF,	"TCOOFF"	},
-	{ TCOON,	"TCOON"		},
-	{ TCIOFF,	"TCIOFF"	},
-	{ TCION,	"TCION"		},
+	XLAT(TCOOFF),
+	XLAT(TCOON),
+	XLAT(TCIOFF),
+	XLAT(TCION),
 	{ 0,		NULL		},
 };
 
 #ifdef TCLFLSH
 static const struct xlat tcflsh_options[] = {
-	{ TCIFLUSH,	"TCIFLUSH"	},
-	{ TCOFLUSH,	"TCOFLUSH"	},
-	{ TCIOFLUSH,	"TCIOFLUSH"	},
+	XLAT(TCIFLUSH),
+	XLAT(TCOFLUSH),
+	XLAT(TCIOFLUSH),
 	{ 0,		NULL		},
 };
 #endif
 
 static const struct xlat baud_options[] = {
-	{ B0,		"B0"		},
-	{ B50,		"B50"		},
-	{ B75,		"B75"		},
-	{ B110,		"B110"		},
-	{ B134,		"B134"		},
-	{ B150,		"B150"		},
-	{ B200,		"B200"		},
-	{ B300,		"B300"		},
-	{ B600,		"B600"		},
-	{ B1200,	"B1200"		},
-	{ B1800,	"B1800"		},
-	{ B2400,	"B2400"		},
-	{ B4800,	"B4800"		},
-	{ B9600,	"B9600"		},
+	XLAT(B0),
+	XLAT(B50),
+	XLAT(B75),
+	XLAT(B110),
+	XLAT(B134),
+	XLAT(B150),
+	XLAT(B200),
+	XLAT(B300),
+	XLAT(B600),
+	XLAT(B1200),
+	XLAT(B1800),
+	XLAT(B2400),
+	XLAT(B4800),
+	XLAT(B9600),
 #ifdef B19200
-	{ B19200,	"B19200"	},
+	XLAT(B19200),
 #endif
 #ifdef B38400
-	{ B38400,	"B38400"	},
+	XLAT(B38400),
 #endif
 #ifdef B57600
-	{ B57600,	"B57600"	},
+	XLAT(B57600),
 #endif
 #ifdef B115200
-	{ B115200,	"B115200"	},
+	XLAT(B115200),
 #endif
 #ifdef B230400
-	{ B230400,	"B230400"	},
+	XLAT(B230400),
 #endif
 #ifdef B460800
-	{ B460800,	"B460800"	},
+	XLAT(B460800),
 #endif
 #ifdef B500000
-	{ B500000,	"B500000"	},
+	XLAT(B500000),
 #endif
 #ifdef B576000
-	{ B576000,	"B576000"	},
+	XLAT(B576000),
 #endif
 #ifdef B921600
-	{ B921600,	"B921600"	},
+	XLAT(B921600),
 #endif
 #ifdef B1000000
-	{ B1000000,	"B1000000"	},
+	XLAT(B1000000),
 #endif
 #ifdef B1152000
-	{ B1152000,	"B1152000"	},
+	XLAT(B1152000),
 #endif
 #ifdef B1500000
-	{ B1500000,	"B1500000"	},
+	XLAT(B1500000),
 #endif
 #ifdef B2000000
-	{ B2000000,	"B2000000"	},
+	XLAT(B2000000),
 #endif
 #ifdef B2500000
-	{ B2500000,	"B2500000"	},
+	XLAT(B2500000),
 #endif
 #ifdef B3000000
-	{ B3000000,	"B3000000"	},
+	XLAT(B3000000),
 #endif
 #ifdef B3500000
-	{ B3500000,	"B3500000"	},
+	XLAT(B3500000),
 #endif
 #ifdef B4000000
-	{ B4000000,	"B4000000"	},
+	XLAT(B4000000),
 #endif
 #ifdef EXTA
-	{ EXTA,		"EXTA"		},
+	XLAT(EXTA),
 #endif
 #ifdef EXTB
-	{ EXTB,		"EXTB"		},
+	XLAT(EXTB),
 #endif
 	{ 0,		NULL		},
 };
 
 static const struct xlat modem_flags[] = {
 #ifdef TIOCM_LE
-	{ TIOCM_LE,	"TIOCM_LE",	},
+	XLAT(TIOCM_LE),
 #endif
 #ifdef TIOCM_DTR
-	{ TIOCM_DTR,	"TIOCM_DTR",	},
+	XLAT(TIOCM_DTR),
 #endif
 #ifdef TIOCM_RTS
-	{ TIOCM_RTS,	"TIOCM_RTS",	},
+	XLAT(TIOCM_RTS),
 #endif
 #ifdef TIOCM_ST
-	{ TIOCM_ST,	"TIOCM_ST",	},
+	XLAT(TIOCM_ST),
 #endif
 #ifdef TIOCM_SR
-	{ TIOCM_SR,	"TIOCM_SR",	},
+	XLAT(TIOCM_SR),
 #endif
 #ifdef TIOCM_CTS
-	{ TIOCM_CTS,	"TIOCM_CTS",	},
+	XLAT(TIOCM_CTS),
 #endif
 #ifdef TIOCM_CAR
-	{ TIOCM_CAR,	"TIOCM_CAR",	},
+	XLAT(TIOCM_CAR),
 #endif
 #ifdef TIOCM_CD
-	{ TIOCM_CD,	"TIOCM_CD",	},
+	XLAT(TIOCM_CD),
 #endif
 #ifdef TIOCM_RNG
-	{ TIOCM_RNG,	"TIOCM_RNG",	},
+	XLAT(TIOCM_RNG),
 #endif
 #ifdef TIOCM_RI
-	{ TIOCM_RI,	"TIOCM_RI",	},
+	XLAT(TIOCM_RI),
 #endif
 #ifdef TIOCM_DSR
-	{ TIOCM_DSR,	"TIOCM_DSR",	},
+	XLAT(TIOCM_DSR),
 #endif
 	{ 0,		NULL,		},
 };
diff --git a/time.c b/time.c
index 9a27bca..3c50b80 100644
--- a/time.c
+++ b/time.c
@@ -280,9 +280,9 @@ sys_nanosleep(struct tcb *tcp)
 }
 
 static const struct xlat which[] = {
-	{ ITIMER_REAL,	"ITIMER_REAL"	},
-	{ ITIMER_VIRTUAL,"ITIMER_VIRTUAL"},
-	{ ITIMER_PROF,	"ITIMER_PROF"	},
+	XLAT(ITIMER_REAL),
+	XLAT(ITIMER_VIRTUAL),
+	XLAT(ITIMER_PROF),
 	{ 0,		NULL		},
 };
 
@@ -403,119 +403,119 @@ sys_osf_setitimer(struct tcb *tcp)
 #endif
 
 static const struct xlat adjtimex_modes[] = {
-	{ 0,		"0"			},
+	XLAT(0),
 #ifdef ADJ_OFFSET
-	{ ADJ_OFFSET,	"ADJ_OFFSET"		},
+	XLAT(ADJ_OFFSET),
 #endif
 #ifdef ADJ_FREQUENCY
-	{ ADJ_FREQUENCY, "ADJ_FREQUENCY"	},
+	XLAT(ADJ_FREQUENCY),
 #endif
 #ifdef ADJ_MAXERROR
-	{ ADJ_MAXERROR,	"ADJ_MAXERROR"		},
+	XLAT(ADJ_MAXERROR),
 #endif
 #ifdef ADJ_ESTERROR
-	{ ADJ_ESTERROR,	"ADJ_ESTERROR"		},
+	XLAT(ADJ_ESTERROR),
 #endif
 #ifdef ADJ_STATUS
-	{ ADJ_STATUS,	"ADJ_STATUS"		},
+	XLAT(ADJ_STATUS),
 #endif
 #ifdef ADJ_TIMECONST
-	{ ADJ_TIMECONST, "ADJ_TIMECONST"	},
+	XLAT(ADJ_TIMECONST),
 #endif
 #ifdef ADJ_TAI
-	{ ADJ_TAI, "ADJ_TAI"			},
+	XLAT(ADJ_TAI),
 #endif
 #ifdef ADJ_SETOFFSET
-	{ ADJ_SETOFFSET, "ADJ_SETOFFSET"	},
+	XLAT(ADJ_SETOFFSET),
 #endif
 #ifdef ADJ_MICRO
-	{ ADJ_MICRO, "ADJ_MICRO"		},
+	XLAT(ADJ_MICRO),
 #endif
 #ifdef ADJ_NANO
-	{ ADJ_NANO, "ADJ_NANO"			},
+	XLAT(ADJ_NANO),
 #endif
 #ifdef ADJ_TICK
-	{ ADJ_TICK,	"ADJ_TICK"		},
+	XLAT(ADJ_TICK),
 #endif
 #ifdef ADJ_OFFSET_SINGLESHOT
-	{ ADJ_OFFSET_SINGLESHOT, "ADJ_OFFSET_SINGLESHOT" },
+	XLAT(ADJ_OFFSET_SINGLESHOT),
 #endif
 #ifdef ADJ_OFFSET_SS_READ
-	{ ADJ_OFFSET_SS_READ, "ADJ_OFFSET_SS_READ" },
+	XLAT(ADJ_OFFSET_SS_READ),
 #endif
 	{ 0,		NULL			}
 };
 
 static const struct xlat adjtimex_status[] = {
 #ifdef STA_PLL
-	{ STA_PLL,	"STA_PLL"	},
+	XLAT(STA_PLL),
 #endif
 #ifdef STA_PPSFREQ
-	{ STA_PPSFREQ,	"STA_PPSFREQ"	},
+	XLAT(STA_PPSFREQ),
 #endif
 #ifdef STA_PPSTIME
-	{ STA_PPSTIME,	"STA_PPSTIME"	},
+	XLAT(STA_PPSTIME),
 #endif
 #ifdef STA_FLL
-	{ STA_FLL,	"STA_FLL"	},
+	XLAT(STA_FLL),
 #endif
 #ifdef STA_INS
-	{ STA_INS,	"STA_INS"	},
+	XLAT(STA_INS),
 #endif
 #ifdef STA_DEL
-	{ STA_DEL,	"STA_DEL"	},
+	XLAT(STA_DEL),
 #endif
 #ifdef STA_UNSYNC
-	{ STA_UNSYNC,	"STA_UNSYNC"	},
+	XLAT(STA_UNSYNC),
 #endif
 #ifdef STA_FREQHOLD
-	{ STA_FREQHOLD,	"STA_FREQHOLD"	},
+	XLAT(STA_FREQHOLD),
 #endif
 #ifdef STA_PPSSIGNAL
-	{ STA_PPSSIGNAL, "STA_PPSSIGNAL" },
+	XLAT(STA_PPSSIGNAL),
 #endif
 #ifdef STA_PPSJITTER
-	{ STA_PPSJITTER, "STA_PPSJITTER" },
+	XLAT(STA_PPSJITTER),
 #endif
 #ifdef STA_PPSWANDER
-	{ STA_PPSWANDER, "STA_PPSWANDER" },
+	XLAT(STA_PPSWANDER),
 #endif
 #ifdef STA_PPSERROR
-	{ STA_PPSERROR,	"STA_PPSERROR"	},
+	XLAT(STA_PPSERROR),
 #endif
 #ifdef STA_CLOCKERR
-	{ STA_CLOCKERR,	"STA_CLOCKERR"	},
+	XLAT(STA_CLOCKERR),
 #endif
 #ifdef STA_NANO
-	{ STA_NANO,	"STA_NANO"	},
+	XLAT(STA_NANO),
 #endif
 #ifdef STA_MODE
-	{ STA_MODE,	"STA_MODE"	},
+	XLAT(STA_MODE),
 #endif
 #ifdef STA_CLK
-	{ STA_CLK,	"STA_CLK"	},
+	XLAT(STA_CLK),
 #endif
 	{ 0,		NULL		}
 };
 
 static const struct xlat adjtimex_state[] = {
 #ifdef TIME_OK
-	{ TIME_OK,	"TIME_OK"	},
+	XLAT(TIME_OK),
 #endif
 #ifdef TIME_INS
-	{ TIME_INS,	"TIME_INS"	},
+	XLAT(TIME_INS),
 #endif
 #ifdef TIME_DEL
-	{ TIME_DEL,	"TIME_DEL"	},
+	XLAT(TIME_DEL),
 #endif
 #ifdef TIME_OOP
-	{ TIME_OOP,	"TIME_OOP"	},
+	XLAT(TIME_OOP),
 #endif
 #ifdef TIME_WAIT
-	{ TIME_WAIT,	"TIME_WAIT"	},
+	XLAT(TIME_WAIT),
 #endif
 #ifdef TIME_ERROR
-	{ TIME_ERROR,	"TIME_ERROR"	},
+	XLAT(TIME_ERROR),
 #endif
 	{ 0,		NULL		}
 };
@@ -639,40 +639,40 @@ sys_adjtimex(struct tcb *tcp)
 }
 
 static const struct xlat clockflags[] = {
-	{ TIMER_ABSTIME,	"TIMER_ABSTIME"	},
+	XLAT(TIMER_ABSTIME),
 	{ 0,			NULL		}
 };
 
 static const struct xlat clocknames[] = {
 #ifdef CLOCK_REALTIME
-	{ CLOCK_REALTIME,		"CLOCK_REALTIME" },
+	XLAT(CLOCK_REALTIME),
 #endif
 #ifdef CLOCK_MONOTONIC
-	{ CLOCK_MONOTONIC,		"CLOCK_MONOTONIC" },
+	XLAT(CLOCK_MONOTONIC),
 #endif
 #ifdef CLOCK_PROCESS_CPUTIME_ID
-	{ CLOCK_PROCESS_CPUTIME_ID,	"CLOCK_PROCESS_CPUTIME_ID" },
+	XLAT(CLOCK_PROCESS_CPUTIME_ID),
 #endif
 #ifdef CLOCK_THREAD_CPUTIME_ID
-	{ CLOCK_THREAD_CPUTIME_ID,	"CLOCK_THREAD_CPUTIME_ID" },
+	XLAT(CLOCK_THREAD_CPUTIME_ID),
 #endif
 #ifdef CLOCK_MONOTONIC_RAW
-	{ CLOCK_MONOTONIC_RAW,		"CLOCK_MONOTONIC_RAW" },
+	XLAT(CLOCK_MONOTONIC_RAW),
 #endif
 #ifdef CLOCK_REALTIME_COARSE
-	{ CLOCK_REALTIME_COARSE,	"CLOCK_REALTIME_COARSE" },
+	XLAT(CLOCK_REALTIME_COARSE),
 #endif
 #ifdef CLOCK_MONOTONIC_COARSE
-	{ CLOCK_MONOTONIC_COARSE,	"CLOCK_MONOTONIC_COARSE" },
+	XLAT(CLOCK_MONOTONIC_COARSE),
 #endif
 	{ 0,				NULL }
 };
 
 #ifdef CLOCKID_TO_FD
 static const struct xlat cpuclocknames[] = {
-	{ CPUCLOCK_PROF,	"CPUCLOCK_PROF" },
-	{ CPUCLOCK_VIRT,	"CPUCLOCK_VIRT" },
-	{ CPUCLOCK_SCHED,	"CPUCLOCK_SCHED" },
+	XLAT(CPUCLOCK_PROF),
+	XLAT(CPUCLOCK_VIRT),
+	XLAT(CPUCLOCK_SCHED),
 	{ 0, NULL }
 };
 #endif
@@ -988,7 +988,7 @@ rtc_ioctl(struct tcb *tcp, long code, long arg)
 #endif
 
 static const struct xlat timerfdflags[] = {
-	{ TFD_TIMER_ABSTIME,	"TFD_TIMER_ABSTIME"	},
+	XLAT(TFD_TIMER_ABSTIME),
 	{ 0,			NULL			}
 };