Changeset 7f1c620 in mainline for generic/src

Timestamp:

2006-07-04T17:17:56Z (19 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

0ffa3ef5

Parents:

991779c5

Message:

Replace old u?? types with respective C99 variants (e.g. uint32_t, int64_t, uintptr_t etc.).

Location:

generic/src

Files:

• adt/bitmap.c (modified) (1 diff)
• adt/hash_table.c (modified) (4 diffs)
• console/chardev.c (modified) (1 diff)
• console/cmd.c (modified) (12 diffs)
• console/console.c (modified) (2 diffs)
• console/kconsole.c (modified) (4 diffs)
• console/klog.c (modified) (1 diff)
• cpu/cpu.c (modified) (1 diff)
• ddi/ddi.c (modified) (6 diffs)
• debug/symtab.c (modified) (6 diffs)
• interrupt/interrupt.c (modified) (1 diff)
• ipc/ipc.c (modified) (3 diffs)
• ipc/ipcrsc.c (modified) (2 diffs)
• ipc/irq.c (modified) (3 diffs)
• ipc/sysipc.c (modified) (23 diffs)
• lib/elf.c (modified) (2 diffs)
• lib/func.c (modified) (2 diffs)
• lib/memstr.c (modified) (3 diffs)
• lib/sort.c (modified) (3 diffs)
• main/main.c (modified) (5 diffs)
• mm/as.c (modified) (26 diffs)
• mm/backend_anon.c (modified) (7 diffs)
• mm/backend_elf.c (modified) (10 diffs)
• mm/backend_phys.c (modified) (2 diffs)
• mm/buddy.c (modified) (5 diffs)
• mm/frame.c (modified) (19 diffs)
• mm/page.c (modified) (4 diffs)
• mm/slab.c (modified) (4 diffs)
• mm/tlb.c (modified) (2 diffs)
• printf/printf_core.c (modified) (10 diffs)
• proc/scheduler.c (modified) (1 diff)
• proc/task.c (modified) (2 diffs)
• proc/thread.c (modified) (13 diffs)
• security/cap.c (modified) (7 diffs)
• synch/condvar.c (modified) (1 diff)
• synch/futex.c (modified) (10 diffs)
• synch/mutex.c (modified) (1 diff)
• synch/rwlock.c (modified) (2 diffs)
• synch/semaphore.c (modified) (1 diff)
• synch/spinlock.c (modified) (1 diff)
• synch/waitq.c (modified) (3 diffs)
• syscall/copy.c (modified) (2 diffs)
• syscall/syscall.c (modified) (3 diffs)
• sysinfo/sysinfo.c (modified) (4 diffs)
• time/clock.c (modified) (4 diffs)
• time/delay.c (modified) (1 diff)
• time/timeout.c (modified) (1 diff)

generic/src/adt/bitmap.c

@@ -56 +56 @@
  * @param bits Number of bits stored in bitmap.
  */
-void bitmap_initialize(bitmap_t *bitmap, __u8 *map, count_t bits)
+void bitmap_initialize(bitmap_t *bitmap, uint8_t *map, count_t bits)
 {
         bitmap->map = map;

generic/src/adt/hash_table.c

@@ -65 +65 @@
                 panic("cannot allocate memory for hash table\n");
         }
-        memsetb((__address) h->entry, m * sizeof(link_t), 0);
+        memsetb((uintptr_t) h->entry, m * sizeof(link_t), 0);
         
         for (i = 0; i < m; i++)
@@ -81 +81 @@
  * @param item Item to be inserted into the hash table.
  */
-void hash_table_insert(hash_table_t *h, __native key[], link_t *item)
+void hash_table_insert(hash_table_t *h, unative_t key[], link_t *item)
 {
         index_t chain;
@@ -101 +101 @@
  * @return Matching item on success, NULL if there is no such item.
  */
-link_t *hash_table_find(hash_table_t *h, __native key[])
+link_t *hash_table_find(hash_table_t *h, unative_t key[])
 {
         link_t *cur;
@@ -131 +131 @@
  * @param keys Number of keys in the key array.
  */
-void hash_table_remove(hash_table_t *h, __native key[], count_t keys)
+void hash_table_remove(hash_table_t *h, unative_t key[], count_t keys)
 {
         index_t chain;

generic/src/console/chardev.c

@@ -60 +60 @@
  * @param ch Character being pushed.
  */
-void chardev_push_character(chardev_t *chardev, __u8 ch)
+void chardev_push_character(chardev_t *chardev, uint8_t ch)
 {
         spinlock_lock(&chardev->lock);

generic/src/console/cmd.c

@@ -480 +480 @@
 int cmd_call0(cmd_arg_t *argv)
 {
-        __address symaddr;
+        uintptr_t symaddr;
         char *symbol;
-        __native (*f)(void);
+        unative_t (*f)(void);
 #ifdef ia64
         struct {
-                __native f;
-                __native gp;
+                unative_t f;
+                unative_t gp;
         }fptr;
 #endif
@@ -493 +493 @@
         if (!symaddr)
                 printf("Symbol %s not found.\n", argv->buffer);
-        else if (symaddr == (__address) -1) {
+        else if (symaddr == (uintptr_t) -1) {
                 symtab_print_search(argv->buffer);
                 printf("Duplicate symbol, be more specific.\n");
         } else {
                 symbol = get_symtab_entry(symaddr);
-                printf("Calling f(): %.*p: %s\n", sizeof(__address) * 2, symaddr, symbol);
+                printf("Calling f(): %.*p: %s\n", sizeof(uintptr_t) * 2, symaddr, symbol);
 #ifdef ia64
                 fptr.f = symaddr;
-                fptr.gp = ((__native *)cmd_call2)[1];
-                f =  (__native (*)(void)) &fptr;
+                fptr.gp = ((unative_t *)cmd_call2)[1];
+                f =  (unative_t (*)(void)) &fptr;
 #else
-                f =  (__native (*)(void)) symaddr;
+                f =  (unative_t (*)(void)) symaddr;
 #endif
                 printf("Result: %#zx\n", f());
@@ -515 +515 @@
 int cmd_call1(cmd_arg_t *argv)
 {
-        __address symaddr;
+        uintptr_t symaddr;
         char *symbol;
-        __native (*f)(__native,...);
-        __native arg1 = argv[1].intval;
+        unative_t (*f)(unative_t,...);
+        unative_t arg1 = argv[1].intval;
 #ifdef ia64
         struct {
-                __native f;
-                __native gp;
+                unative_t f;
+                unative_t gp;
         }fptr;
 #endif
@@ -529 +529 @@
         if (!symaddr)
                 printf("Symbol %s not found.\n", argv->buffer);
-        else if (symaddr == (__address) -1) {
+        else if (symaddr == (uintptr_t) -1) {
                 symtab_print_search(argv->buffer);
                 printf("Duplicate symbol, be more specific.\n");
@@ -535 +535 @@
                 symbol = get_symtab_entry(symaddr);
 
-                printf("Calling f(%#zx): %.*p: %s\n", arg1, sizeof(__address) * 2, symaddr, symbol);
+                printf("Calling f(%#zx): %.*p: %s\n", arg1, sizeof(uintptr_t) * 2, symaddr, symbol);
 #ifdef ia64
                 fptr.f = symaddr;
-                fptr.gp = ((__native *)cmd_call2)[1];
-                f =  (__native (*)(__native,...)) &fptr;
+                fptr.gp = ((unative_t *)cmd_call2)[1];
+                f =  (unative_t (*)(unative_t,...)) &fptr;
 #else
-                f =  (__native (*)(__native,...)) symaddr;
+                f =  (unative_t (*)(unative_t,...)) symaddr;
 #endif
                 printf("Result: %#zx\n", f(arg1));
@@ -552 +552 @@
 int cmd_call2(cmd_arg_t *argv)
 {
-        __address symaddr;
+        uintptr_t symaddr;
         char *symbol;
-        __native (*f)(__native,__native,...);
-        __native arg1 = argv[1].intval;
-        __native arg2 = argv[2].intval;
+        unative_t (*f)(unative_t,unative_t,...);
+        unative_t arg1 = argv[1].intval;
+        unative_t arg2 = argv[2].intval;
 #ifdef ia64
         struct {
-                __native f;
-                __native gp;
+                unative_t f;
+                unative_t gp;
         }fptr;
 #endif
@@ -567 +567 @@
         if (!symaddr)
                 printf("Symbol %s not found.\n", argv->buffer);
-        else if (symaddr == (__address) -1) {
+        else if (symaddr == (uintptr_t) -1) {
                 symtab_print_search(argv->buffer);
                 printf("Duplicate symbol, be more specific.\n");
@@ -573 +573 @@
                 symbol = get_symtab_entry(symaddr);
                 printf("Calling f(0x%zx,0x%zx): %.*p: %s\n", 
-                       arg1, arg2, sizeof(__address) * 2, symaddr, symbol);
+                       arg1, arg2, sizeof(uintptr_t) * 2, symaddr, symbol);
 #ifdef ia64
                 fptr.f = symaddr;
-                fptr.gp = ((__native *)cmd_call2)[1];
-                f =  (__native (*)(__native,__native,...)) &fptr;
+                fptr.gp = ((unative_t *)cmd_call2)[1];
+                f =  (unative_t (*)(unative_t,unative_t,...)) &fptr;
 #else
-                f =  (__native (*)(__native,__native,...)) symaddr;
+                f =  (unative_t (*)(unative_t,unative_t,...)) symaddr;
 #endif
                 printf("Result: %#zx\n", f(arg1, arg2));
@@ -590 +590 @@
 int cmd_call3(cmd_arg_t *argv)
 {
-        __address symaddr;
+        uintptr_t symaddr;
         char *symbol;
-        __native (*f)(__native,__native,__native,...);
-        __native arg1 = argv[1].intval;
-        __native arg2 = argv[2].intval;
-        __native arg3 = argv[3].intval;
+        unative_t (*f)(unative_t,unative_t,unative_t,...);
+        unative_t arg1 = argv[1].intval;
+        unative_t arg2 = argv[2].intval;
+        unative_t arg3 = argv[3].intval;
 #ifdef ia64
         struct {
-                __native f;
-                __native gp;
+                unative_t f;
+                unative_t gp;
         }fptr;
 #endif
@@ -606 +606 @@
         if (!symaddr)
                 printf("Symbol %s not found.\n", argv->buffer);
-        else if (symaddr == (__address) -1) {
+        else if (symaddr == (uintptr_t) -1) {
                 symtab_print_search(argv->buffer);
                 printf("Duplicate symbol, be more specific.\n");
@@ -612 +612 @@
                 symbol = get_symtab_entry(symaddr);
                 printf("Calling f(0x%zx,0x%zx, 0x%zx): %.*p: %s\n", 
-                       arg1, arg2, arg3, sizeof(__address) * 2, symaddr, symbol);
+                       arg1, arg2, arg3, sizeof(uintptr_t) * 2, symaddr, symbol);
 #ifdef ia64
                 fptr.f = symaddr;
-                fptr.gp = ((__native *)cmd_call2)[1];
-                f =  (__native (*)(__native,__native,__native,...)) &fptr;
+                fptr.gp = ((unative_t *)cmd_call2)[1];
+                f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) &fptr;
 #else
-                f =  (__native (*)(__native,__native,__native,...)) symaddr;
+                f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) symaddr;
 #endif
                 printf("Result: %#zx\n", f(arg1, arg2, arg3));
@@ -660 +660 @@
 int cmd_set4(cmd_arg_t *argv)
 {
-        __u32 *addr ;
-        __u32 arg1 = argv[1].intval;
+        uint32_t *addr ;
+        uint32_t arg1 = argv[1].intval;
         bool pointer = false;
 
         if (((char *)argv->buffer)[0] == '*') {
-                addr = (__u32 *) get_symbol_addr(argv->buffer+1);
+                addr = (uint32_t *) get_symbol_addr(argv->buffer+1);
                 pointer = true;
         } else if (((char *)argv->buffer)[0] >= '0' && 
                    ((char *)argv->buffer)[0] <= '9')
-                addr = (__u32 *)atoi((char *)argv->buffer);
+                addr = (uint32_t *)atoi((char *)argv->buffer);
         else
-                addr = (__u32 *)get_symbol_addr(argv->buffer);
+                addr = (uint32_t *)get_symbol_addr(argv->buffer);
 
         if (!addr)
                 printf("Symbol %s not found.\n", argv->buffer);
-        else if (addr == (__u32 *) -1) {
+        else if (addr == (uint32_t *) -1) {
                 symtab_print_search(argv->buffer);
                 printf("Duplicate symbol, be more specific.\n");
         } else {
                 if (pointer)
-                        addr = (__u32 *)(*(__native *)addr);
-                printf("Writing 0x%x -> %.*p\n", arg1, sizeof(__address) * 2, addr);
+                        addr = (uint32_t *)(*(unative_t *)addr);
+                printf("Writing 0x%x -> %.*p\n", arg1, sizeof(uintptr_t) * 2, addr);
                 *addr = arg1;
                 

generic/src/console/console.c

@@ -77 +77 @@
  * @return Character read.
  */
-__u8 _getc(chardev_t *chardev)
+uint8_t _getc(chardev_t *chardev)
 {
-        __u8 ch;
+        uint8_t ch;
         ipl_t ipl;
 
@@ -151 +151 @@
 
 /** Get character from device & echo it to screen */
-__u8 getc(chardev_t *chardev)
+uint8_t getc(chardev_t *chardev)
 {
-        __u8 ch;
+        uint8_t ch;
 
         ch = _getc(chardev);

generic/src/console/kconsole.c

@@ -432 +432 @@
 }
 
-static int parse_int_arg(char *text, size_t len, __native *result)
+static int parse_int_arg(char *text, size_t len, unative_t *result)
 {
         char symname[MAX_SYMBOL_NAME];
-        __address symaddr;
+        uintptr_t symaddr;
         bool isaddr = false;
         bool isptr = false;
@@ -454 +454 @@
                         return -1;
                 }
-                if (symaddr == (__address) -1) {
+                if (symaddr == (uintptr_t) -1) {
                         printf("Duplicate symbol %s.\n",symname);
                         symtab_print_search(symname);
@@ -460 +460 @@
                 }
                 if (isaddr)
-                        *result = (__native)symaddr;
+                        *result = (unative_t)symaddr;
                 else if (isptr)
-                        *result = **((__native **)symaddr);
+                        *result = **((unative_t **)symaddr);
                 else
-                        *result = *((__native *)symaddr);
+                        *result = *((unative_t *)symaddr);
         } else { /* It's a number - convert it */
                 *result = atoi(text);
                 if (isptr)
-                        *result = *((__native *)*result);
+                        *result = *((unative_t *)*result);
         }
 
@@ -555 +555 @@
                                         min((end-start), cmd->argv[i].len));
                                 buf[min((end - start), cmd->argv[i].len - 1)] = '\0';
-                                cmd->argv[i].intval = (__native) buf;
+                                cmd->argv[i].intval = (unative_t) buf;
                                 cmd->argv[i].vartype = ARG_TYPE_STRING;
                         } else if (!parse_int_arg(cmdline+start, end-start+1, 

generic/src/console/klog.c

@@ -64 +64 @@
         klog = (char *)PA2KA(faddr);
         
-        sysinfo_set_item_val("klog.faddr", NULL, (__native)faddr);
+        sysinfo_set_item_val("klog.faddr", NULL, (unative_t)faddr);
         sysinfo_set_item_val("klog.pages", NULL, 1 << KLOG_ORDER);
 

generic/src/cpu/cpu.c

@@ -69 +69 @@
 
                 /* initialize everything */
-                memsetb((__address) cpus, sizeof(cpu_t) * config.cpu_count, 0);
+                memsetb((uintptr_t) cpus, sizeof(cpu_t) * config.cpu_count, 0);
 
                 for (i=0; i < config.cpu_count; i++) {
-                        cpus[i].stack = (__u8 *) frame_alloc(STACK_FRAMES, FRAME_KA | FRAME_ATOMIC);
+                        cpus[i].stack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | FRAME_ATOMIC);
                         
                         cpus[i].id = i;

generic/src/ddi/ddi.c

@@ -63 +63 @@
  *         there was a problem in creating address space area.
  */
-static int ddi_physmem_map(__address pf, __address vp, count_t pages, int flags)
+static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, count_t pages, int flags)
 {
         ipl_t ipl;
@@ -111 +111 @@
  *         ENOENT if there is no task matching the specified ID.
  */
-static int ddi_iospace_enable(task_id_t id, __address ioaddr, size_t size)
+static int ddi_iospace_enable(task_id_t id, uintptr_t ioaddr, size_t size)
 {
         ipl_t ipl;
@@ -159 +159 @@
  * @return 0 on success, otherwise it returns error code found in errno.h
  */ 
-__native sys_physmem_map(__native phys_base, __native virt_base, __native pages, 
-                         __native flags)
-{
-        return (__native) ddi_physmem_map(ALIGN_DOWN((__address) phys_base, FRAME_SIZE),
-                                          ALIGN_DOWN((__address) virt_base, PAGE_SIZE), (count_t) pages,
+unative_t sys_physmem_map(unative_t phys_base, unative_t virt_base, unative_t pages, 
+                         unative_t flags)
+{
+        return (unative_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base, FRAME_SIZE),
+                                          ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE), (count_t) pages,
                                           (int) flags);
 }
@@ -173 +173 @@
  * @return 0 on success, otherwise it returns error code found in errno.h
  */ 
-__native sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
+unative_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
 {
         ddi_ioarg_t arg;
@@ -180 +180 @@
         rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
         if (rc != 0)
-                return (__native) rc;
+                return (unative_t) rc;
                 
-        return (__native) ddi_iospace_enable((task_id_t) arg.task_id, (__address) arg.ioaddr, (size_t) arg.size);
+        return (unative_t) ddi_iospace_enable((task_id_t) arg.task_id, (uintptr_t) arg.ioaddr, (size_t) arg.size);
 }
 
@@ -193 +193 @@
  * @return Zero on success or EPERM if callers capabilities are not sufficient.
  */ 
-__native sys_preempt_control(int enable)
+unative_t sys_preempt_control(int enable)
 {
         if (! cap_get(TASK) & CAP_PREEMPT_CONTROL)

generic/src/debug/symtab.c

@@ -51 +51 @@
  * @return Pointer to respective symbol string on success, NULL otherwise.
  */
-char * get_symtab_entry(__native addr)
+char * get_symtab_entry(unative_t addr)
 {
         count_t i;
 
         for (i=1;symbol_table[i].address_le;++i) {
-                if (addr < __u64_le2host(symbol_table[i].address_le))
+                if (addr < uint64_t_le2host(symbol_table[i].address_le))
                         break;
         }
-        if (addr >= __u64_le2host(symbol_table[i-1].address_le))
+        if (addr >= uint64_t_le2host(symbol_table[i-1].address_le))
                 return symbol_table[i-1].symbol_name;
         return NULL;
@@ -109 +109 @@
  * @return 0 - Not found, -1 - Duplicate symbol, other - address of symbol
  */
-__address get_symbol_addr(const char *name)
+uintptr_t get_symbol_addr(const char *name)
 {
         count_t found = 0;
-        __address addr = NULL;
+        uintptr_t addr = NULL;
         char *hint;
         int i;
@@ -119 +119 @@
         while ((hint=symtab_search_one(name, &i))) {
                 if (!strlen(hint)) {
-                        addr =  __u64_le2host(symbol_table[i].address_le);
+                        addr =  uint64_t_le2host(symbol_table[i].address_le);
                         found++;
                 }
@@ -125 +125 @@
         }
         if (found > 1)
-                return ((__address) -1);
+                return ((uintptr_t) -1);
         return addr;
 }
@@ -133 +133 @@
 {
         int i;
-        __address addr;
+        uintptr_t addr;
         char *realname;
 
@@ -139 +139 @@
         i = 0;
         while (symtab_search_one(name, &i)) {
-                addr =  __u64_le2host(symbol_table[i].address_le);
+                addr =  uint64_t_le2host(symbol_table[i].address_le);
                 realname = symbol_table[i].symbol_name;
-                printf("%.*p: %s\n", sizeof(__address) * 2, addr, realname);
+                printf("%.*p: %s\n", sizeof(uintptr_t) * 2, addr, realname);
                 i++;
         }

generic/src/interrupt/interrupt.c

@@ -110 +110 @@
         printf("Exc Description Handler\n");
         for (i=0; i < IVT_ITEMS; i++) {
-                symbol = get_symtab_entry((__native)exc_table[i].f);
+                symbol = get_symtab_entry((unative_t)exc_table[i].f);
                 if (!symbol)
                         symbol = "not found";
                 printf("%d %s %.*p(%s)\n", i + IVT_FIRST, exc_table[i].name,
-                       sizeof(__address) * 2, exc_table[i].f,symbol);           
+                       sizeof(uintptr_t) * 2, exc_table[i].f,symbol);           
                 if (!((i+1) % 20)) {
                         printf("Press any key to continue.");

generic/src/ipc/ipc.c

@@ -62 +62 @@
 static void _ipc_call_init(call_t *call)
 {
-        memsetb((__address)call, sizeof(*call), 0);
+        memsetb((uintptr_t)call, sizeof(*call), 0);
         call->callerbox = &TASK->answerbox;
         call->sender = TASK;
@@ -186 +186 @@
  * message and sending it as a normal answer.
  */
-void ipc_backsend_err(phone_t *phone, call_t *call, __native err)
+void ipc_backsend_err(phone_t *phone, call_t *call, unative_t err)
 {
         call->data.phone = phone;
@@ -309 +309 @@
  * - to distinguish between call and answer, look at call->flags
  */
-call_t * ipc_wait_for_call(answerbox_t *box, __u32 usec, int flags)
+call_t * ipc_wait_for_call(answerbox_t *box, uint32_t usec, int flags)
 {
         call_t *request;

generic/src/ipc/ipcrsc.c

@@ -139 +139 @@
  * @return NULL on not found, otherwise pointer to call structure
  */
-call_t * get_call(__native callid)
+call_t * get_call(unative_t callid)
 {
         link_t *lst;
@@ -148 +148 @@
              lst != &TASK->answerbox.dispatched_calls; lst = lst->next) {
                 call = list_get_instance(lst, call_t, link);
-                if ((__native)call == callid) {
+                if ((unative_t)call == callid) {
                         result = call;
                         break;

generic/src/ipc/irq.c

@@ -73 +73 @@
 {
         int i;
-        __native dstval = 0;
+        unative_t dstval = 0;
         
         if (!code)
@@ -81 +81 @@
                 switch (code->cmds[i].cmd) {
                 case CMD_MEM_READ_1:
-                        dstval = *((__u8 *)code->cmds[i].addr);
+                        dstval = *((uint8_t *)code->cmds[i].addr);
                         break;
                 case CMD_MEM_READ_2:
-                        dstval = *((__u16 *)code->cmds[i].addr);
+                        dstval = *((uint16_t *)code->cmds[i].addr);
                         break;
                 case CMD_MEM_READ_4:
-                        dstval = *((__u32 *)code->cmds[i].addr);
+                        dstval = *((uint32_t *)code->cmds[i].addr);
                         break;
                 case CMD_MEM_READ_8:
-                        dstval = *((__u64 *)code->cmds[i].addr);
+                        dstval = *((uint64_t *)code->cmds[i].addr);
                         break;
                 case CMD_MEM_WRITE_1:
-                        *((__u8 *)code->cmds[i].addr) = code->cmds[i].value;
+                        *((uint8_t *)code->cmds[i].addr) = code->cmds[i].value;
                         break;
                 case CMD_MEM_WRITE_2:
-                        *((__u16 *)code->cmds[i].addr) = code->cmds[i].value;
+                        *((uint16_t *)code->cmds[i].addr) = code->cmds[i].value;
                         break;
                 case CMD_MEM_WRITE_4:
-                        *((__u32 *)code->cmds[i].addr) = code->cmds[i].value;
+                        *((uint32_t *)code->cmds[i].addr) = code->cmds[i].value;
                         break;
                 case CMD_MEM_WRITE_8:
-                        *((__u64 *)code->cmds[i].addr) = code->cmds[i].value;
+                        *((uint64_t *)code->cmds[i].addr) = code->cmds[i].value;
                         break;
 #if defined(ia32) || defined(amd64)
@@ -235 +235 @@
  *
  */
-void ipc_irq_send_msg(int irq, __native a1, __native a2, __native a3)
+void ipc_irq_send_msg(int irq, unative_t a1, unative_t a2, unative_t a3)
 {
         call_t *call;

generic/src/ipc/sysipc.c

@@ -57 +57 @@
 
 /** Return true if the method is a system method */
-static inline int is_system_method(__native method)
+static inline int is_system_method(unative_t method)
 {
         if (method <= IPC_M_LAST_SYSTEM)
@@ -69 +69 @@
  *   it is useless
  */
-static inline int is_forwardable(__native method)
+static inline int is_forwardable(unative_t method)
 {
         if (method == IPC_M_PHONE_HUNGUP || method == IPC_M_AS_AREA_SEND \
@@ -132 +132 @@
                         phone_connect(phoneid,&answer->sender->answerbox);
                         /* Set 'phone identification' as arg3 of response */
-                        IPC_SET_ARG3(answer->data, (__native)&TASK->phones[phoneid]);
+                        IPC_SET_ARG3(answer->data, (unative_t)&TASK->phones[phoneid]);
                 }
         } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
@@ -192 +192 @@
                         return ELIMIT;
                 /* Set arg3 for server */
-                IPC_SET_ARG3(call->data, (__native)&TASK->phones[newphid]);
+                IPC_SET_ARG3(call->data, (unative_t)&TASK->phones[newphid]);
                 call->flags |= IPC_CALL_CONN_ME_TO;
                 call->private = newphid;
@@ -254 +254 @@
            -2 on 'Too many async request, handle answers first
  */
-__native sys_ipc_call_sync_fast(__native phoneid, __native method, 
-                                __native arg1, ipc_data_t *data)
+unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method, 
+                                unative_t arg1, ipc_data_t *data)
 {
         call_t call;
@@ -278 +278 @@
 
 /** Synchronous IPC call allowing to send whole message */
-__native sys_ipc_call_sync(__native phoneid, ipc_data_t *question, 
+unative_t sys_ipc_call_sync(unative_t phoneid, ipc_data_t *question, 
                            ipc_data_t *reply)
 {
@@ -289 +289 @@
         rc = copy_from_uspace(&call.data.args, &question->args, sizeof(call.data.args));
         if (rc != 0)
-                return (__native) rc;
+                return (unative_t) rc;
 
         GET_CHECK_PHONE(phone, phoneid, return ENOENT);
@@ -324 +324 @@
            -2 on 'Too many async request, handle answers first
  */
-__native sys_ipc_call_async_fast(__native phoneid, __native method, 
-                                 __native arg1, __native arg2)
+unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method, 
+                                 unative_t arg1, unative_t arg2)
 {
         call_t *call;
@@ -347 +347 @@
                 ipc_backsend_err(phone, call, res);
 
-        return (__native) call;
+        return (unative_t) call;
 }
 
@@ -354 +354 @@
  * @return The same as sys_ipc_call_async
  */
-__native sys_ipc_call_async(__native phoneid, ipc_data_t *data)
+unative_t sys_ipc_call_async(unative_t phoneid, ipc_data_t *data)
 {
         call_t *call;
@@ -370 +370 @@
         if (rc != 0) {
                 ipc_call_free(call);
-                return (__native) rc;
+                return (unative_t) rc;
         }
         if (!(res=request_preprocess(call)))
@@ -377 +377 @@
                 ipc_backsend_err(phone, call, res);
 
-        return (__native) call;
+        return (unative_t) call;
 }
 
@@ -387 +387 @@
  *          arg3 is not rewritten for certain system IPC
  */
-__native sys_ipc_forward_fast(__native callid, __native phoneid,
-                              __native method, __native arg1)
+unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
+                              unative_t method, unative_t arg1)
 {
         call_t *call;
@@ -429 +429 @@
 
 /** Send IPC answer */
-__native sys_ipc_answer_fast(__native callid, __native retval, 
-                             __native arg1, __native arg2)
+unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval, 
+                             unative_t arg1, unative_t arg2)
 {
         call_t *call;
@@ -460 +460 @@
 
 /** Send IPC answer */
-__native sys_ipc_answer(__native callid, ipc_data_t *data)
+unative_t sys_ipc_answer(unative_t callid, ipc_data_t *data)
 {
         call_t *call;
@@ -494 +494 @@
  *
  */
-__native sys_ipc_hangup(int phoneid)
+unative_t sys_ipc_hangup(int phoneid)
 {
         phone_t *phone;
@@ -514 +514 @@
  * @return Callid, if callid & 1, then the call is answer
  */
-__native sys_ipc_wait_for_call(ipc_data_t *calldata, __u32 usec, int flags)
+unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, int flags)
 {
         call_t *call;
@@ -533 +533 @@
                 ipc_call_free(call);
                 
-                return ((__native)call) | IPC_CALLID_NOTIFICATION;
+                return ((unative_t)call) | IPC_CALLID_NOTIFICATION;
         }
 
@@ -551 +551 @@
                 ipc_call_free(call);
 
-                return ((__native)call) | IPC_CALLID_ANSWERED;
+                return ((unative_t)call) | IPC_CALLID_ANSWERED;
         }
 
@@ -562 +562 @@
                 return 0;
         }
-        return (__native)call;
+        return (unative_t)call;
 }
 
 /** Connect irq handler to task */
-__native sys_ipc_register_irq(int irq, irq_code_t *ucode)
+unative_t sys_ipc_register_irq(int irq, irq_code_t *ucode)
 {
         if (!(cap_get(TASK) & CAP_IRQ_REG))
@@ -572 +572 @@
 
         if (irq >= IRQ_COUNT || irq <= -IPC_IRQ_RESERVED_VIRTUAL)
-                return (__native) ELIMIT;
+                return (unative_t) ELIMIT;
         
         irq_ipc_bind_arch(irq);
@@ -580 +580 @@
 
 /* Disconnect irq handler from task */
-__native sys_ipc_unregister_irq(int irq)
+unative_t sys_ipc_unregister_irq(int irq)
 {
         if (!(cap_get(TASK) & CAP_IRQ_REG))
@@ -586 +586 @@
 
         if (irq >= IRQ_COUNT || irq <= -IPC_IRQ_RESERVED_VIRTUAL)
-                return (__native) ELIMIT;
+                return (unative_t) ELIMIT;
 
         ipc_irq_unregister(&TASK->answerbox, irq);

generic/src/lib/elf.c

@@ -97 +97 @@
         /* Walk through all segment headers and process them. */
         for (i = 0; i < header->e_phnum; i++) {
-                rc = segment_header(&((elf_segment_header_t *)(((__u8 *) header) + header->e_phoff))[i], header, as);
+                rc = segment_header(&((elf_segment_header_t *)(((uint8_t *) header) + header->e_phoff))[i], header, as);
                 if (rc != EE_OK)
                         return rc;
@@ -104 +104 @@
         /* Inspect all section headers and proccess them. */
         for (i = 0; i < header->e_shnum; i++) {
-                rc = section_header(&((elf_section_header_t *)(((__u8 *) header) + header->e_shoff))[i], header, as);
+                rc = section_header(&((elf_section_header_t *)(((uint8_t *) header) + header->e_shoff))[i], header, as);
                 if (rc != EE_OK)
                         return rc;

generic/src/lib/func.c

@@ -149 +149 @@
 }
 
-/** Convert ascii representation to __native
+/** Convert ascii representation to unative_t
  *
  * Supports 0x for hexa & 0 for octal notation.
@@ -157 +157 @@
  * @return Converted number or 0 if no valid number ofund 
  */
-__native atoi(const char *text)
+unative_t atoi(const char *text)
 {
         int base = 10;
-        __native result = 0;
+        unative_t result = 0;
 
         if (text[0] == '0' && text[1] == 'x') {

generic/src/lib/memstr.c

@@ -62 +62 @@
         int i, j;
         
-        if (ALIGN_UP((__address) src, sizeof(__native)) != (__address) src ||
-                ALIGN_UP((__address) dst, sizeof(__native)) != (__address) dst) {
+        if (ALIGN_UP((uintptr_t) src, sizeof(unative_t)) != (uintptr_t) src ||
+                ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
                 for (i = 0; i < cnt; i++)
-                        ((__u8 *) dst)[i] = ((__u8 *) src)[i];
+                        ((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
         } else { 
         
-                for (i = 0; i < cnt/sizeof(__native); i++)
-                        ((__native *) dst)[i] = ((__native *) src)[i];
+                for (i = 0; i < cnt/sizeof(unative_t); i++)
+                        ((unative_t *) dst)[i] = ((unative_t *) src)[i];
                 
-                for (j = 0; j < cnt%sizeof(__native); j++)
-                        ((__u8 *)(((__native *) dst) + i))[j] = ((__u8 *)(((__native *) src) + i))[j];
+                for (j = 0; j < cnt%sizeof(unative_t); j++)
+                        ((uint8_t *)(((unative_t *) dst) + i))[j] = ((uint8_t *)(((unative_t *) src) + i))[j];
         }
                 
@@ -88 +88 @@
  *
  */
-void _memsetb(__address dst, size_t cnt, __u8 x)
+void _memsetb(uintptr_t dst, size_t cnt, uint8_t x)
 {
         int i;
-        __u8 *p = (__u8 *) dst;
+        uint8_t *p = (uint8_t *) dst;
         
         for(i=0; i<cnt; i++)
@@ -107 +107 @@
  *
  */
-void _memsetw(__address dst, size_t cnt, __u16 x)
+void _memsetw(uintptr_t dst, size_t cnt, uint16_t x)
 {
         int i;
-        __u16 *p = (__u16 *) dst;
+        uint16_t *p = (uint16_t *) dst;
         
         for(i=0; i<cnt; i++)

generic/src/lib/sort.c

@@ -64 +64 @@
 void qsort(void * data, count_t n, size_t e_size, int (* cmp) (void * a, void * b))
 {
-        __u8 buf_tmp[EBUFSIZE];
-        __u8 buf_pivot[EBUFSIZE];
+        uint8_t buf_tmp[EBUFSIZE];
+        uint8_t buf_pivot[EBUFSIZE];
         void * tmp = buf_tmp;
         void * pivot = buf_pivot;
@@ -133 +133 @@
 void bubblesort(void * data, count_t n, size_t e_size, int (* cmp) (void * a, void * b))
 {
-        __u8 buf_slot[EBUFSIZE];
+        uint8_t buf_slot[EBUFSIZE];
         void * slot = buf_slot;
         
@@ -185 +185 @@
 }
 
-int __u8_cmp(void * a, void * b)
-{
-        return (* (__u8 *) a > * (__u8 *)b) ? 1 : (*(__u8 *)a < * (__u8 *)b) ? -1 : 0;
-}
-
-int __u16_cmp(void * a, void * b)
-{
-        return (* (__u16 *) a > * (__u16 *)b) ? 1 : (*(__u16 *)a < * (__u16 *)b) ? -1 : 0;
-}
-
-int __u32_cmp(void * a, void * b)
-{
-        return (* (__u32 *) a > * (__u32 *)b) ? 1 : (*(__u32 *)a < * (__u32 *)b) ? -1 : 0;
+int uint8_t_cmp(void * a, void * b)
+{
+        return (* (uint8_t *) a > * (uint8_t *)b) ? 1 : (*(uint8_t *)a < * (uint8_t *)b) ? -1 : 0;
+}
+
+int uint16_t_cmp(void * a, void * b)
+{
+        return (* (uint16_t *) a > * (uint16_t *)b) ? 1 : (*(uint16_t *)a < * (uint16_t *)b) ? -1 : 0;
+}
+
+int uint32_t_cmp(void * a, void * b)
+{
+        return (* (uint32_t *) a > * (uint32_t *)b) ? 1 : (*(uint32_t *)a < * (uint32_t *)b) ? -1 : 0;
 }
 

generic/src/main/main.c

@@ -102 +102 @@
  * appropriate sizes and addresses.
  */
-__address hardcoded_load_address = 0;   /**< Virtual address of where the kernel is loaded. */
+uintptr_t hardcoded_load_address = 0;   /**< Virtual address of where the kernel is loaded. */
 size_t hardcoded_ktext_size = 0;        /**< Size of the kernel code in bytes. */
 size_t hardcoded_kdata_size = 0;        /**< Size of the kernel data in bytes. */
@@ -133 +133 @@
 void main_bsp(void)
 {
-        __address stackaddr;
+        uintptr_t stackaddr;
 
         config.cpu_count = 1;
@@ -203 +203 @@
 
         version_print();
-        printf("%.*p: hardcoded_ktext_size=%zdK, hardcoded_kdata_size=%zdK\n", sizeof(__address) * 2, config.base, hardcoded_ktext_size >> 10, hardcoded_kdata_size >> 10);
+        printf("%.*p: hardcoded_ktext_size=%zdK, hardcoded_kdata_size=%zdK\n", sizeof(uintptr_t) * 2, config.base, hardcoded_ktext_size >> 10, hardcoded_kdata_size >> 10);
 
         arch_pre_smp_init();
@@ -224 +224 @@
         
         for (i = 0; i < init.cnt; i++)
-                printf("init[%zd].addr=%.*p, init[%zd].size=%zd\n", i, sizeof(__address) * 2, init.tasks[i].addr, i, init.tasks[i].size);
+                printf("init[%zd].addr=%.*p, init[%zd].size=%zd\n", i, sizeof(uintptr_t) * 2, init.tasks[i].addr, i, init.tasks[i].size);
         
         ipc_init();
@@ -298 +298 @@
          * switch to this cpu's private stack prior to waking kmp up.
          */
-        context_set(&CPU->saved_context, FADDR(main_ap_separated_stack), (__address) CPU->stack, CPU_STACK_SIZE);
+        context_set(&CPU->saved_context, FADDR(main_ap_separated_stack), (uintptr_t) CPU->stack, CPU_STACK_SIZE);
         context_restore(&CPU->saved_context);
         /* not reached */

generic/src/mm/as.c

@@ -98 +98 @@
 
 static int area_flags_to_page_flags(int aflags);
-static as_area_t *find_area_and_lock(as_t *as, __address va);
-static bool check_area_conflicts(as_t *as, __address va, size_t size, as_area_t *avoid_area);
+static as_area_t *find_area_and_lock(as_t *as, uintptr_t va);
+static bool check_area_conflicts(as_t *as, uintptr_t va, size_t size, as_area_t *avoid_area);
 static void sh_info_remove_reference(share_info_t *sh_info);
 
@@ -200 +200 @@
  * @return Address space area on success or NULL on failure.
  */
-as_area_t *as_area_create(as_t *as, int flags, size_t size, __address base, int attrs,
+as_area_t *as_area_create(as_t *as, int flags, size_t size, uintptr_t base, int attrs,
                mem_backend_t *backend, mem_backend_data_t *backend_data)
 {
@@ -239 +239 @@
                 a->backend_data = *backend_data;
         else
-                memsetb((__address) &a->backend_data, sizeof(a->backend_data), 0);
+                memsetb((uintptr_t) &a->backend_data, sizeof(a->backend_data), 0);
 
         btree_create(&a->used_space);
@@ -260 +260 @@
  * @return Zero on success or a value from @ref errno.h otherwise.
  */ 
-int as_area_resize(as_t *as, __address address, size_t size, int flags)
+int as_area_resize(as_t *as, uintptr_t address, size_t size, int flags)
 {
         as_area_t *area;
@@ -313 +313 @@
         if (pages < area->pages) {
                 bool cond;
-                __address start_free = area->base + pages*PAGE_SIZE;
+                uintptr_t start_free = area->base + pages*PAGE_SIZE;
 
                 /*
@@ -338 +338 @@
                         node = list_get_instance(area->used_space.leaf_head.prev, btree_node_t, leaf_link);
                         if ((cond = (bool) node->keys)) {
-                                __address b = node->key[node->keys - 1];
+                                uintptr_t b = node->key[node->keys - 1];
                                 count_t c = (count_t) node->value[node->keys - 1];
                                 int i = 0;
@@ -419 +419 @@
  * @return Zero on success or a value from @ref errno.h on failure. 
  */
-int as_area_destroy(as_t *as, __address address)
+int as_area_destroy(as_t *as, uintptr_t address)
 {
         as_area_t *area;
-        __address base;
+        uintptr_t base;
         link_t *cur;
         ipl_t ipl;
@@ -452 +452 @@
                 node = list_get_instance(cur, btree_node_t, leaf_link);
                 for (i = 0; i < node->keys; i++) {
-                        __address b = node->key[i];
+                        uintptr_t b = node->key[i];
                         count_t j;
                         pte_t *pte;
@@ -519 +519 @@
  *         to share non-anonymous address space area is detected.
  */
-int as_area_share(as_t *src_as, __address src_base, size_t acc_size,
-                  as_t *dst_as, __address dst_base, int dst_flags_mask)
+int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
+                  as_t *dst_as, uintptr_t dst_base, int dst_flags_mask)
 {
         ipl_t ipl;
@@ -666 +666 @@
  *         fault was caused by copy_to_uspace() or copy_from_uspace().
  */
-int as_page_fault(__address page, pf_access_t access, istate_t *istate)
+int as_page_fault(uintptr_t page, pf_access_t access, istate_t *istate)
 {
         pte_t *pte;
@@ -745 +745 @@
         if (THREAD->in_copy_from_uspace) {
                 THREAD->in_copy_from_uspace = false;
-                istate_set_retaddr(istate, (__address) &memcpy_from_uspace_failover_address);
+                istate_set_retaddr(istate, (uintptr_t) &memcpy_from_uspace_failover_address);
         } else if (THREAD->in_copy_to_uspace) {
                 THREAD->in_copy_to_uspace = false;
-                istate_set_retaddr(istate, (__address) &memcpy_to_uspace_failover_address);
+                istate_set_retaddr(istate, (uintptr_t) &memcpy_to_uspace_failover_address);
         } else {
                 return AS_PF_FAULT;
@@ -943 +943 @@
  * @return Locked address space area containing va on success or NULL on failure.
  */
-as_area_t *find_area_and_lock(as_t *as, __address va)
+as_area_t *find_area_and_lock(as_t *as, uintptr_t va)
 {
         as_area_t *a;
@@ -999 +999 @@
  * @return True if there is no conflict, false otherwise.
  */
-bool check_area_conflicts(as_t *as, __address va, size_t size, as_area_t *avoid_area)
+bool check_area_conflicts(as_t *as, uintptr_t va, size_t size, as_area_t *avoid_area)
 {
         as_area_t *a;
@@ -1072 +1072 @@
 
 /** Return size of the address space area with given base.  */
-size_t as_get_size(__address base)
+size_t as_get_size(uintptr_t base)
 {
         ipl_t ipl;
@@ -1100 +1100 @@
  * @return 0 on failure and 1 on success.
  */
-int used_space_insert(as_area_t *a, __address page, count_t count)
+int used_space_insert(as_area_t *a, uintptr_t page, count_t count)
 {
         btree_node_t *leaf, *node;
@@ -1124 +1124 @@
         node = btree_leaf_node_left_neighbour(&a->used_space, leaf);
         if (node) {
-                __address left_pg = node->key[node->keys - 1], right_pg = leaf->key[0];
+                uintptr_t left_pg = node->key[node->keys - 1], right_pg = leaf->key[0];
                 count_t left_cnt = (count_t) node->value[node->keys - 1], right_cnt = (count_t) leaf->value[0];
                 
@@ -1167 +1167 @@
                 }
         } else if (page < leaf->key[0]) {
-                __address right_pg = leaf->key[0];
+                uintptr_t right_pg = leaf->key[0];
                 count_t right_cnt = (count_t) leaf->value[0];
         
@@ -1198 +1198 @@
         node = btree_leaf_node_right_neighbour(&a->used_space, leaf);
         if (node) {
-                __address left_pg = leaf->key[leaf->keys - 1], right_pg = node->key[0];
+                uintptr_t left_pg = leaf->key[leaf->keys - 1], right_pg = node->key[0];
                 count_t left_cnt = (count_t) leaf->value[leaf->keys - 1], right_cnt = (count_t) node->value[0];
                 
@@ -1241 +1241 @@
                 }
         } else if (page >= leaf->key[leaf->keys - 1]) {
-                __address left_pg = leaf->key[leaf->keys - 1];
+                uintptr_t left_pg = leaf->key[leaf->keys - 1];
                 count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
         
@@ -1273 +1273 @@
         for (i = 1; i < leaf->keys; i++) {
                 if (page < leaf->key[i]) {
-                        __address left_pg = leaf->key[i - 1], right_pg = leaf->key[i];
+                        uintptr_t left_pg = leaf->key[i - 1], right_pg = leaf->key[i];
                         count_t left_cnt = (count_t) leaf->value[i - 1], right_cnt = (count_t) leaf->value[i];
 
@@ -1327 +1327 @@
  * @return 0 on failure and 1 on success.
  */
-int used_space_remove(as_area_t *a, __address page, count_t count)
+int used_space_remove(as_area_t *a, uintptr_t page, count_t count)
 {
         btree_node_t *leaf, *node;
@@ -1364 +1364 @@
         node = btree_leaf_node_left_neighbour(&a->used_space, leaf);
         if (node && page < leaf->key[0]) {
-                __address left_pg = node->key[node->keys - 1];
+                uintptr_t left_pg = node->key[node->keys - 1];
                 count_t left_cnt = (count_t) node->value[node->keys - 1];
 
@@ -1397 +1397 @@
         
         if (page > leaf->key[leaf->keys - 1]) {
-                __address left_pg = leaf->key[leaf->keys - 1];
+                uintptr_t left_pg = leaf->key[leaf->keys - 1];
                 count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
 
@@ -1433 +1433 @@
         for (i = 1; i < leaf->keys - 1; i++) {
                 if (page < leaf->key[i]) {
-                        __address left_pg = leaf->key[i - 1];
+                        uintptr_t left_pg = leaf->key[i - 1];
                         count_t left_cnt = (count_t) leaf->value[i - 1];
 
@@ -1497 +1497 @@
                         node = list_get_instance(cur, btree_node_t, leaf_link);
                         for (i = 0; i < node->keys; i++) 
-                                frame_free((__address) node->value[i]);
+                                frame_free((uintptr_t) node->value[i]);
                 }
                 
@@ -1514 +1514 @@
 
 /** Wrapper for as_area_create(). */
-__native sys_as_area_create(__address address, size_t size, int flags)
+unative_t sys_as_area_create(uintptr_t address, size_t size, int flags)
 {
         if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address, AS_AREA_ATTR_NONE, &anon_backend, NULL))
-                return (__native) address;
+                return (unative_t) address;
         else
-                return (__native) -1;
+                return (unative_t) -1;
 }
 
 /** Wrapper for as_area_resize. */
-__native sys_as_area_resize(__address address, size_t size, int flags)
-{
-        return (__native) as_area_resize(AS, address, size, 0);
+unative_t sys_as_area_resize(uintptr_t address, size_t size, int flags)
+{
+        return (unative_t) as_area_resize(AS, address, size, 0);
 }
 
 /** Wrapper for as_area_destroy. */
-__native sys_as_area_destroy(__address address)
-{
-        return (__native) as_area_destroy(AS, address);
+unative_t sys_as_area_destroy(uintptr_t address)
+{
+        return (unative_t) as_area_destroy(AS, address);
 }
 

generic/src/mm/backend_anon.c

@@ -52 +52 @@
 #include <arch.h>
 
-static int anon_page_fault(as_area_t *area, __address addr, pf_access_t access);
-static void anon_frame_free(as_area_t *area, __address page, __address frame);
+static int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access);
+static void anon_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame);
 static void anon_share(as_area_t *area);
 
@@ -72 +72 @@
  * @return AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK on success (i.e. serviced).
  */
-int anon_page_fault(as_area_t *area, __address addr, pf_access_t access)
+int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
 {
-        __address frame;
+        uintptr_t frame;
 
         if (!as_area_check_access(area, access))
@@ -89 +89 @@
                  */
                 mutex_lock(&area->sh_info->lock);
-                frame = (__address) btree_search(&area->sh_info->pagemap,
+                frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
                         ALIGN_DOWN(addr, PAGE_SIZE) - area->base, &leaf);
                 if (!frame) {
@@ -106 +106 @@
                         }
                         if (allocate) {
-                                frame = (__address) frame_alloc(ONE_FRAME, 0);
+                                frame = (uintptr_t) frame_alloc(ONE_FRAME, 0);
                                 memsetb(PA2KA(frame), FRAME_SIZE, 0);
                                 
@@ -133 +133 @@
                  *   the different causes
                  */
-                frame = (__address)frame_alloc(ONE_FRAME, 0);
+                frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
                 memsetb(PA2KA(frame), FRAME_SIZE, 0);
         }
@@ -157 +157 @@
  * @param frame Frame to be released.
  */
-void anon_frame_free(as_area_t *area, __address page, __address frame)
+void anon_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
 {
         frame_free(frame);
@@ -185 +185 @@
                 node = list_get_instance(cur, btree_node_t, leaf_link);
                 for (i = 0; i < node->keys; i++) {
-                        __address base = node->key[i];
+                        uintptr_t base = node->key[i];
                         count_t count = (count_t) node->value[i];
                         int j;

generic/src/mm/backend_elf.c

@@ -51 +51 @@
 #include <arch.h>
 
-static int elf_page_fault(as_area_t *area, __address addr, pf_access_t access);
-static void elf_frame_free(as_area_t *area, __address page, __address frame);
+static int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access);
+static void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame);
 static void elf_share(as_area_t *area);
 
@@ -71 +71 @@
  * @return AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK on success (i.e. serviced).
  */
-int elf_page_fault(as_area_t *area, __address addr, pf_access_t access)
+int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
 {
         elf_header_t *elf = area->backend_data.elf;
         elf_segment_header_t *entry = area->backend_data.segment;
         btree_node_t *leaf;
-        __address base, frame;
+        uintptr_t base, frame;
         index_t i;
 
@@ -84 +84 @@
         ASSERT((addr >= entry->p_vaddr) && (addr < entry->p_vaddr + entry->p_memsz));
         i = (addr - entry->p_vaddr) >> PAGE_WIDTH;
-        base = (__address) (((void *) elf) + entry->p_offset);
+        base = (uintptr_t) (((void *) elf) + entry->p_offset);
         ASSERT(ALIGN_UP(base, FRAME_SIZE) == base);
 
@@ -95 +95 @@
                  
                 mutex_lock(&area->sh_info->lock);
-                frame = (__address) btree_search(&area->sh_info->pagemap,
+                frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
                         ALIGN_DOWN(addr, PAGE_SIZE) - area->base, &leaf);
                 if (!frame) {
@@ -135 +135 @@
                  */
                 if (entry->p_flags & PF_W) {
-                        frame = (__address)frame_alloc(ONE_FRAME, 0);
+                        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
                         memcpy((void *) PA2KA(frame), (void *) (base + i*FRAME_SIZE), FRAME_SIZE);
                         
@@ -154 +154 @@
                  * and cleared.
                  */
-                frame = (__address)frame_alloc(ONE_FRAME, 0);
+                frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
                 memsetb(PA2KA(frame), FRAME_SIZE, 0);
 
@@ -171 +171 @@
                  */
                 size = entry->p_filesz - (i<<PAGE_WIDTH);
-                frame = (__address)frame_alloc(ONE_FRAME, 0);
+                frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
                 memsetb(PA2KA(frame) + size, FRAME_SIZE - size, 0);
                 memcpy((void *) PA2KA(frame), (void *) (base + i*FRAME_SIZE), size);
@@ -202 +202 @@
  *
  */
-void elf_frame_free(as_area_t *area, __address page, __address frame)
+void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
 {
         elf_header_t *elf = area->backend_data.elf;
         elf_segment_header_t *entry = area->backend_data.segment;
-        __address base;
+        uintptr_t base;
         index_t i;
         
         ASSERT((page >= entry->p_vaddr) && (page < entry->p_vaddr + entry->p_memsz));
         i = (page - entry->p_vaddr) >> PAGE_WIDTH;
-        base = (__address) (((void *) elf) + entry->p_offset);
+        base = (uintptr_t) (((void *) elf) + entry->p_offset);
         ASSERT(ALIGN_UP(base, FRAME_SIZE) == base);
         
@@ -246 +246 @@
         link_t *cur;
         btree_node_t *leaf, *node;
-        __address start_anon = entry->p_vaddr + entry->p_filesz;
+        uintptr_t start_anon = entry->p_vaddr + entry->p_filesz;
 
         /*
@@ -270 +270 @@
                 
                 for (i = 0; i < node->keys; i++) {
-                        __address base = node->key[i];
+                        uintptr_t base = node->key[i];
                         count_t count = (count_t) node->value[i];
                         int j;

generic/src/mm/backend_phys.c

@@ -47 +47 @@
 #include <align.h>
 
-static int phys_page_fault(as_area_t *area, __address addr, pf_access_t access);
+static int phys_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access);
 static void phys_share(as_area_t *area);
 
@@ -66 +66 @@
  * @return AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK on success (i.e. serviced).
  */
-int phys_page_fault(as_area_t *area, __address addr, pf_access_t access)
+int phys_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
 {
-        __address base = area->backend_data.base;
+        uintptr_t base = area->backend_data.base;
 
         if (!as_area_check_access(area, access))

generic/src/mm/buddy.c

@@ -67 +67 @@
  */
 void buddy_system_create(buddy_system_t *b,
-                         __u8 max_order, 
+                         uint8_t max_order, 
                          buddy_system_operations_t *op, 
                          void *data)
@@ -102 +102 @@
  * @return True if block can be allocated
  */
-bool buddy_system_can_alloc(buddy_system_t *b, __u8 i) {
-        __u8 k;
+bool buddy_system_can_alloc(buddy_system_t *b, uint8_t i) {
+        uint8_t k;
         
         /*
@@ -131 +131 @@
 {
         link_t *left,*right, *tmp;
-        __u8 order;
+        uint8_t order;
 
         left = b->op->find_block(b, block, BUDDY_SYSTEM_INNER_BLOCK);
@@ -168 +168 @@
  * @return Block of data represented by link_t.
  */
-link_t *buddy_system_alloc(buddy_system_t *b, __u8 i)
+link_t *buddy_system_alloc(buddy_system_t *b, uint8_t i)
 {
         link_t *res, *hlp;
@@ -231 +231 @@
 {
         link_t *buddy, *hlp;
-        __u8 i;
+        uint8_t i;
 
         /*

generic/src/mm/frame.c

@@ -70 +70 @@
 typedef struct {
         count_t refcount;       /**< tracking of shared frames  */
-        __u8 buddy_order;       /**< buddy system block order */
+        uint8_t buddy_order;    /**< buddy system block order */
         link_t buddy_link;      /**< link to the next free block inside one order */
         void *parent;           /**< If allocated by slab, this points there */
@@ -218 +218 @@
 
 /** @return True if zone can allocate specified order */
-static int zone_can_alloc(zone_t *z, __u8 order)
+static int zone_can_alloc(zone_t *z, uint8_t order)
 {
         return buddy_system_can_alloc(z->buddy_system, order);
@@ -231 +231 @@
  * @param pzone Pointer to preferred zone or NULL, on return contains zone number
  */
-static zone_t * find_free_zone_lock(__u8 order, int *pzone)
+static zone_t * find_free_zone_lock(uint8_t order, int *pzone)
 {
         int i;
@@ -272 +272 @@
  */
 static link_t *zone_buddy_find_block(buddy_system_t *b, link_t *child,
-                                     __u8 order)
+                                     uint8_t order)
 {
         frame_t * frame;
@@ -381 +381 @@
  * @param order Order to set
  */
-static void zone_buddy_set_order(buddy_system_t *b, link_t * block, __u8 order) {
+static void zone_buddy_set_order(buddy_system_t *b, link_t * block, uint8_t order) {
         frame_t * frame;
         frame = list_get_instance(block, frame_t, buddy_link);
@@ -394 +394 @@
  * @return Order of block
  */
-static __u8 zone_buddy_get_order(buddy_system_t *b, link_t * block) {
+static uint8_t zone_buddy_get_order(buddy_system_t *b, link_t * block) {
         frame_t * frame;
         frame = list_get_instance(block, frame_t, buddy_link);
@@ -451 +451 @@
  *
  */
-static pfn_t zone_frame_alloc(zone_t *zone, __u8 order)
+static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
 {
         pfn_t v;
@@ -484 +484 @@
 {
         frame_t *frame;
-        __u8 order;
+        uint8_t order;
 
         frame = &zone->frames[frame_idx];
@@ -538 +538 @@
 static void _zone_merge(zone_t *z, zone_t *z1, zone_t *z2)
 {
-        __u8 max_order;
+        uint8_t max_order;
         int i, z2idx;
         pfn_t frame_idx;
@@ -625 +625 @@
         int i;
 
-        pfn = ADDR2PFN((__address)KA2PA(oldzone));
+        pfn = ADDR2PFN((uintptr_t)KA2PA(oldzone));
         cframes = SIZE2FRAMES(zone_conf_size(oldzone->count));
         
@@ -654 +654 @@
 {
         count_t i;
-        __u8 order;
+        uint8_t order;
         frame_t *frame;
         
@@ -690 +690 @@
         zone_t *zone1, *zone2, *newzone;
         int cframes;
-        __u8 order;
+        uint8_t order;
         int i;
         pfn_t pfn;
@@ -780 +780 @@
 {
         int i;
-        __u8 max_order;
+        uint8_t max_order;
 
         spinlock_initialize(&z->lock, "zone_lock");
@@ -818 +818 @@
  * @return Size of zone configuration info (in bytes)
  */
-__address zone_conf_size(count_t count)
+uintptr_t zone_conf_size(count_t count)
 {
         int size = sizeof(zone_t) + count*sizeof(frame_t);
@@ -846 +846 @@
 {
         zone_t *z;
-        __address addr;
+        uintptr_t addr;
         count_t confcount;
         int i;
@@ -932 +932 @@
  *
  */
-void * frame_alloc_generic(__u8 order, int flags, int *pzone) 
+void * frame_alloc_generic(uint8_t order, int flags, int *pzone) 
 {
         ipl_t ipl;
@@ -991 +991 @@
  * @param Frame Physical Address of of the frame to be freed.
  */
-void frame_free(__address frame)
+void frame_free(uintptr_t frame)
 {
         ipl_t ipl;
@@ -1100 +1100 @@
                 zone = zones.info[i];
                 spinlock_lock(&zone->lock);
-                printf("%d: %.*p \t%10zd\t%10zd\n", i, sizeof(__address) * 2, PFN2ADDR(zone->base), zone->free_count, zone->busy_count);
+                printf("%d: %.*p \t%10zd\t%10zd\n", i, sizeof(uintptr_t) * 2, PFN2ADDR(zone->base), zone->free_count, zone->busy_count);
                 spinlock_unlock(&zone->lock);
         }
@@ -1132 +1132 @@
         spinlock_lock(&zone->lock);
         printf("Memory zone information\n");
-        printf("Zone base address: %#.*p\n", sizeof(__address) * 2, PFN2ADDR(zone->base));
+        printf("Zone base address: %#.*p\n", sizeof(uintptr_t) * 2, PFN2ADDR(zone->base));
         printf("Zone size: %zd frames (%zdK)\n", zone->count, ((zone->count) * FRAME_SIZE) >> 10);
         printf("Allocated space: %zd frames (%zdK)\n", zone->busy_count, (zone->busy_count * FRAME_SIZE) >> 10);

generic/src/mm/page.c

@@ -70 +70 @@
  * @param size Size of the structure.
  */
-void map_structure(__address s, size_t size)
+void map_structure(uintptr_t s, size_t size)
 {
         int i, cnt, length;
@@ -94 +94 @@
  * @param flags Flags to be used for mapping.
  */
-void page_mapping_insert(as_t *as, __address page, __address frame, int flags)
+void page_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame, int flags)
 {
         ASSERT(page_mapping_operations);
@@ -113 +113 @@
  * @param page Virtual address of the page to be demapped.
  */
-void page_mapping_remove(as_t *as, __address page)
+void page_mapping_remove(as_t *as, uintptr_t page)
 {
         ASSERT(page_mapping_operations);
@@ -132 +132 @@
  * @return NULL if there is no such mapping; requested mapping otherwise.
  */
-pte_t *page_mapping_find(as_t *as, __address page)
+pte_t *page_mapping_find(as_t *as, uintptr_t page)
 {
         ASSERT(page_mapping_operations);

generic/src/mm/slab.c

@@ -550 +550 @@
         cache->mag_cache = malloc(sizeof(slab_mag_cache_t)*config.cpu_count,0);
         for (i=0; i < config.cpu_count; i++) {
-                memsetb((__address)&cache->mag_cache[i],
+                memsetb((uintptr_t)&cache->mag_cache[i],
                         sizeof(cache->mag_cache[i]), 0);
                 spinlock_initialize(&cache->mag_cache[i].lock, 
@@ -570 +570 @@
         ipl_t ipl;
 
-        memsetb((__address)cache, sizeof(*cache), 0);
+        memsetb((uintptr_t)cache, sizeof(*cache), 0);
         cache->name = name;
 
-        if (align < sizeof(__native))
-                align = sizeof(__native);
+        if (align < sizeof(unative_t))
+                align = sizeof(unative_t);
         size = ALIGN_UP(size, align);
                 
@@ -821 +821 @@
                            "slab_magazine",
                            sizeof(slab_magazine_t)+SLAB_MAG_SIZE*sizeof(void*),
-                           sizeof(__address),
+                           sizeof(uintptr_t),
                            NULL, NULL,
                            SLAB_CACHE_NOMAGAZINE | SLAB_CACHE_SLINSIDE);
@@ -828 +828 @@
                            "slab_cache",
                            sizeof(slab_cache_cache),
-                           sizeof(__address),
+                           sizeof(uintptr_t),
                            NULL, NULL,
                            SLAB_CACHE_NOMAGAZINE | SLAB_CACHE_SLINSIDE);

generic/src/mm/tlb.c

@@ -79 +79 @@
  * @param count Number of pages, if required by type.
  */
-void tlb_shootdown_start(tlb_invalidate_type_t type, asid_t asid, __address page, count_t count)
+void tlb_shootdown_start(tlb_invalidate_type_t type, asid_t asid, uintptr_t page, count_t count)
 {
         int i;
@@ -142 +142 @@
         tlb_invalidate_type_t type;
         asid_t asid;
-        __address page;
+        uintptr_t page;
         count_t count;
         int i;

generic/src/printf/printf_core.c

@@ -89 +89 @@
  * @return string length without trailing zero.
  */
-static __native strlen(const char *str) 
-{
-        __native counter = 0;
+static unative_t strlen(const char *str) 
+{
+        unative_t counter = 0;
 
         while (str[counter] != 0) {
@@ -147 +147 @@
  * @return number of printed characters, negative value on fail
  */
-static int print_char(char c, int width, __u64 flags, struct printf_spec *ps)
+static int print_char(char c, int width, uint64_t flags, struct printf_spec *ps)
 {
         int counter = 0;
@@ -177 +177 @@
  */
                                                 
-static int print_string(char *s, int width, int precision, __u64 flags, struct printf_spec *ps)
+static int print_string(char *s, int width, int precision, uint64_t flags, struct printf_spec *ps)
 {
         int counter = 0;
@@ -237 +237 @@
  *
  */
-static int print_number(__u64 num, int width, int precision, int base , __u64 flags, struct printf_spec *ps)
+static int print_number(uint64_t num, int width, int precision, int base , uint64_t flags, struct printf_spec *ps)
 {
         char *digits = digits_small;
@@ -428 +428 @@
  *      - "l"   Signed or usigned long int.@n
  *      - "ll"  Signed or usigned long long int.@n
- *      - "z"   __native (non-standard extension).@n
+ *      - "z"   unative_t (non-standard extension).@n
  * 
  * 
@@ -467 +467 @@
         qualifier_t qualifier;  /* type of argument */
         int base;       /**< base in which will be parameter (numbers only) printed */
-        __u64 number; /**< argument value */
+        uint64_t number; /**< argument value */
         size_t  size; /**< byte size of integer parameter */
         int width, precision;
-        __u64 flags;
+        uint64_t flags;
         
         counter = 0;
@@ -563 +563 @@
                                         }
                                         break;
-                                case 'z':       /* __native */
+                                case 'z':       /* unative_t */
                                         qualifier = PrintfQualifierNative;
                                         break;
@@ -645 +645 @@
                                 case PrintfQualifierByte:
                                         size = sizeof(unsigned char);
-                                        number = (__u64)va_arg(ap, unsigned int);
+                                        number = (uint64_t)va_arg(ap, unsigned int);
                                         break;
                                 case PrintfQualifierShort:
                                         size = sizeof(unsigned short);
-                                        number = (__u64)va_arg(ap, unsigned int);
+                                        number = (uint64_t)va_arg(ap, unsigned int);
                                         break;
                                 case PrintfQualifierInt:
                                         size = sizeof(unsigned int);
-                                        number = (__u64)va_arg(ap, unsigned int);
+                                        number = (uint64_t)va_arg(ap, unsigned int);
                                         break;
                                 case PrintfQualifierLong:
                                         size = sizeof(unsigned long);
-                                        number = (__u64)va_arg(ap, unsigned long);
+                                        number = (uint64_t)va_arg(ap, unsigned long);
                                         break;
                                 case PrintfQualifierLongLong:
                                         size = sizeof(unsigned long long);
-                                        number = (__u64)va_arg(ap, unsigned long long);
+                                        number = (uint64_t)va_arg(ap, unsigned long long);
                                         break;
                                 case PrintfQualifierPointer:
                                         size = sizeof(void *);
-                                        number = (__u64)(unsigned long)va_arg(ap, void *);
+                                        number = (uint64_t)(unsigned long)va_arg(ap, void *);
                                         break;
                                 case PrintfQualifierNative:
-                                        size = sizeof(__native);
-                                        number = (__u64)va_arg(ap, __native);
+                                        size = sizeof(unative_t);
+                                        number = (uint64_t)va_arg(ap, unative_t);
                                         break;
                                 default: /* Unknown qualifier */
@@ -680 +680 @@
                                         flags |= __PRINTF_FLAG_NEGATIVE;
                                 
-                                        if (size == sizeof(__u64)) {
-                                                number = -((__s64)number);
+                                        if (size == sizeof(uint64_t)) {
+                                                number = -((int64_t)number);
                                         } else {
                                                 number = ~number;
@@ -704 +704 @@
         
         if (i > j) {
-                if ((retval = printf_putnchars(&fmt[j], (__native)(i - j), ps)) < 0) { /* error */
+                if ((retval = printf_putnchars(&fmt[j], (unative_t)(i - j), ps)) < 0) { /* error */
                         counter = -counter;
                         goto out;

generic/src/proc/scheduler.c

@@ -350 +350 @@
          */
         context_save(&CPU->saved_context);
-        context_set(&CPU->saved_context, FADDR(scheduler_separated_stack), (__address) CPU->stack, CPU_STACK_SIZE);
+        context_set(&CPU->saved_context, FADDR(scheduler_separated_stack), (uintptr_t) CPU->stack, CPU_STACK_SIZE);
         context_restore(&CPU->saved_context);
         /* not reached */

generic/src/proc/task.c

@@ -241 +241 @@
  * @return 0 on success or an error code from @ref errno.h.
  */
-__native sys_task_get_id(task_id_t *uspace_task_id)
+unative_t sys_task_get_id(task_id_t *uspace_task_id)
 {
         /*
@@ -247 +247 @@
          * remains constant for the lifespan of the task.
          */
-        return (__native) copy_to_uspace(uspace_task_id, &TASK->taskid, sizeof(TASK->taskid));
+        return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid, sizeof(TASK->taskid));
 }
 

generic/src/proc/thread.c

@@ -91 +91 @@
 
 SPINLOCK_INITIALIZE(tidlock);
-__u32 last_tid = 0;
+uint32_t last_tid = 0;
 
 static slab_cache_t *thread_slab;
@@ -255 +255 @@
 
         spinlock_lock(&threads_lock);
-        btree_remove(&threads_btree, (btree_key_t) ((__address ) t), NULL);
+        btree_remove(&threads_btree, (btree_key_t) ((uintptr_t ) t), NULL);
         spinlock_unlock(&threads_lock);
 
@@ -300 +300 @@
         
         /* Not needed, but good for debugging */
-        memsetb((__address)t->kstack, THREAD_STACK_SIZE * 1<<STACK_FRAMES, 0);
+        memsetb((uintptr_t)t->kstack, THREAD_STACK_SIZE * 1<<STACK_FRAMES, 0);
         
         ipl = interrupts_disable();
@@ -309 +309 @@
         
         context_save(&t->saved_context);
-        context_set(&t->saved_context, FADDR(cushion), (__address) t->kstack, THREAD_STACK_SIZE);
+        context_set(&t->saved_context, FADDR(cushion), (uintptr_t) t->kstack, THREAD_STACK_SIZE);
         
         the_initialize((the_t *) t->kstack);
@@ -369 +369 @@
          */
         spinlock_lock(&threads_lock);
-        btree_insert(&threads_btree, (btree_key_t) ((__address) t), (void *) t, NULL);
+        btree_insert(&threads_btree, (btree_key_t) ((uintptr_t) t), (void *) t, NULL);
         spinlock_unlock(&threads_lock);
         
@@ -412 +412 @@
  *
  */
-void thread_sleep(__u32 sec)
+void thread_sleep(uint32_t sec)
 {
         thread_usleep(sec*1000000);
@@ -425 +425 @@
  * @return An error code from errno.h or an error code from synch.h.
  */
-int thread_join_timeout(thread_t *t, __u32 usec, int flags)
+int thread_join_timeout(thread_t *t, uint32_t usec, int flags)
 {
         ipl_t ipl;
@@ -485 +485 @@
  *
  */     
-void thread_usleep(__u32 usec)
+void thread_usleep(uint32_t usec)
 {
         waitq_t wq;
@@ -565 +565 @@
         btree_node_t *leaf;
         
-        return btree_search(&threads_btree, (btree_key_t) ((__address) t), &leaf) != NULL;
+        return btree_search(&threads_btree, (btree_key_t) ((uintptr_t) t), &leaf) != NULL;
 }
 
@@ -571 +571 @@
  *
  */
-__native sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name)
+unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name)
 {
         thread_t *t;
         char namebuf[THREAD_NAME_BUFLEN];
         uspace_arg_t *kernel_uarg;
-        __u32 tid;
+        uint32_t tid;
         int rc;
 
         rc = copy_from_uspace(namebuf, uspace_name, THREAD_NAME_BUFLEN);
         if (rc != 0)
-                return (__native) rc;
+                return (unative_t) rc;
 
         kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0); 
@@ -587 +587 @@
         if (rc != 0) {
                 free(kernel_uarg);
-                return (__native) rc;
+                return (unative_t) rc;
         }
 
@@ -593 +593 @@
                 tid = t->tid;
                 thread_ready(t);
-                return (__native) tid; 
+                return (unative_t) tid; 
         } else {
                 free(kernel_uarg);
         }
 
-        return (__native) ENOMEM;
+        return (unative_t) ENOMEM;
 }
 
@@ -604 +604 @@
  *
  */
-__native sys_thread_exit(int uspace_status)
+unative_t sys_thread_exit(int uspace_status)
 {
         thread_exit();

generic/src/security/cap.c

@@ -95 +95 @@
  * @return Zero on success or an error code from @ref errno.h.
  */
-__native sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps)
+unative_t sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps)
 {
         sysarg64_t taskid_arg;
@@ -103 +103 @@
         
         if (!(cap_get(TASK) & CAP_CAP))
-                return (__native) EPERM;
+                return (unative_t) EPERM;
         
         rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
         if (rc != 0)
-                return (__native) rc;
+                return (unative_t) rc;
                 
         ipl = interrupts_disable();
@@ -115 +115 @@
                 spinlock_unlock(&tasks_lock);
                 interrupts_restore(ipl);
-                return (__native) ENOENT;
+                return (unative_t) ENOENT;
         }
         
@@ -140 +140 @@
  * @return Zero on success or an error code from @ref errno.h.
  */
-__native sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps)
+unative_t sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps)
 {
         sysarg64_t taskid_arg;
@@ -149 +149 @@
         rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
         if (rc != 0)
-                return (__native) rc;
+                return (unative_t) rc;
 
         ipl = interrupts_disable();
@@ -157 +157 @@
                 spinlock_unlock(&tasks_lock);
                 interrupts_restore(ipl);
-                return (__native) ENOENT;
+                return (unative_t) ENOENT;
         }
 
@@ -168 +168 @@
                 spinlock_unlock(&tasks_lock);
                 interrupts_restore(ipl);
-                return (__native) EPERM;
+                return (unative_t) EPERM;
         }
         

generic/src/synch/condvar.c

@@ -88 +88 @@
  * @return See comment for waitq_sleep_timeout().
  */
-int _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, __u32 usec, int flags)
+int _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, uint32_t usec, int flags)
 {
         int rc;

generic/src/synch/futex.c

@@ -59 +59 @@
 static void futex_initialize(futex_t *futex);
 
-static futex_t *futex_find(__address paddr);
-static index_t futex_ht_hash(__native *key);
-static bool futex_ht_compare(__native *key, count_t keys, link_t *item);
+static futex_t *futex_find(uintptr_t paddr);
+static index_t futex_ht_hash(unative_t *key);
+static bool futex_ht_compare(unative_t *key, count_t keys, link_t *item);
 static void futex_ht_remove_callback(link_t *item);
 
@@ -109 +109 @@
  *         If there is no physical mapping for uaddr ENOENT is returned.
  */
-__native sys_futex_sleep_timeout(__address uaddr, __u32 usec, int flags)
-{
-        futex_t *futex;
-        __address paddr;
+unative_t sys_futex_sleep_timeout(uintptr_t uaddr, uint32_t usec, int flags)
+{
+        futex_t *futex;
+        uintptr_t paddr;
         pte_t *t;
         ipl_t ipl;
@@ -126 +126 @@
                 page_table_unlock(AS, true);
                 interrupts_restore(ipl);
-                return (__native) ENOENT;
+                return (unative_t) ENOENT;
         }
         paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
@@ -135 +135 @@
         futex = futex_find(paddr);
         
-        return (__native) waitq_sleep_timeout(&futex->wq, usec, flags | SYNCH_FLAGS_INTERRUPTIBLE);
+        return (unative_t) waitq_sleep_timeout(&futex->wq, usec, flags | SYNCH_FLAGS_INTERRUPTIBLE);
 }
 
@@ -144 +144 @@
  * @return ENOENT if there is no physical mapping for uaddr.
  */
-__native sys_futex_wakeup(__address uaddr)
-{
-        futex_t *futex;
-        __address paddr;
+unative_t sys_futex_wakeup(uintptr_t uaddr)
+{
+        futex_t *futex;
+        uintptr_t paddr;
         pte_t *t;
         ipl_t ipl;
@@ -161 +161 @@
                 page_table_unlock(AS, true);
                 interrupts_restore(ipl);
-                return (__native) ENOENT;
+                return (unative_t) ENOENT;
         }
         paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
@@ -183 +183 @@
  * @return Address of the kernel futex structure.
  */
-futex_t *futex_find(__address paddr)
+futex_t *futex_find(uintptr_t paddr)
 {
         link_t *item;
@@ -276 +276 @@
  * @return Index into futex hash table.
  */
-index_t futex_ht_hash(__native *key)
+index_t futex_ht_hash(unative_t *key)
 {
         return *key & (FUTEX_HT_SIZE-1);
@@ -287 +287 @@
  * @return True if the item matches the key. False otherwise.
  */
-bool futex_ht_compare(__native *key, count_t keys, link_t *item)
+bool futex_ht_compare(unative_t *key, count_t keys, link_t *item)
 {
         futex_t *futex;
@@ -324 +324 @@
                 for (i = 0; i < node->keys; i++) {
                         futex_t *ftx;
-                        __address paddr = node->key[i];
+                        uintptr_t paddr = node->key[i];
                         
                         ftx = (futex_t *) node->value[i];

generic/src/synch/mutex.c

@@ -65 +65 @@
  * @return See comment for waitq_sleep_timeout().
  */
-int _mutex_lock_timeout(mutex_t *mtx, __u32 usec, int flags)
+int _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, int flags)
 {
         return _semaphore_down_timeout(&mtx->sem, usec, flags);

generic/src/synch/rwlock.c

@@ -102 +102 @@
  * @return See comment for waitq_sleep_timeout().
  */
-int _rwlock_write_lock_timeout(rwlock_t *rwl, __u32 usec, int flags)
+int _rwlock_write_lock_timeout(rwlock_t *rwl, uint32_t usec, int flags)
 {
         ipl_t ipl;
@@ -156 +156 @@
  * @return See comment for waitq_sleep_timeout().
  */
-int _rwlock_read_lock_timeout(rwlock_t *rwl, __u32 usec, int flags)
+int _rwlock_read_lock_timeout(rwlock_t *rwl, uint32_t usec, int flags)
 {
         int rc;

generic/src/synch/semaphore.c

@@ -79 +79 @@
  * @return See comment for waitq_sleep_timeout().
  */
-int _semaphore_down_timeout(semaphore_t *s, __u32 usec, int flags)
+int _semaphore_down_timeout(semaphore_t *s, uint32_t usec, int flags)
 {
         return waitq_sleep_timeout(&s->wq, usec, flags); 

generic/src/synch/spinlock.c

@@ -109 +109 @@
                 if (i++ > DEADLOCK_THRESHOLD) {
                         printf("cpu%d: looping on spinlock %.*p:%s, caller=%.*p",
-                               CPU->id, sizeof(__address) * 2, sl, sl->name, sizeof(__address) * 2, CALLER);
+                               CPU->id, sizeof(uintptr_t) * 2, sl, sl->name, sizeof(uintptr_t) * 2, CALLER);
                         symbol = get_symtab_entry(CALLER);
                         if (symbol)

generic/src/synch/waitq.c

@@ -215 +215 @@
  * attempted.
  */
-int waitq_sleep_timeout(waitq_t *wq, __u32 usec, int flags)
+int waitq_sleep_timeout(waitq_t *wq, uint32_t usec, int flags)
 {
         ipl_t ipl;
@@ -298 +298 @@
  * @return See waitq_sleep_timeout().
  */
-int waitq_sleep_timeout_unsafe(waitq_t *wq, __u32 usec, int flags)
+int waitq_sleep_timeout_unsafe(waitq_t *wq, uint32_t usec, int flags)
 {
         /* checks whether to go to sleep at all */
@@ -352 +352 @@
                 }
                 THREAD->timeout_pending = true;
-                timeout_register(&THREAD->sleep_timeout, (__u64) usec, waitq_timeouted_sleep, THREAD);
+                timeout_register(&THREAD->sleep_timeout, (uint64_t) usec, waitq_timeouted_sleep, THREAD);
         }
 

generic/src/syscall/copy.c

@@ -68 +68 @@
         
         if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
-                if (overlaps((__address) uspace_src, size,
+                if (overlaps((uintptr_t) uspace_src, size,
                         KERNEL_ADDRESS_SPACE_START, KERNEL_ADDRESS_SPACE_END-KERNEL_ADDRESS_SPACE_START)) {
                         /*
@@ -109 +109 @@
         
         if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
-                if (overlaps((__address) uspace_dst, size,
+                if (overlaps((uintptr_t) uspace_dst, size,
                         KERNEL_ADDRESS_SPACE_START, KERNEL_ADDRESS_SPACE_END-KERNEL_ADDRESS_SPACE_START)) {
                         /*

generic/src/syscall/syscall.c

@@ -59 +59 @@
  * this syscall to facilitate it.
  */
-static __native sys_io(int fd, const void * buf, size_t count) 
+static unative_t sys_io(int fd, const void * buf, size_t count) 
 {
         size_t i;
@@ -86 +86 @@
 
 /** Tell kernel to get keyboard/console access again */
-static __native sys_debug_enable_console(void)
+static unative_t sys_debug_enable_console(void)
 {
         arch_grab_console();
@@ -93 +93 @@
 
 /** Dispatch system call */
-__native syscall_handler(__native a1, __native a2, __native a3,
-                         __native a4, __native id)
+unative_t syscall_handler(unative_t a1, unative_t a2, unative_t a3,
+                         unative_t a4, unative_t id)
 {
-        __native rc;
+        unative_t rc;
 
         if (id < SYSCALL_END)

generic/src/sysinfo/sysinfo.c

@@ -168 +168 @@
 }
 
-void sysinfo_set_item_val(const char *name, sysinfo_item_t **root, __native val)
+void sysinfo_set_item_val(const char *name, sysinfo_item_t **root, unative_t val)
 {
         if (root == NULL)
@@ -223 +223 @@
         while (root != NULL) {
                 int i;
-                __native val = 0;
+                unative_t val = 0;
                 char *vtype = NULL;
                 
@@ -279 +279 @@
 }
 
-__native sys_sysinfo_valid(__native ptr, __native len)
+unative_t sys_sysinfo_valid(unative_t ptr, unative_t len)
 {
         char *str;
@@ -293 +293 @@
 }
 
-__native sys_sysinfo_value(__native ptr, __native len)
+unative_t sys_sysinfo_value(unative_t ptr, unative_t len)
 {
         char *str;

generic/src/time/clock.c

@@ -58 +58 @@
 /* Pointers to public variables with time */
 struct ptime {
-        __native seconds1;
-        __native useconds;
-        __native seconds2;
+        unative_t seconds1;
+        unative_t useconds;
+        unative_t seconds2;
 };
 struct ptime *public_time;
@@ -66 +66 @@
  * seconds correctly
  */
-static __native secfrag = 0;
+static unative_t secfrag = 0;
 
 /** Initialize realtime clock counter
@@ -91 +91 @@
         public_time->useconds = 0; 
 
-        sysinfo_set_item_val("clock.faddr", NULL, (__native)faddr);
+        sysinfo_set_item_val("clock.faddr", NULL, (unative_t)faddr);
 }
 
@@ -166 +166 @@
 
         if (THREAD) {
-                __u64 ticks;
+                uint64_t ticks;
                 
                 spinlock_lock(&CPU->lock);

generic/src/time/delay.c

@@ -50 +50 @@
  * @param usec Number of microseconds to sleep.
  */
-void delay(__u32 usec)
+void delay(uint32_t usec)
 {
         ipl_t ipl;

generic/src/time/timeout.c

@@ -104 +104 @@
  *
  */
-void timeout_register(timeout_t *t, __u64 time, timeout_handler_t f, void *arg)
+void timeout_register(timeout_t *t, uint64_t time, timeout_handler_t f, void *arg)
 {
         timeout_t *hlp = NULL;
         link_t *l, *m;
         ipl_t ipl;
-        __u64 sum;
+        uint64_t sum;
 
         ipl = interrupts_disable();