diff --git a/libs/libc/csetjmp.c2i b/libs/libc/csetjmp.c2i
index 119eaac4f..fcf5eba30 100644
--- a/libs/libc/csetjmp.c2i
+++ b/libs/libc/csetjmp.c2i
@@ -28,7 +28,7 @@ struct JmpBufTag @(cname="__jmp_buf_tag", aligned=8) {
 typedef JmpBufTag* JmpBuf @(cname="jmp_buf");
 
 // TODO alias setjmp -> _setjmp
-int setjmp(JmpBuf __env);
-int _setjmp(JmpBuf __env);
-void longjmp(JmpBuf __env, int __val) @(noreturn);
+int setjmp(JmpBuf env);
+int _setjmp(JmpBuf env);
+void longjmp(JmpBuf env, int val) @(noreturn);
 
diff --git a/libs/libc/ifaddrs.c2i b/libs/libc/ifaddrs.c2i
index c667db675..3357fad32 100644
--- a/libs/libc/ifaddrs.c2i
+++ b/libs/libc/ifaddrs.c2i
@@ -31,7 +31,7 @@ struct Ifaddrs {
    The storage returned in *IFAP is allocated dynamically and can
    only be properly freed by passing it to `freeifaddrs'.
 */
-int get(Ifaddrs** __ifap) @(cname="getifaddrs");
+int get(Ifaddrs** ifap) @(cname="getifaddrs");
 
 /* Reclaim the storage allocated by a previous `getifaddrs' call.  */
-void Ifaddrs.free(Ifaddrs* __ifa) @(cname="freeifaddrs");
+void Ifaddrs.free(Ifaddrs* ifa) @(cname="freeifaddrs");
diff --git a/libs/libc/libc_fcntl.c2i b/libs/libc/libc_fcntl.c2i
index 17b8b4dc9..a88b6a24c 100644
--- a/libs/libc/libc_fcntl.c2i
+++ b/libs/libc/libc_fcntl.c2i
@@ -64,7 +64,7 @@ const u32 F_SETFL = 4;
 
 const u32 FD_CLOEXEC = 1;
 
-int open(const char* __file, int __oflag, ...);
+int open(const char* file, int oflag, ...);
 int openat(int dirfd, const char* pathname, int flags, ...);
-int fcntl(int __fd, int __cmd, ...);
+int fcntl(int fd, int cmd, ...);
 
diff --git a/libs/libc/libc_time.c2i b/libs/libc/libc_time.c2i
index ccb861c89..2b4aa8068 100644
--- a/libs/libc/libc_time.c2i
+++ b/libs/libc/libc_time.c2i
@@ -15,23 +15,24 @@ struct Tm {
     const char* tm_zone;
 }
 
-type Time long @(cname="time_t");
+typedef long time_t;
+type Time time_t;
 
-Time time(Time* tloc);
+time_t time(time_t* tloc);
 
 char* asctime(const Tm* tm);
 char* asctime_r(const Tm* tm, char* buf);
 
-char* ctime(const Time* timep);
-char* ctime_r(const Time* timep, char* buf);
+char* ctime(const time_t* timep);
+char* ctime_r(const time_t* timep, char* buf);
 
-Time* gmtime(const Time* timep);
-Time* gmtime_r(const Time* timep, Tm* result);
+time_t* gmtime(const time_t* timep);
+time_t* gmtime_r(const time_t* timep, Tm* result);
 
-Tm* localtime(const Time* timep);
-Tm* localtime_r(const Time* timep, Tm* result);
+Tm* localtime(const time_t* timep);
+Tm* localtime_r(const time_t* timep, Tm* result);
 
-Time mktime(Tm* tm);
+time_t mktime(Tm* tm);
 
 size_t strftime(char* s, size_t max, const char* format, const Tm* tm);
 
diff --git a/libs/libc/regex.c2i b/libs/libc/regex.c2i
index 7314b1798..caaa4eb1e 100644
--- a/libs/libc/regex.c2i
+++ b/libs/libc/regex.c2i
@@ -1,18 +1,22 @@
 module regex extern "C";
 
-struct Regex_t @(cname="regex_t") {
+struct regex_t {
     void* re_pcre;
     size_t re_nsub;
     size_t re_erroffset;
 }
 
-typedef int RegOff @(cname="regoff_t");
+typedef int regoff_t;
 
-struct Regmatch_t @(cname="regmatch_t") {
-    RegOff rm_so;
-    RegOff rm_eo;
+struct regmatch_t {
+    regoff_t rm_so;
+    regoff_t rm_eo;
 }
 
+type Regex regex_t;
+type RegOff regoff_t;
+type Regmatch regmatch_t;
+
 /* regcomp() flags */
 const int REG_BASIC = 0000;
 const int REG_EXTENDED = 0001;
@@ -54,8 +58,8 @@ const int REG_TRACE = 00400;
 const int REG_LARGE = 01000;
 const int REG_BACKR = 02000;
 
-int regcomp(Regex_t* preg, const char* pattern, int cflags);
-int regexec(const Regex_t* preg, const char* string, size_t nmatch, Regmatch_t* pmatch, int eflags);
-size_t regerror(int errcode, const Regex_t* preg, char* errbuf, size_t errbuf_size);
-void regfree(Regex_t* preg);
+int regcomp(regex_t* preg, const char* pattern, int cflags);
+int regexec(const regex_t* preg, const char* string, size_t nmatch, regmatch_t* pmatch, int eflags);
+size_t regerror(int errcode, const regex_t* preg, char* errbuf, size_t errbuf_size);
+void regfree(regex_t* preg);
 
diff --git a/libs/libc/stdio.c2i b/libs/libc/stdio.c2i
index 34fbc9ffc..f674bf07e 100644
--- a/libs/libc/stdio.c2i
+++ b/libs/libc/stdio.c2i
@@ -74,93 +74,92 @@ FILE[] stderr @(cname="__stderr", cdef="extern FILE __stderr[]");
 #endif
 #endif
 
-int remove(const char* __filename);
-int rename(const char* __old, const char* __new);
+int remove(const char* filename);
+int rename(const char* oldname, const char* newname);
 
 FILE* tmpfile(void);
-char* tmpnam(char* __s) @(deprecated="use unistd.mkstemp instead");
-char* tempnam(const char* __dir, const char* __pfx) @(deprecated="use unistd.mkstemp instead");
-int fclose(FILE* __stream);
-int fflush(FILE* __stream);
-FILE* fopen(const char* __filename, const char* __modes);
-FILE* freopen(const char* __filename, const char* __modes, FILE* __stream);
-FILE* fdopen(int __fd, const char* __modes);
-void setbuf(FILE* __stream, char* __buf);
-int setvbuf(FILE* __stream, char* __buf, int __modes, size_t __n);
-void setbuffer(FILE* __stream, char* __buf, size_t __size);
-void setlinebuf(FILE* __stream);
-int fprintf(FILE* __stream, const char* __format @(printf_format), ...);
-int printf(const char* __format @(printf_format), ...);
-int sprintf(char* __s, const char* __format @(printf_format), ...);
-int snprintf(char* __s, size_t size, const char* __format @(printf_format), ...);
-int dprintf(int __fd, const char* __fmt @(printf_format), ...);
-int fscanf(FILE* __stream, const char* __format @(scanf_format), ...);
-int scanf(const char* __format @(scanf_format), ...);
-int sscanf(const char* __s, const char* __format @(scanf_format), ...);
-int fgetc(FILE* __stream);
-int getc(FILE* __stream);
+char* tmpnam(char* s) @(deprecated="use unistd.mkstemp instead");
+char* tempnam(const char* dir, const char* pfx) @(deprecated="use unistd.mkstemp instead");
+int fclose(FILE* stream);
+int fflush(FILE* stream);
+FILE* fopen(const char* filename, const char* modes);
+FILE* freopen(const char* filename, const char* modes, FILE* stream);
+FILE* fdopen(int fd, const char* modes);
+void setbuf(FILE* stream, char* buf);
+int setvbuf(FILE* stream, char* buf, int modes, size_t n);
+void setbuffer(FILE* stream, char* buf, size_t size);
+void setlinebuf(FILE* stream);
+int fprintf(FILE* stream, const char* format @(printf_format), ...);
+int printf(const char* format @(printf_format), ...);
+int sprintf(char* s, const char* format @(printf_format), ...);
+int snprintf(char* s, size_t size, const char* format @(printf_format), ...);
+int dprintf(int fd, const char* format @(printf_format), ...);
+int fscanf(FILE* stream, const char* format @(scanf_format), ...);
+int scanf(const char* format @(scanf_format), ...);
+int sscanf(const char* s, const char* format @(scanf_format), ...);
+int fgetc(FILE* stream);
+int getc(FILE* stream);
 int getchar(void);
-int getc_unlocked(FILE* __stream);
+int getc_unlocked(FILE* stream);
 int getchar_unlocked(void);
-int fputc(int __c, FILE* __stream);
-int putc(int __c, FILE* __stream);
-int putchar(int __c);
-int putchar_unlocked(int __c);
-char* gets(char* __s) @(deprecated="function cannot be used safely, consider using getsn");
-int getw(FILE* __stream);
-int putw(int __w, FILE* __stream);
-char* fgets(char* __s, int __n, FILE* __stream);
-ssize_t getdelim(char** __lineptr, size_t* __n, int __delimiter, FILE* __stream);
-ssize_t getline(char** __lineptr, size_t* __n, FILE* __stream);
-int fputs(const char* __s, FILE* __stream);
-int puts(const char* __s);
-int ungetc(int __c, FILE* __stream);
-size_t fread(void* __ptr, size_t __size, size_t __n, FILE* __stream);
-size_t fwrite(const void* __ptr, size_t __size, size_t __n, FILE* __s);
-int fseek(FILE* __stream, long __off, int __whence);
-long ftell(FILE* __stream);
-void rewind(FILE* __stream);
-int fseeko(FILE* __stream, Offset __off, int __whence);
-Offset ftello(FILE* __stream);
-int fgetpos(FILE* __stream, fpos_t* __pos);
-int fsetpos(FILE* __stream, const fpos_t* __pos);
-void clearerr(FILE* __stream);
-int feof(FILE* __stream);
-int ferror(FILE* __stream);
-void perror(const char* __s);
-int fileno(FILE* __stream);
-FILE* popen(const char* __command, const char* __modes);
-int pclose(FILE* __stream);
-char* ctermid(char* __s);
-void flockfile(FILE* __stream);
-int ftrylockfile(FILE* __stream);
-void funlockfile(FILE* __stream);
+int fputc(int c, FILE* stream);
+int putc(int c, FILE* stream);
+int putchar(int c);
+int putchar_unlocked(int c);
+char* gets(char* s) @(deprecated="function cannot be used safely, consider using getsn");
+int getw(FILE* stream);
+int putw(int w, FILE* stream);
+char* fgets(char* s, int n, FILE* stream);
+ssize_t getdelim(char** lineptr, size_t* n, int delimiter, FILE* stream);
+ssize_t getline(char** lineptr, size_t* n, FILE* stream);
+int fputs(const char* s, FILE* stream);
+int puts(const char* s);
+int ungetc(int c, FILE* stream);
+size_t fread(void* ptr, size_t size, size_t n, FILE* stream);
+size_t fwrite(const void* ptr, size_t size, size_t n, FILE* s);
+int fseek(FILE* stream, long off, int whence);
+long ftell(FILE* stream);
+void rewind(FILE* stream);
+int fseeko(FILE* stream, off_t off, int whence);
+off_t ftello(FILE* stream);
+int fgetpos(FILE* stream, fpos_t* pos);
+int fsetpos(FILE* stream, const fpos_t* pos);
+void clearerr(FILE* stream);
+int feof(FILE* stream);
+int ferror(FILE* stream);
+void perror(const char* s);
+int fileno(FILE* stream);
+FILE* popen(const char* command, const char* modes);
+int pclose(FILE* stream);
+char* ctermid(char* s);
+void flockfile(FILE* stream);
+int ftrylockfile(FILE* stream);
+void funlockfile(FILE* stream);
 
 // --- Linux only ---
 #if __USE_LARGEFILE64
 FILE* tmpfile64(void);
 #endif
-char* tmpnam_r(char* __s);
-int renameat(int __oldfd, const char* __old, int __newfd, const char* __new);
-FILE* fmemopen(void* __s, size_t __len, const char* __modes);
-FILE* open_memstream(char** __bufloc, size_t* __sizeloc);
-int fflush_unlocked(FILE* __stream);
-int fgetc_unlocked(FILE* __stream);
-int putc_unlocked(int __c, FILE* __stream);
-int fputc_unlocked(int __c, FILE* __stream);
-ssize_t __getdelim(char** __lineptr, size_t* __n, int __delimiter, FILE* __stream);
-int fread_unlocked(void* __ptr, size_t __size, size_t __n, FILE* __stream);
-size_t fwrite_unlocked(const void* __ptr, size_t __size, size_t __n, FILE* __stream);
-void clearerr_unlocked(FILE* __stream);
-int feof_unlocked(FILE* __stream);
-int ferror_unlocked(FILE* __stream);
+char* tmpnam_r(char* s);
+int renameat(int oldfd, const char* old, int newfd, const char* newname);
+FILE* fmemopen(void* s, size_t len, const char* modes);
+FILE* open_memstream(char** bufloc, size_t* sizeloc);
+int fflush_unlocked(FILE* stream);
+int fgetc_unlocked(FILE* stream);
+int putc_unlocked(int c, FILE* stream);
+int fputc_unlocked(int c, FILE* stream);
+int fread_unlocked(void* ptr, size_t size, size_t n, FILE* stream);
+size_t fwrite_unlocked(const void* ptr, size_t size, size_t n, FILE* stream);
+void clearerr_unlocked(FILE* stream);
+int feof_unlocked(FILE* stream);
+int ferror_unlocked(FILE* stream);
 
 // --- Darwin/BSD only----
 // unlocked functions below exist, but as macro
-//void clearerr_unlocked(FILE* __stream);
-//int feof_unlocked(FILE* __stream);
-//int ferror_unlocked(FILE* __stream);
-//int fileno_unlocked(FILE* __stream);
+//void clearerr_unlocked(FILE* stream);
+//int feof_unlocked(FILE* stream);
+//int ferror_unlocked(FILE* stream);
+//int fileno_unlocked(FILE* stream);
 
 int asprintf(char**, const char* @(printf_format), ...);
 char* ctermid_r(char*);
@@ -170,7 +169,7 @@ int fpurge(FILE*);
 //int vasprintf(char**, const char*, va_list);
 FILE* zopen(const char*, const char*, int);
 
-int vdprintf(int __fd, const char* format, va_list ap);
+int vdprintf(int fd, const char* format, va_list ap);
 int vfprintf(FILE* stream, const char* format, va_list ap);
 int vprintf(const char* format, va_list ap);
 int vsprintf(char* str, const char* format, va_list ap);
diff --git a/libs/libc/stdlib.c2i b/libs/libc/stdlib.c2i
index 755b4cf12..9194fc084 100644
--- a/libs/libc/stdlib.c2i
+++ b/libs/libc/stdlib.c2i
@@ -4,15 +4,17 @@ module stdlib extern "C";
 import string { memset }
 #endif
 
-struct Div_t @(cname="div_t") {
+struct div_t {
     int quot;
     int rem;
 }
 
-struct Ldiv_t @(cname="ldiv_t") {
+struct ldiv_t {
     long quot;
     long rem;
 }
+type Ldiv_t ldiv_t;
+type Div_t div_t;
 
 const int RAND_MAX = 2147483647;      // same as Int32_max
 
@@ -54,91 +56,91 @@ char* l64a(long n);
 long a64l(const char* s);
 
 long random(void);
-void srandom(unsigned int __seed);
-char* initstate(unsigned int __seed, char* __statebuf, size_t __statelen);
-char* setstate(char* __statebuf);
+void srandom(unsigned int seed);
+char* initstate(unsigned int seed, char* statebuf, size_t statelen);
+char* setstate(char* statebuf);
 
 struct Random_data @(opaque, cname="random_data");
 
-int random_r(Random_data* __buf, int* __result);
-int srandom_r(unsigned int __seed, Random_data* __buf);
-int initstate_r(unsigned int __seed, char* __statebuf, size_t __statelen, Random_data* __buf);
-int setstate_r(char* __statebuf, Random_data* __buf);
+int random_r(Random_data* buf, int* result);
+int srandom_r(unsigned int seed, Random_data* buf);
+int initstate_r(unsigned int seed, char* statebuf, size_t statelen, Random_data* buf);
+int setstate_r(char* statebuf, Random_data* buf);
 int rand(void);
-void srand(unsigned int __seed);
-int rand_r(unsigned int* __seed);
+void srand(unsigned int seed);
+int rand_r(unsigned int* seed);
 double drand48(void);
-double erand48(u16* __xsubi);
+double erand48(u16* xsubi);
 long lrand48(void);
-long nrand48(u16* __xsubi);
+long nrand48(u16* xsubi);
 long mrand48(void);
-long jrand48(u16* __xsubi);
-void srand48(long __seedval);
-u16* seed48(u16* __seed16v);
-void lcong48(u16* __param);
+long jrand48(u16* xsubi);
+void srand48(long seedval);
+u16* seed48(u16* seed16v);
+void lcong48(u16* param);
 
 struct Drand48_data @(opaque, cname="drand48_data");
 
-int drand48_r(Drand48_data* __buffer, double* __result);
-int erand48_r(u16* __xsubi, Drand48_data* __buffer, double* __result);
-int lrand48_r(Drand48_data* __buffer, long* __result);
-int nrand48_r(u16* __xsubi, Drand48_data* __buffer, long* __result);
-int mrand48_r(Drand48_data* __buffer, long* __result);
-int jrand48_r(u16* __xsubi, Drand48_data* __buffer, long* __result);
-int srand48_r(long __seedval, Drand48_data* __buffer);
-int seed48_r(u16* __seed16v, Drand48_data* __buffer);
-int lcong48_r(u16* __param, Drand48_data* __buffer);
+int drand48_r(Drand48_data* buffer, double* result);
+int erand48_r(u16* xsubi, Drand48_data* buffer, double* result);
+int lrand48_r(Drand48_data* buffer, long* result);
+int nrand48_r(u16* xsubi, Drand48_data* buffer, long* result);
+int mrand48_r(Drand48_data* buffer, long* result);
+int jrand48_r(u16* xsubi, Drand48_data* buffer, long* result);
+int srand48_r(long seedval, Drand48_data* buffer);
+int seed48_r(u16* seed16v, Drand48_data* buffer);
+int lcong48_r(u16* param, Drand48_data* buffer);
 
-int posix_memalign(void** __memptr, size_t __alignment, size_t __size);
-void* aligned_alloc(int __alignment, size_t __size);
+int posix_memalign(void** memptr, size_t alignment, size_t size);
+void* aligned_alloc(int alignment, size_t size);
 
 void abort(void) @(noreturn);
 int atexit(fn void());
 int at_quick_exit(fn void());
 int on_exit(fn void(i32, void*), void*);
-void exit(int __status) @(noreturn);
-void quick_exit(int __status);
-void _Exit(int __status) @(noreturn);
-
-char* getenv(const char* __name);
-int putenv(char* __string);
-int setenv(const char* __name, const char* __value, int __replace);
-int unsetenv(const char* __name);
+void exit(int status) @(noreturn);
+void quick_exit(int status);
+void _Exit(int status) @(noreturn);
+
+char* getenv(const char* name);
+int putenv(char* string);
+int setenv(const char* name, const char* value, int replace);
+int unsetenv(const char* name);
 int clearenv(void);
 
-int mkstemp(char* __template);
-int mkstemps(char* __template, int __suffixlen);
-char* mkdtemp(char* __template);
-int system(const char* __command);
-char* realpath(const char* __name, char* __resolved);
-char* mktemp(char* __template);
-
-void* bsearch(const void* __key, const void* __base, size_t __nmemb, size_t __size, fn i32(const void*, const void*) __compare);
-void qsort(void* __base, size_t __nmemb, size_t __size, fn i32(const void*, const void*) __compar);
-
-int abs(int __x) @(pure);
-long labs(long __x) @(pure);
-Div_t div(int __numer, int __denom);
-Ldiv_t ldiv(long __numer, long __denom);
-
-char* ecvt(double __value, int __ndigit, int* __decpt, int* __sign);
-char* fcvt(double __value, int __ndigit, int* __decpt, int* __sign);
-char* gcvt(double __value, int __ndigit, char* __buf);
-char* qecvt(double __value, int __ndigit, int* __decpt, int* __sign);
-char* qfcvt(double __value, int __ndigit, int* __decpt, int* __sign);
-char* qgcvt(double __value, int __ndigit, char* __buf);
-int ecvt_r(double __value, int __ndigit, int* __decpt, int* __sign, char* __buf, size_t __len);
-int fcvt_r(double __value, int __ndigit, int* __decpt, int* __sign, char* __buf, size_t __len);
-int qecvt_r(double __value, int __ndigit, int* __decpt, int* __sign, char* __buf, size_t __len);
-int qfcvt_r(double __value, int __ndigit, int* __decpt, int* __sign, char* __buf, size_t __len);
-
-int mblen(const char* __s, size_t __n);
-int mbtowc(int* __pwc, const char* __s, size_t __n);
+int mkstemp(char* tpl);
+int mkstemps(char* tpl, int suffixlen);
+char* mkdtemp(char* tpl);
+int system(const char* command);
+char* realpath(const char* name, char* resolved);
+char* mktemp(char* tpl);
+
+void* bsearch(const void* key, const void* base, size_t nmemb, size_t size, fn i32(const void*, const void*) compare);
+void qsort(void* base, size_t nmemb, size_t size, fn i32(const void*, const void*) compar);
+
+int abs(int x) @(pure);
+long labs(long x) @(pure);
+div_t div(int numer, int denom);
+ldiv_t ldiv(long numer, long denom);
+
+char* ecvt(double value, int ndigit, int* decpt, int* sign);
+char* fcvt(double value, int ndigit, int* decpt, int* sign);
+char* gcvt(double value, int ndigit, char* buf);
+char* qecvt(double value, int ndigit, int* decpt, int* sign);
+char* qfcvt(double value, int ndigit, int* decpt, int* sign);
+char* qgcvt(double value, int ndigit, char* buf);
+int ecvt_r(double value, int ndigit, int* decpt, int* sign, char* buf, size_t len);
+int fcvt_r(double value, int ndigit, int* decpt, int* sign, char* buf, size_t len);
+int qecvt_r(double value, int ndigit, int* decpt, int* sign, char* buf, size_t len);
+int qfcvt_r(double value, int ndigit, int* decpt, int* sign, char* buf, size_t len);
+
+int mblen(const char* s, size_t n);
+int mbtowc(int* pwc, const char* s, size_t n);
 // needs wchar_t
-//fn int wctomb(char* __s, int __wchar);
-int mbstowcs(int* __pwcs, const char* __s, size_t __n);
-int wcstombs(char* __s, const int* __pwcs, size_t __n);
-int rpmatch(const char* __response);
-int getsubopt(char** __optionp, char* const* __tokens, char** __valuep);
-int getloadavg(double* __loadavg, int __nelem);
+//int wctomb(char* s, int wchar);
+int mbstowcs(int* pwcs, const char* s, size_t n);
+int wcstombs(char* s, const int* pwcs, size_t n);
+int rpmatch(const char* response);
+int getsubopt(char** optionp, char* const* tokens, char** valuep);
+int getloadavg(double* loadavg, int nelem);
 
diff --git a/libs/libc/sys_mman.c2i b/libs/libc/sys_mman.c2i
index cf79815d5..a97365c81 100644
--- a/libs/libc/sys_mman.c2i
+++ b/libs/libc/sys_mman.c2i
@@ -1,8 +1,9 @@
 module sys_mman extern "C";
 
-typedef i64 Offset @(cname="off_t");
+typedef long long off_t;
+type Offset off_t;
 
-void* mmap(void* addr, size_t length, int prot, int flags, int fd, Offset offset);
+void* mmap(void* addr, size_t length, int prot, int flags, int fd, off_t offset);
 int munmap(void* addr, size_t length);
 
 const u32 PROT_NONE  = 0x0;
diff --git a/libs/libc/sys_sendfile.c2i b/libs/libc/sys_sendfile.c2i
index 14bbf2d9c..a48f30924 100644
--- a/libs/libc/sys_sendfile.c2i
+++ b/libs/libc/sys_sendfile.c2i
@@ -1,6 +1,7 @@
 module sys_sendfile extern "C";
 
-typedef i64 Offset @(cname="off_t");
+typedef i64 off_t;
+type Offset off_t;
 
-ssize_t sendfile(int __out_fd, int __in_fd, Offset* __offset, size_t __count);
+ssize_t sendfile(int out_fd, int in_fd, off_t* offset, size_t count);
 
diff --git a/libs/libc/sys_signalfd.c2i b/libs/libc/sys_signalfd.c2i
index 5130ff3bc..d5e3bbeca 100644
--- a/libs/libc/sys_signalfd.c2i
+++ b/libs/libc/sys_signalfd.c2i
@@ -27,5 +27,5 @@ struct Siginfo {
   u8[28] __pad;
 }
 
-int signalfd(int __fd, const Sigset* mask, int flags) @(cname="signalfd");
+int signalfd(int fd, const Sigset* mask, int flags);
 
diff --git a/libs/libc/sys_time.c2i b/libs/libc/sys_time.c2i
index 237619bfd..67c9f6523 100644
--- a/libs/libc/sys_time.c2i
+++ b/libs/libc/sys_time.c2i
@@ -1,17 +1,19 @@
 module sys_time extern "C";
 
 #if SYSTEM_DARWIN
-typedef long Time @(cname="time_t");
-typedef int SuSeconds @(cname="suseconds_t");
+typedef long time_t;
+typedef int suseconds_t;
 #else
 // Same for Linux, FreeBSD and OpenBSD
-typedef long Time @(cname="time_t");
-typedef long SuSeconds @(cname="suseconds_t");
+typedef long time_t;
+typedef long suseconds_t;
 #endif
+type Time time_t;
+type SuSeconds suseconds_t;
 
 struct Timeval @(cname="timeval") {
-    Time tv_sec;
-    SuSeconds tv_usec;
+    time_t tv_sec;
+    suseconds_t tv_usec;
 }
 static_assert(16, sizeof(Timeval));
 
diff --git a/libs/libc/unistd.c2i b/libs/libc/unistd.c2i
index 8e96dc887..e0aa98f78 100644
--- a/libs/libc/unistd.c2i
+++ b/libs/libc/unistd.c2i
@@ -14,6 +14,9 @@ typedef int pid_t;
 typedef unsigned uid_t;
 typedef unsigned useconds_t;
 
+type Offset off_t;
+type Pid pid_t;
+
 /* POSIX.1-1990 */
 
 void _exit(int) @(noreturn);
@@ -206,10 +209,9 @@ int pipe2(int* pipefd, int flags) {
 
 #endif
 
-typedef int Pid @(cname="pid_t");
-Pid wait(int* wstatus);
-Pid waitpid(Pid pid, int* wstatus, int options);
-int kill(Pid pid, int sig);
+pid_t wait(int* wstatus);
+pid_t waitpid(pid_t pid, int* wstatus, int options);
+int kill(pid_t pid, int sig);
 
 #if SYSTEM_LINUX
 // sysconf names per IEEE Std 1003.1, 2008 Edition, values for Linux
diff --git a/test/c_generator/attributes/noreturn.c2t b/test/c_generator/attributes/noreturn.c2t
index 74ee15f82..286d82107 100644
--- a/test/c_generator/attributes/noreturn.c2t
+++ b/test/c_generator/attributes/noreturn.c2t
@@ -23,7 +23,7 @@ public fn i32 main() {
 // @expect{atleast, cgen/build.c}
 
 __attribute__((noreturn))
-void exit(int __status);
+void exit(int status);
 
 // --- module file1 ---
 __attribute__((noreturn))