diff --git a/kernel/Kconfig b/kernel/Kconfig
index 4245572..ffa6aaf 100644
--- a/kernel/Kconfig
+++ b/kernel/Kconfig
@@ -577,7 +577,7 @@
 	  The k_timeout_t API has changed to become an opaque type
 	  that must be initialized with macros.  Older applications
 	  can choose this to continue using the old style of timeouts
-	  (which were s32_t counts of milliseconds), at the cost of
+	  (which were int32_t counts of milliseconds), at the cost of
 	  not being able to use new features.
 
 config TIMEOUT_64BIT
diff --git a/kernel/device.c b/kernel/device.c
index 53df56d..0e6f2aa 100644
--- a/kernel/device.c
+++ b/kernel/device.c
@@ -24,8 +24,8 @@
 extern struct device __device_end[];
 
 #ifdef CONFIG_DEVICE_POWER_MANAGEMENT
-extern u32_t __device_busy_start[];
-extern u32_t __device_busy_end[];
+extern uint32_t __device_busy_start[];
+extern uint32_t __device_busy_end[];
 #define DEVICE_BUSY_SIZE (__device_busy_end - __device_busy_start)
 #endif
 
@@ -40,7 +40,7 @@
  *
  * @param level init level to run.
  */
-void z_sys_init_run_level(s32_t level)
+void z_sys_init_run_level(int32_t level)
 {
 	static const struct init_entry *levels[] = {
 		__init_PRE_KERNEL_1_start,
@@ -119,7 +119,7 @@
 
 #ifdef CONFIG_DEVICE_POWER_MANAGEMENT
 int device_pm_control_nop(struct device *unused_device,
-		       u32_t unused_ctrl_command,
+		       uint32_t unused_ctrl_command,
 		       void *unused_context,
 		       device_pm_cb cb,
 		       void *unused_arg)
diff --git a/kernel/idle.c b/kernel/idle.c
index 701b4b7..5393803 100644
--- a/kernel/idle.c
+++ b/kernel/idle.c
@@ -63,7 +63,7 @@
  * @return N/A
  */
 #if !SMP_FALLBACK
-static void set_kernel_idle_time_in_ticks(s32_t ticks)
+static void set_kernel_idle_time_in_ticks(int32_t ticks)
 {
 #ifdef CONFIG_SYS_POWER_MANAGEMENT
 	_kernel.idle = ticks;
@@ -72,7 +72,7 @@
 
 static void sys_power_save_idle(void)
 {
-	s32_t ticks = z_get_next_timeout_expiry();
+	int32_t ticks = z_get_next_timeout_expiry();
 
 	/* The documented behavior of CONFIG_TICKLESS_IDLE_THRESH is
 	 * that the system should not enter a tickless idle for
@@ -113,7 +113,7 @@
 }
 #endif
 
-void z_sys_power_save_idle_exit(s32_t ticks)
+void z_sys_power_save_idle_exit(int32_t ticks)
 {
 #if defined(CONFIG_SYS_POWER_SLEEP_STATES)
 	/* Some CPU low power states require notification at the ISR
@@ -146,7 +146,7 @@
 #ifdef CONFIG_BOOT_TIME_MEASUREMENT
 	/* record timestamp when idling begins */
 
-	extern u32_t z_timestamp_idle;
+	extern uint32_t z_timestamp_idle;
 
 	z_timestamp_idle = k_cycle_get_32();
 #endif
diff --git a/kernel/include/kernel_arch_interface.h b/kernel/include/kernel_arch_interface.h
index 781a40d..1ced9df 100644
--- a/kernel/include/kernel_arch_interface.h
+++ b/kernel/include/kernel_arch_interface.h
@@ -36,7 +36,7 @@
  *
  * @param usec_to_wait Wait period, in microseconds
  */
-void arch_busy_wait(u32_t usec_to_wait);
+void arch_busy_wait(uint32_t usec_to_wait);
 #endif
 
 /** @} */
diff --git a/kernel/include/kernel_internal.h b/kernel/include/kernel_internal.h
index c137d78..c0852d0 100644
--- a/kernel/include/kernel_internal.h
+++ b/kernel/include/kernel_internal.h
@@ -44,7 +44,7 @@
 			      k_thread_stack_t *stack, size_t stack_size,
 			      k_thread_entry_t entry,
 			      void *p1, void *p2, void *p3,
-			      int prio, u32_t options, const char *name);
+			      int prio, uint32_t options, const char *name);
 
 static inline void z_new_thread_init(struct k_thread *thread,
 				     char *stack, size_t stack_size)
@@ -117,15 +117,15 @@
 
 extern void smp_timer_init(void);
 
-extern void z_early_boot_rand_get(u8_t *buf, size_t length);
+extern void z_early_boot_rand_get(uint8_t *buf, size_t length);
 
 #if CONFIG_STACK_POINTER_RANDOM
 extern int z_stack_adjust_initialized;
 #endif
 
 #ifdef CONFIG_BOOT_TIME_MEASUREMENT
-extern u32_t z_timestamp_main; /* timestamp when main task starts */
-extern u32_t z_timestamp_idle; /* timestamp when CPU goes idle */
+extern uint32_t z_timestamp_main; /* timestamp when main task starts */
+extern uint32_t z_timestamp_idle; /* timestamp when CPU goes idle */
 #endif
 
 extern struct k_thread z_main_thread;
@@ -138,7 +138,7 @@
 				   CONFIG_ISR_STACK_SIZE);
 
 #ifdef CONFIG_GEN_PRIV_STACKS
-extern u8_t *z_priv_stack_find(k_thread_stack_t *stack);
+extern uint8_t *z_priv_stack_find(k_thread_stack_t *stack);
 #endif
 
 #ifdef __cplusplus
diff --git a/kernel/include/ksched.h b/kernel/include/ksched.h
index 4a88bef..2f350fa 100644
--- a/kernel/include/ksched.h
+++ b/kernel/include/ksched.h
@@ -43,11 +43,11 @@
 void z_unpend_thread_no_timeout(struct k_thread *thread);
 int z_pend_curr(struct k_spinlock *lock, k_spinlock_key_t key,
 	       _wait_q_t *wait_q, k_timeout_t timeout);
-int z_pend_curr_irqlock(u32_t key, _wait_q_t *wait_q, k_timeout_t timeout);
+int z_pend_curr_irqlock(uint32_t key, _wait_q_t *wait_q, k_timeout_t timeout);
 void z_pend_thread(struct k_thread *thread, _wait_q_t *wait_q,
 		   k_timeout_t timeout);
 void z_reschedule(struct k_spinlock *lock, k_spinlock_key_t key);
-void z_reschedule_irqlock(u32_t key);
+void z_reschedule_irqlock(uint32_t key);
 struct k_thread *z_unpend_first_thread(_wait_q_t *wait_q);
 void z_unpend_thread(struct k_thread *thread);
 int z_unpend_all(_wait_q_t *wait_q);
@@ -110,7 +110,7 @@
 
 static inline bool z_is_thread_prevented_from_running(struct k_thread *thread)
 {
-	u8_t state = thread->base.thread_state;
+	uint8_t state = thread->base.thread_state;
 
 	return (state & (_THREAD_PENDING | _THREAD_PRESTART | _THREAD_DEAD |
 			 _THREAD_DUMMY | _THREAD_SUSPENDED)) != 0U;
@@ -133,7 +133,7 @@
 	return (thread->base.thread_state & _THREAD_PRESTART) == 0U;
 }
 
-static inline bool z_is_thread_state_set(struct k_thread *thread, u32_t state)
+static inline bool z_is_thread_state_set(struct k_thread *thread, uint32_t state)
 {
 	return (thread->base.thread_state & state) != 0U;
 }
@@ -170,13 +170,13 @@
 	thread->base.thread_state &= ~_THREAD_PENDING;
 }
 
-static inline void z_set_thread_states(struct k_thread *thread, u32_t states)
+static inline void z_set_thread_states(struct k_thread *thread, uint32_t states)
 {
 	thread->base.thread_state |= states;
 }
 
 static inline void z_reset_thread_states(struct k_thread *thread,
-					u32_t states)
+					uint32_t states)
 {
 	thread->base.thread_state &= ~states;
 }
diff --git a/kernel/init.c b/kernel/init.c
index fb25ff3..6f97f64 100644
--- a/kernel/init.c
+++ b/kernel/init.c
@@ -52,8 +52,8 @@
 /* boot time measurement items */
 
 #ifdef CONFIG_BOOT_TIME_MEASUREMENT
-u32_t __noinit z_timestamp_main;  /* timestamp when main task starts */
-u32_t __noinit z_timestamp_idle;  /* timestamp when CPU goes idle */
+uint32_t __noinit z_timestamp_main;  /* timestamp when main task starts */
+uint32_t __noinit z_timestamp_idle;  /* timestamp when CPU goes idle */
 #endif
 
 /* init/main and idle threads */
@@ -108,11 +108,11 @@
 	(void)memset(__bss_start, 0, __bss_end - __bss_start);
 #if DT_NODE_HAS_STATUS(DT_CHOSEN(zephyr_ccm), okay)
 	(void)memset(&__ccm_bss_start, 0,
-		     ((u32_t) &__ccm_bss_end - (u32_t) &__ccm_bss_start));
+		     ((uint32_t) &__ccm_bss_end - (uint32_t) &__ccm_bss_start));
 #endif
 #if DT_NODE_HAS_STATUS(DT_CHOSEN(zephyr_dtcm), okay)
 	(void)memset(&__dtcm_bss_start, 0,
-		     ((u32_t) &__dtcm_bss_end - (u32_t) &__dtcm_bss_start));
+		     ((uint32_t) &__dtcm_bss_end - (uint32_t) &__dtcm_bss_start));
 #endif
 #ifdef CONFIG_CODE_DATA_RELOCATION
 	extern void bss_zeroing_relocation(void);
@@ -121,7 +121,7 @@
 #endif	/* CONFIG_CODE_DATA_RELOCATION */
 #ifdef CONFIG_COVERAGE_GCOV
 	(void)memset(&__gcov_bss_start, 0,
-		 ((u32_t) &__gcov_bss_end - (u32_t) &__gcov_bss_start));
+		 ((uint32_t) &__gcov_bss_end - (uint32_t) &__gcov_bss_start));
 #endif
 }
 
@@ -169,9 +169,9 @@
 	 * value gets set later in z_cstart().
 	 */
 	uintptr_t guard_copy = __stack_chk_guard;
-	u8_t *src = (u8_t *)&_app_smem_rom_start;
-	u8_t *dst = (u8_t *)&_app_smem_start;
-	u32_t count = _app_smem_end - _app_smem_start;
+	uint8_t *src = (uint8_t *)&_app_smem_rom_start;
+	uint8_t *dst = (uint8_t *)&_app_smem_start;
+	uint32_t count = _app_smem_end - _app_smem_start;
 
 	guard_copy = __stack_chk_guard;
 	while (count > 0) {
@@ -373,9 +373,9 @@
 #endif /* CONFIG_MULTITHREADING */
 
 #if defined(CONFIG_ENTROPY_HAS_DRIVER) || defined(CONFIG_TEST_RANDOM_GENERATOR)
-void z_early_boot_rand_get(u8_t *buf, size_t length)
+void z_early_boot_rand_get(uint8_t *buf, size_t length)
 {
-	int n = sizeof(u32_t);
+	int n = sizeof(uint32_t);
 #ifdef CONFIG_ENTROPY_HAS_DRIVER
 	struct device *entropy = device_get_binding(DT_CHOSEN_ZEPHYR_ENTROPY_LABEL);
 	int rc;
@@ -410,12 +410,12 @@
 	 */
 
 	while (length > 0) {
-		u32_t rndbits;
-		u8_t *p_rndbits = (u8_t *)&rndbits;
+		uint32_t rndbits;
+		uint8_t *p_rndbits = (uint8_t *)&rndbits;
 
 		rndbits = sys_rand32_get();
 
-		if (length < sizeof(u32_t)) {
+		if (length < sizeof(uint32_t)) {
 			n = length;
 		}
 
@@ -467,7 +467,7 @@
 #ifdef CONFIG_STACK_CANARIES
 	uintptr_t stack_guard;
 
-	z_early_boot_rand_get((u8_t *)&stack_guard, sizeof(stack_guard));
+	z_early_boot_rand_get((uint8_t *)&stack_guard, sizeof(stack_guard));
 	__stack_chk_guard = stack_guard;
 	__stack_chk_guard <<= 8;
 #endif	/* CONFIG_STACK_CANARIES */
diff --git a/kernel/kheap.c b/kernel/kheap.c
index 12344ce..8951649 100644
--- a/kernel/kheap.c
+++ b/kernel/kheap.c
@@ -28,7 +28,7 @@
 
 void *k_heap_alloc(struct k_heap *h, size_t bytes, k_timeout_t timeout)
 {
-	s64_t now, end = z_timeout_end_calc(timeout);
+	int64_t now, end = z_timeout_end_calc(timeout);
 	void *ret = NULL;
 	k_spinlock_key_t key = k_spin_lock(&h->lock);
 
diff --git a/kernel/mailbox.c b/kernel/mailbox.c
index cd9016f..bb20e8f 100644
--- a/kernel/mailbox.c
+++ b/kernel/mailbox.c
@@ -120,7 +120,7 @@
 static int mbox_message_match(struct k_mbox_msg *tx_msg,
 			       struct k_mbox_msg *rx_msg)
 {
-	u32_t temp_info;
+	uint32_t temp_info;
 
 	if (((tx_msg->tx_target_thread == (k_tid_t)K_ANY) ||
 	     (tx_msg->tx_target_thread == rx_msg->tx_target_thread)) &&
diff --git a/kernel/mem_domain.c b/kernel/mem_domain.c
index 8534ae7..1458269 100644
--- a/kernel/mem_domain.c
+++ b/kernel/mem_domain.c
@@ -13,17 +13,17 @@
 #include <spinlock.h>
 
 static struct k_spinlock lock;
-static u8_t max_partitions;
+static uint8_t max_partitions;
 
 #if (defined(CONFIG_EXECUTE_XOR_WRITE) || \
 	defined(CONFIG_MPU_REQUIRES_NON_OVERLAPPING_REGIONS)) && __ASSERT_ON
 static bool sane_partition(const struct k_mem_partition *part,
 			   const struct k_mem_partition *parts,
-			   u32_t num_parts)
+			   uint32_t num_parts)
 {
 	bool exec, write;
-	u32_t last;
-	u32_t i;
+	uint32_t last;
+	uint32_t i;
 
 	last = part->start + part->size - 1;
 	exec = K_MEM_PARTITION_IS_EXECUTABLE(part->attr);
@@ -38,7 +38,7 @@
 
 	for (i = 0U; i < num_parts; i++) {
 		bool cur_write, cur_exec;
-		u32_t cur_last;
+		uint32_t cur_last;
 
 		cur_last = parts[i].start + parts[i].size - 1;
 
@@ -80,7 +80,7 @@
 #define sane_partition_domain(...) (true)
 #endif
 
-void k_mem_domain_init(struct k_mem_domain *domain, u8_t num_parts,
+void k_mem_domain_init(struct k_mem_domain *domain, uint8_t num_parts,
 		       struct k_mem_partition *parts[])
 {
 	k_spinlock_key_t key;
@@ -95,7 +95,7 @@
 	(void)memset(domain->partitions, 0, sizeof(domain->partitions));
 
 	if (num_parts != 0U) {
-		u32_t i;
+		uint32_t i;
 
 		for (i = 0U; i < num_parts; i++) {
 			__ASSERT(parts[i] != NULL, "");
diff --git a/kernel/mem_slab.c b/kernel/mem_slab.c
index 6c4dc80..7c51689 100644
--- a/kernel/mem_slab.c
+++ b/kernel/mem_slab.c
@@ -31,7 +31,7 @@
  */
 static int create_free_list(struct k_mem_slab *slab)
 {
-	u32_t j;
+	uint32_t j;
 	char *p;
 
 	/* blocks must be word aligned */
@@ -80,7 +80,7 @@
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
 
 int k_mem_slab_init(struct k_mem_slab *slab, void *buffer,
-		    size_t block_size, u32_t num_blocks)
+		    size_t block_size, uint32_t num_blocks)
 {
 	int rc = 0;
 
diff --git a/kernel/mempool_sys.c b/kernel/mempool_sys.c
index da78107..a8d749b 100644
--- a/kernel/mempool_sys.c
+++ b/kernel/mempool_sys.c
@@ -48,14 +48,14 @@
 		     size_t size, k_timeout_t timeout)
 {
 	int ret;
-	u64_t end = 0;
+	uint64_t end = 0;
 
 	__ASSERT(!(arch_is_in_isr() && !K_TIMEOUT_EQ(timeout, K_NO_WAIT)), "");
 
 	end = z_timeout_end_calc(timeout);
 
 	while (true) {
-		u32_t level_num, block_num;
+		uint32_t level_num, block_num;
 
 		ret = z_sys_mem_pool_block_alloc(&p->base, size,
 						 &level_num, &block_num,
@@ -72,7 +72,7 @@
 		z_pend_curr_unlocked(&p->wait_q, timeout);
 
 		if (!K_TIMEOUT_EQ(timeout, K_FOREVER)) {
-			s64_t remaining = end - z_tick_get();
+			int64_t remaining = end - z_tick_get();
 
 			if (remaining <= 0) {
 				break;
diff --git a/kernel/msg_q.c b/kernel/msg_q.c
index f7351f2..106d46a 100644
--- a/kernel/msg_q.c
+++ b/kernel/msg_q.c
@@ -47,7 +47,7 @@
 #endif /* CONFIG_OBJECT_TRACING */
 
 void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size,
-		 u32_t max_msgs)
+		 uint32_t max_msgs)
 {
 	msgq->msg_size = msg_size;
 	msgq->max_msgs = max_msgs;
@@ -66,7 +66,7 @@
 }
 
 int z_impl_k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size,
-			    u32_t max_msgs)
+			    uint32_t max_msgs)
 {
 	void *buffer;
 	int ret;
@@ -90,7 +90,7 @@
 
 #ifdef CONFIG_USERSPACE
 int z_vrfy_k_msgq_alloc_init(struct k_msgq *q, size_t msg_size,
-			    u32_t max_msgs)
+			    uint32_t max_msgs)
 {
 	Z_OOPS(Z_SYSCALL_OBJ_NEVER_INIT(q, K_OBJ_MSGQ));
 
@@ -312,14 +312,14 @@
 }
 #include <syscalls/k_msgq_purge_mrsh.c>
 
-static inline u32_t z_vrfy_k_msgq_num_free_get(struct k_msgq *q)
+static inline uint32_t z_vrfy_k_msgq_num_free_get(struct k_msgq *q)
 {
 	Z_OOPS(Z_SYSCALL_OBJ(q, K_OBJ_MSGQ));
 	return z_impl_k_msgq_num_free_get(q);
 }
 #include <syscalls/k_msgq_num_free_get_mrsh.c>
 
-static inline u32_t z_vrfy_k_msgq_num_used_get(struct k_msgq *q)
+static inline uint32_t z_vrfy_k_msgq_num_used_get(struct k_msgq *q)
 {
 	Z_OOPS(Z_SYSCALL_OBJ(q, K_OBJ_MSGQ));
 	return z_impl_k_msgq_num_used_get(q);
diff --git a/kernel/mutex.c b/kernel/mutex.c
index 3181966..551cbe2 100644
--- a/kernel/mutex.c
+++ b/kernel/mutex.c
@@ -93,7 +93,7 @@
 #include <syscalls/k_mutex_init_mrsh.c>
 #endif
 
-static s32_t new_prio_for_inheritance(s32_t target, s32_t limit)
+static int32_t new_prio_for_inheritance(int32_t target, int32_t limit)
 {
 	int new_prio = z_is_prio_higher(target, limit) ? target : limit;
 
@@ -102,7 +102,7 @@
 	return new_prio;
 }
 
-static bool adjust_owner_prio(struct k_mutex *mutex, s32_t new_prio)
+static bool adjust_owner_prio(struct k_mutex *mutex, int32_t new_prio)
 {
 	if (mutex->owner->base.prio != new_prio) {
 
diff --git a/kernel/pipes.c b/kernel/pipes.c
index d28d7a3..f841767 100644
--- a/kernel/pipes.c
+++ b/kernel/pipes.c
@@ -639,7 +639,7 @@
 				  sys_dlist_get(&xfer_list);
 	while ((thread != NULL) && (num_bytes_read < bytes_to_read)) {
 		desc = (struct k_pipe_desc *)thread->base.swap_data;
-		bytes_copied = pipe_xfer((u8_t *)data + num_bytes_read,
+		bytes_copied = pipe_xfer((uint8_t *)data + num_bytes_read,
 					  bytes_to_read - num_bytes_read,
 					  desc->buffer, desc->bytes_to_xfer);
 
@@ -663,7 +663,7 @@
 
 	if ((writer != NULL) && (num_bytes_read < bytes_to_read)) {
 		desc = (struct k_pipe_desc *)writer->base.swap_data;
-		bytes_copied = pipe_xfer((u8_t *)data + num_bytes_read,
+		bytes_copied = pipe_xfer((uint8_t *)data + num_bytes_read,
 					  bytes_to_read - num_bytes_read,
 					  desc->buffer, desc->bytes_to_xfer);
 
@@ -722,7 +722,7 @@
 
 	struct k_pipe_desc  pipe_desc;
 
-	pipe_desc.buffer        = (u8_t *)data + num_bytes_read;
+	pipe_desc.buffer        = (uint8_t *)data + num_bytes_read;
 	pipe_desc.bytes_to_xfer = bytes_to_read - num_bytes_read;
 
 	if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
diff --git a/kernel/poll.c b/kernel/poll.c
index 4fe88ff..9c0ab72 100644
--- a/kernel/poll.c
+++ b/kernel/poll.c
@@ -35,7 +35,7 @@
  */
 static struct k_spinlock lock;
 
-void k_poll_event_init(struct k_poll_event *event, u32_t type,
+void k_poll_event_init(struct k_poll_event *event, uint32_t type,
 		       int mode, void *obj)
 {
 	__ASSERT(mode == K_POLL_MODE_NOTIFY_ONLY,
@@ -53,7 +53,7 @@
 }
 
 /* must be called with interrupts locked */
-static inline bool is_condition_met(struct k_poll_event *event, u32_t *state)
+static inline bool is_condition_met(struct k_poll_event *event, uint32_t *state)
 {
 	switch (event->type) {
 	case K_POLL_TYPE_SEM_AVAILABLE:
@@ -182,7 +182,7 @@
 	}
 }
 
-static inline void set_event_ready(struct k_poll_event *event, u32_t state)
+static inline void set_event_ready(struct k_poll_event *event, uint32_t state)
 {
 	event->poller = NULL;
 	event->state |= state;
@@ -197,7 +197,7 @@
 
 	for (int ii = 0; ii < num_events; ii++) {
 		k_spinlock_key_t key;
-		u32_t state;
+		uint32_t state;
 
 		key = k_spin_lock(&lock);
 		if (is_condition_met(&events[ii], &state)) {
@@ -217,7 +217,7 @@
 	return events_registered;
 }
 
-static int k_poll_poller_cb(struct k_poll_event *event, u32_t state)
+static int k_poll_poller_cb(struct k_poll_event *event, uint32_t state)
 {
 	struct k_thread *thread = event->poller->thread;
 
@@ -307,7 +307,7 @@
 	int ret;
 	k_spinlock_key_t key;
 	struct k_poll_event *events_copy = NULL;
-	u32_t bounds;
+	uint32_t bounds;
 
 	/* Validate the events buffer and make a copy of it in an
 	 * allocated kernel-side buffer.
@@ -378,7 +378,7 @@
 #endif
 
 /* must be called with interrupts locked */
-static int signal_poll_event(struct k_poll_event *event, u32_t state)
+static int signal_poll_event(struct k_poll_event *event, uint32_t state)
 {
 	struct _poller *poller = event->poller;
 	int retcode = 0;
@@ -399,7 +399,7 @@
 	return retcode;
 }
 
-void z_handle_obj_poll_events(sys_dlist_t *events, u32_t state)
+void z_handle_obj_poll_events(sys_dlist_t *events, uint32_t state)
 {
 	struct k_poll_event *poll_event;
 
@@ -521,7 +521,7 @@
 	k_work_submit_to_queue(work_q, &twork->work);
 }
 
-static int triggered_work_poller_cb(struct k_poll_event *event, u32_t status)
+static int triggered_work_poller_cb(struct k_poll_event *event, uint32_t status)
 {
 	struct _poller *poller = event->poller;
 
diff --git a/kernel/queue.c b/kernel/queue.c
index 578325a..1564fb7 100644
--- a/kernel/queue.c
+++ b/kernel/queue.c
@@ -33,7 +33,7 @@
 {
 	void *ret;
 
-	if ((node != NULL) && (sys_sfnode_flags_get(node) != (u8_t)0)) {
+	if ((node != NULL) && (sys_sfnode_flags_get(node) != (uint8_t)0)) {
 		/* If the flag is set, then the enqueue operation for this item
 		 * did a behind-the scenes memory allocation of an alloc_node
 		 * struct, which is what got put in the queue. Free it and pass
@@ -106,7 +106,7 @@
 	z_ready_thread(thread);
 }
 
-static inline void handle_poll_events(struct k_queue *queue, u32_t state)
+static inline void handle_poll_events(struct k_queue *queue, uint32_t state)
 {
 #ifdef CONFIG_POLL
 	z_handle_obj_poll_events(&queue->poll_events, state);
@@ -137,7 +137,7 @@
 #include <syscalls/k_queue_cancel_wait_mrsh.c>
 #endif
 
-static s32_t queue_insert(struct k_queue *queue, void *prev, void *data,
+static int32_t queue_insert(struct k_queue *queue, void *prev, void *data,
 			  bool alloc)
 {
 	k_spinlock_key_t key = k_spin_lock(&queue->lock);
@@ -189,14 +189,14 @@
 	(void)queue_insert(queue, NULL, data, false);
 }
 
-s32_t z_impl_k_queue_alloc_append(struct k_queue *queue, void *data)
+int32_t z_impl_k_queue_alloc_append(struct k_queue *queue, void *data)
 {
 	return queue_insert(queue, sys_sflist_peek_tail(&queue->data_q), data,
 			    true);
 }
 
 #ifdef CONFIG_USERSPACE
-static inline s32_t z_vrfy_k_queue_alloc_append(struct k_queue *queue,
+static inline int32_t z_vrfy_k_queue_alloc_append(struct k_queue *queue,
 						void *data)
 {
 	Z_OOPS(Z_SYSCALL_OBJ(queue, K_OBJ_QUEUE));
@@ -205,13 +205,13 @@
 #include <syscalls/k_queue_alloc_append_mrsh.c>
 #endif
 
-s32_t z_impl_k_queue_alloc_prepend(struct k_queue *queue, void *data)
+int32_t z_impl_k_queue_alloc_prepend(struct k_queue *queue, void *data)
 {
 	return queue_insert(queue, NULL, data, true);
 }
 
 #ifdef CONFIG_USERSPACE
-static inline s32_t z_vrfy_k_queue_alloc_prepend(struct k_queue *queue,
+static inline int32_t z_vrfy_k_queue_alloc_prepend(struct k_queue *queue,
 						 void *data)
 {
 	Z_OOPS(Z_SYSCALL_OBJ(queue, K_OBJ_QUEUE));
diff --git a/kernel/sched.c b/kernel/sched.c
index 093dd28..20567cb 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -288,7 +288,7 @@
 	}
 }
 
-void k_sched_time_slice_set(s32_t slice, int prio)
+void k_sched_time_slice_set(int32_t slice, int prio)
 {
 	LOCKED(&sched_spinlock) {
 		_current_cpu->slice_ticks = 0;
@@ -506,7 +506,7 @@
 			}
 		}
 
-		u32_t mask = _THREAD_DEAD;
+		uint32_t mask = _THREAD_DEAD;
 
 		/* If the abort is happening in interrupt context,
 		 * that means that execution will never return to the
@@ -649,7 +649,7 @@
 }
 #endif
 
-int z_pend_curr_irqlock(u32_t key, _wait_q_t *wait_q, k_timeout_t timeout)
+int z_pend_curr_irqlock(uint32_t key, _wait_q_t *wait_q, k_timeout_t timeout)
 {
 	pend(_current, wait_q, timeout);
 
@@ -737,7 +737,7 @@
 	}
 }
 
-static inline int resched(u32_t key)
+static inline int resched(uint32_t key)
 {
 #ifdef CONFIG_SMP
 	_current_cpu->swap_ok = 0;
@@ -755,7 +755,7 @@
 	}
 }
 
-void z_reschedule_irqlock(u32_t key)
+void z_reschedule_irqlock(uint32_t key)
 {
 	if (resched(key)) {
 		z_swap_irqlock(key);
@@ -1076,7 +1076,7 @@
 	Z_OOPS(Z_SYSCALL_OBJ(thread, K_OBJ_THREAD));
 	Z_OOPS(Z_SYSCALL_VERIFY_MSG(_is_valid_prio(prio, NULL),
 				    "invalid thread priority %d", prio));
-	Z_OOPS(Z_SYSCALL_VERIFY_MSG((s8_t)prio >= thread->base.prio,
+	Z_OOPS(Z_SYSCALL_VERIFY_MSG((int8_t)prio >= thread->base.prio,
 				    "thread priority may only be downgraded (%d < %d)",
 				    prio, thread->base.prio));
 
@@ -1142,10 +1142,10 @@
 #include <syscalls/k_yield_mrsh.c>
 #endif
 
-static s32_t z_tick_sleep(s32_t ticks)
+static int32_t z_tick_sleep(int32_t ticks)
 {
 #ifdef CONFIG_MULTITHREADING
-	u32_t expected_wakeup_time;
+	uint32_t expected_wakeup_time;
 
 	__ASSERT(!arch_is_in_isr(), "");
 
@@ -1195,7 +1195,7 @@
 	return 0;
 }
 
-s32_t z_impl_k_sleep(k_timeout_t timeout)
+int32_t z_impl_k_sleep(k_timeout_t timeout)
 {
 	k_ticks_t ticks;
 
@@ -1203,7 +1203,7 @@
 
 	if (K_TIMEOUT_EQ(timeout, K_FOREVER)) {
 		k_thread_suspend(_current);
-		return (s32_t) K_TICKS_FOREVER;
+		return (int32_t) K_TICKS_FOREVER;
 	}
 
 #ifdef CONFIG_LEGACY_TIMEOUT_API
@@ -1217,16 +1217,16 @@
 }
 
 #ifdef CONFIG_USERSPACE
-static inline s32_t z_vrfy_k_sleep(k_timeout_t timeout)
+static inline int32_t z_vrfy_k_sleep(k_timeout_t timeout)
 {
 	return z_impl_k_sleep(timeout);
 }
 #include <syscalls/k_sleep_mrsh.c>
 #endif
 
-s32_t z_impl_k_usleep(int us)
+int32_t z_impl_k_usleep(int us)
 {
-	s32_t ticks;
+	int32_t ticks;
 
 	ticks = k_us_to_ticks_ceil64(us);
 	ticks = z_tick_sleep(ticks);
@@ -1234,7 +1234,7 @@
 }
 
 #ifdef CONFIG_USERSPACE
-static inline s32_t z_vrfy_k_usleep(int us)
+static inline int32_t z_vrfy_k_usleep(int us)
 {
 	return z_impl_k_usleep(us);
 }
@@ -1381,7 +1381,7 @@
 # endif
 
 
-static int cpu_mask_mod(k_tid_t thread, u32_t enable_mask, u32_t disable_mask)
+static int cpu_mask_mod(k_tid_t thread, uint32_t enable_mask, uint32_t disable_mask)
 {
 	int ret = 0;
 
diff --git a/kernel/stack.c b/kernel/stack.c
index be00a1f..d9c4b53 100644
--- a/kernel/stack.c
+++ b/kernel/stack.c
@@ -42,7 +42,7 @@
 #endif /* CONFIG_OBJECT_TRACING */
 
 void k_stack_init(struct k_stack *stack, stack_data_t *buffer,
-		  u32_t num_entries)
+		  uint32_t num_entries)
 {
 	z_waitq_init(&stack->wait_q);
 	stack->lock = (struct k_spinlock) {};
@@ -53,16 +53,16 @@
 	z_object_init(stack);
 }
 
-s32_t z_impl_k_stack_alloc_init(struct k_stack *stack, u32_t num_entries)
+int32_t z_impl_k_stack_alloc_init(struct k_stack *stack, uint32_t num_entries)
 {
 	void *buffer;
-	s32_t ret;
+	int32_t ret;
 
 	buffer = z_thread_malloc(num_entries * sizeof(stack_data_t));
 	if (buffer != NULL) {
 		k_stack_init(stack, buffer, num_entries);
 		stack->flags = K_STACK_FLAG_ALLOC;
-		ret = (s32_t)0;
+		ret = (int32_t)0;
 	} else {
 		ret = -ENOMEM;
 	}
@@ -71,8 +71,8 @@
 }
 
 #ifdef CONFIG_USERSPACE
-static inline s32_t z_vrfy_k_stack_alloc_init(struct k_stack *stack,
-					      u32_t num_entries)
+static inline int32_t z_vrfy_k_stack_alloc_init(struct k_stack *stack,
+					      uint32_t num_entries)
 {
 	Z_OOPS(Z_SYSCALL_OBJ_NEVER_INIT(stack, K_OBJ_STACK));
 	Z_OOPS(Z_SYSCALL_VERIFY(num_entries > 0));
@@ -87,7 +87,7 @@
 		return -EAGAIN;
 	}
 
-	if ((stack->flags & K_STACK_FLAG_ALLOC) != (u8_t)0) {
+	if ((stack->flags & K_STACK_FLAG_ALLOC) != (uint8_t)0) {
 		k_free(stack->base);
 		stack->base = NULL;
 		stack->flags &= ~K_STACK_FLAG_ALLOC;
diff --git a/kernel/thread.c b/kernel/thread.c
index a1288ae..5dc1b4e 100644
--- a/kernel/thread.c
+++ b/kernel/thread.c
@@ -115,19 +115,19 @@
 }
 
 #ifdef CONFIG_SYS_CLOCK_EXISTS
-void z_impl_k_busy_wait(u32_t usec_to_wait)
+void z_impl_k_busy_wait(uint32_t usec_to_wait)
 {
 #if !defined(CONFIG_ARCH_HAS_CUSTOM_BUSY_WAIT)
 	/* use 64-bit math to prevent overflow when multiplying */
-	u32_t cycles_to_wait = (u32_t)(
-		(u64_t)usec_to_wait *
-		(u64_t)sys_clock_hw_cycles_per_sec() /
-		(u64_t)USEC_PER_SEC
+	uint32_t cycles_to_wait = (uint32_t)(
+		(uint64_t)usec_to_wait *
+		(uint64_t)sys_clock_hw_cycles_per_sec() /
+		(uint64_t)USEC_PER_SEC
 	);
-	u32_t start_cycles = k_cycle_get_32();
+	uint32_t start_cycles = k_cycle_get_32();
 
 	for (;;) {
-		u32_t current_cycles = k_cycle_get_32();
+		uint32_t current_cycles = k_cycle_get_32();
 
 		/* this handles the rollover on an unsigned 32-bit value */
 		if ((current_cycles - start_cycles) >= cycles_to_wait) {
@@ -140,7 +140,7 @@
 }
 
 #ifdef CONFIG_USERSPACE
-static inline void z_vrfy_k_busy_wait(u32_t usec_to_wait)
+static inline void z_vrfy_k_busy_wait(uint32_t usec_to_wait)
 {
 	z_impl_k_busy_wait(usec_to_wait);
 }
@@ -358,13 +358,13 @@
  */
 void z_check_stack_sentinel(void)
 {
-	u32_t *stack;
+	uint32_t *stack;
 
 	if ((_current->base.thread_state & _THREAD_DUMMY) != 0) {
 		return;
 	}
 
-	stack = (u32_t *)_current->stack_info.start;
+	stack = (uint32_t *)_current->stack_info.start;
 	if (*stack != STACK_SENTINEL) {
 		/* Restore it so further checks don't trigger this same error */
 		*stack = STACK_SENTINEL;
@@ -422,9 +422,9 @@
 	size_t random_val;
 
 	if (!z_stack_adjust_initialized) {
-		z_early_boot_rand_get((u8_t *)&random_val, sizeof(random_val));
+		z_early_boot_rand_get((uint8_t *)&random_val, sizeof(random_val));
 	} else {
-		sys_rand_get((u8_t *)&random_val, sizeof(random_val));
+		sys_rand_get((uint8_t *)&random_val, sizeof(random_val));
 	}
 
 	/* Don't need to worry about alignment of the size here,
@@ -457,7 +457,7 @@
 		       k_thread_stack_t *stack, size_t stack_size,
 		       k_thread_entry_t entry,
 		       void *p1, void *p2, void *p3,
-		       int prio, u32_t options, const char *name)
+		       int prio, uint32_t options, const char *name)
 {
 	Z_ASSERT_VALID_PRIO(prio, entry);
 
@@ -504,7 +504,7 @@
 	 * We periodically check that it's still present and kill the thread
 	 * if it isn't.
 	 */
-	*((u32_t *)new_thread->stack_info.start) = STACK_SENTINEL;
+	*((uint32_t *)new_thread->stack_info.start) = STACK_SENTINEL;
 #endif /* CONFIG_STACK_SENTINEL */
 #ifdef CONFIG_THREAD_USERSPACE_LOCAL_DATA
 #ifndef CONFIG_THREAD_USERSPACE_LOCAL_DATA_ARCH_DEFER_SETUP
@@ -575,7 +575,7 @@
 			      k_thread_stack_t *stack,
 			      size_t stack_size, k_thread_entry_t entry,
 			      void *p1, void *p2, void *p3,
-			      int prio, u32_t options, k_timeout_t delay)
+			      int prio, uint32_t options, k_timeout_t delay)
 {
 	__ASSERT(!arch_is_in_isr(), "Threads may not be created in ISRs");
 
@@ -602,7 +602,7 @@
 			       k_thread_stack_t *stack,
 			       size_t stack_size, k_thread_entry_t entry,
 			       void *p1, void *p2, void *p3,
-			       int prio, u32_t options, k_timeout_t delay)
+			       int prio, uint32_t options, k_timeout_t delay)
 {
 	size_t total_size, stack_obj_size;
 	struct z_object *stack_object;
@@ -720,12 +720,12 @@
 #endif
 
 void z_init_thread_base(struct _thread_base *thread_base, int priority,
-		       u32_t initial_state, unsigned int options)
+		       uint32_t initial_state, unsigned int options)
 {
 	/* k_q_node is initialized upon first insertion in a list */
 
-	thread_base->user_options = (u8_t)options;
-	thread_base->thread_state = (u8_t)initial_state;
+	thread_base->user_options = (uint8_t)options;
+	thread_base->thread_state = (uint8_t)initial_state;
 
 	thread_base->prio = priority;
 
@@ -829,15 +829,15 @@
 int z_impl_k_thread_stack_space_get(const struct k_thread *thread,
 				    size_t *unused_ptr)
 {
-	const u8_t *start = (u8_t *)thread->stack_info.start;
+	const uint8_t *start = (uint8_t *)thread->stack_info.start;
 	size_t size = thread->stack_info.size;
 	size_t unused = 0;
-	const u8_t *checked_stack = start;
+	const uint8_t *checked_stack = start;
 	/* Take the address of any local variable as a shallow bound for the
 	 * stack pointer.  Addresses above it are guaranteed to be
 	 * accessible.
 	 */
-	const u8_t *stack_pointer = (const u8_t *)&start;
+	const uint8_t *stack_pointer = (const uint8_t *)&start;
 
 	/* If we are currently running on the stack being analyzed, some
 	 * memory management hardware will generate an exception if we
diff --git a/kernel/timeout.c b/kernel/timeout.c
index 523a7a4..e5f3b05 100644
--- a/kernel/timeout.c
+++ b/kernel/timeout.c
@@ -17,7 +17,7 @@
 			__i.key == 0;					\
 			k_spin_unlock(lck, __key), __i.key = 1)
 
-static u64_t curr_tick;
+static uint64_t curr_tick;
 
 static sys_dlist_t timeout_list = SYS_DLIST_STATIC_INIT(&timeout_list);
 
@@ -64,16 +64,16 @@
 	sys_dlist_remove(&t->node);
 }
 
-static s32_t elapsed(void)
+static int32_t elapsed(void)
 {
 	return announce_remaining == 0 ? z_clock_elapsed() : 0;
 }
 
-static s32_t next_timeout(void)
+static int32_t next_timeout(void)
 {
 	struct _timeout *to = first();
-	s32_t ticks_elapsed = elapsed();
-	s32_t ret = to == NULL ? MAX_WAIT : MAX(0, to->dticks - ticks_elapsed);
+	int32_t ticks_elapsed = elapsed();
+	int32_t ret = to == NULL ? MAX_WAIT : MAX(0, to->dticks - ticks_elapsed);
 
 #ifdef CONFIG_TIMESLICING
 	if (_current_cpu->slice_ticks && _current_cpu->slice_ticks < ret) {
@@ -184,9 +184,9 @@
 	return ticks;
 }
 
-s32_t z_get_next_timeout_expiry(void)
+int32_t z_get_next_timeout_expiry(void)
 {
-	s32_t ret = (s32_t) K_TICKS_FOREVER;
+	int32_t ret = (int32_t) K_TICKS_FOREVER;
 
 	LOCKED(&timeout_lock) {
 		ret = next_timeout();
@@ -194,7 +194,7 @@
 	return ret;
 }
 
-void z_set_timeout_expiry(s32_t ticks, bool idle)
+void z_set_timeout_expiry(int32_t ticks, bool idle)
 {
 	LOCKED(&timeout_lock) {
 		int next = next_timeout();
@@ -217,7 +217,7 @@
 	}
 }
 
-void z_clock_announce(s32_t ticks)
+void z_clock_announce(int32_t ticks)
 {
 #ifdef CONFIG_TIMESLICING
 	z_time_slice(ticks);
@@ -253,9 +253,9 @@
 	k_spin_unlock(&timeout_lock, key);
 }
 
-s64_t z_tick_get(void)
+int64_t z_tick_get(void)
 {
-	u64_t t = 0U;
+	uint64_t t = 0U;
 
 	LOCKED(&timeout_lock) {
 		t = curr_tick + z_clock_elapsed();
@@ -263,22 +263,22 @@
 	return t;
 }
 
-u32_t z_tick_get_32(void)
+uint32_t z_tick_get_32(void)
 {
 #ifdef CONFIG_TICKLESS_KERNEL
-	return (u32_t)z_tick_get();
+	return (uint32_t)z_tick_get();
 #else
-	return (u32_t)curr_tick;
+	return (uint32_t)curr_tick;
 #endif
 }
 
-s64_t z_impl_k_uptime_ticks(void)
+int64_t z_impl_k_uptime_ticks(void)
 {
 	return z_tick_get();
 }
 
 #ifdef CONFIG_USERSPACE
-static inline s64_t z_vrfy_k_uptime_ticks(void)
+static inline int64_t z_vrfy_k_uptime_ticks(void)
 {
 	return z_impl_k_uptime_ticks();
 }
@@ -290,7 +290,7 @@
  * synchronously with the user passing a new timeout value.  It should
  * not be used iteratively to adjust a timeout.
  */
-u64_t z_timeout_end_calc(k_timeout_t timeout)
+uint64_t z_timeout_end_calc(k_timeout_t timeout)
 {
 	k_ticks_t dt;
 
diff --git a/kernel/timer.c b/kernel/timer.c
index 350a603..9a9b268 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -186,10 +186,10 @@
 #include <syscalls/k_timer_stop_mrsh.c>
 #endif
 
-u32_t z_impl_k_timer_status_get(struct k_timer *timer)
+uint32_t z_impl_k_timer_status_get(struct k_timer *timer)
 {
 	k_spinlock_key_t key = k_spin_lock(&lock);
-	u32_t result = timer->status;
+	uint32_t result = timer->status;
 
 	timer->status = 0U;
 	k_spin_unlock(&lock, key);
@@ -198,7 +198,7 @@
 }
 
 #ifdef CONFIG_USERSPACE
-static inline u32_t z_vrfy_k_timer_status_get(struct k_timer *timer)
+static inline uint32_t z_vrfy_k_timer_status_get(struct k_timer *timer)
 {
 	Z_OOPS(Z_SYSCALL_OBJ(timer, K_OBJ_TIMER));
 	return z_impl_k_timer_status_get(timer);
@@ -206,12 +206,12 @@
 #include <syscalls/k_timer_status_get_mrsh.c>
 #endif
 
-u32_t z_impl_k_timer_status_sync(struct k_timer *timer)
+uint32_t z_impl_k_timer_status_sync(struct k_timer *timer)
 {
 	__ASSERT(!arch_is_in_isr(), "");
 
 	k_spinlock_key_t key = k_spin_lock(&lock);
-	u32_t result = timer->status;
+	uint32_t result = timer->status;
 
 	if (result == 0U) {
 		if (!z_is_inactive_timeout(&timer->timeout)) {
@@ -235,7 +235,7 @@
 }
 
 #ifdef CONFIG_USERSPACE
-static inline u32_t z_vrfy_k_timer_status_sync(struct k_timer *timer)
+static inline uint32_t z_vrfy_k_timer_status_sync(struct k_timer *timer)
 {
 	Z_OOPS(Z_SYSCALL_OBJ(timer, K_OBJ_TIMER));
 	return z_impl_k_timer_status_sync(timer);
diff --git a/kernel/userspace.c b/kernel/userspace.c
index 04f3239..941a767 100644
--- a/kernel/userspace.c
+++ b/kernel/userspace.c
@@ -55,7 +55,7 @@
 #define MAX_THREAD_BITS		(CONFIG_MAX_THREAD_BYTES * 8)
 
 #ifdef CONFIG_DYNAMIC_OBJECTS
-extern u8_t _thread_idx_map[CONFIG_MAX_THREAD_BYTES];
+extern uint8_t _thread_idx_map[CONFIG_MAX_THREAD_BYTES];
 #endif
 
 static void clear_perms_cb(struct z_object *ko, void *ctx_ptr);
@@ -100,7 +100,7 @@
  */
 BUILD_ASSERT(CONFIG_PRIVILEGED_STACK_SIZE % Z_PRIVILEGE_STACK_ALIGN == 0);
 
-u8_t *z_priv_stack_find(k_thread_stack_t *stack)
+uint8_t *z_priv_stack_find(k_thread_stack_t *stack)
 {
 	struct z_object *obj = z_object_find(stack);
 
@@ -117,7 +117,7 @@
 	struct z_object kobj;
 	sys_dnode_t obj_list;
 	struct rbnode node; /* must be immediately before data member */
-	u8_t data[]; /* The object itself */
+	uint8_t data[]; /* The object itself */
 };
 
 extern struct z_object *z_object_gperf_find(void *obj);
diff --git a/kernel/version.c b/kernel/version.c
index a2b7cf0..799e555 100644
--- a/kernel/version.c
+++ b/kernel/version.c
@@ -15,7 +15,7 @@
  *
  * @return kernel version
  */
-u32_t sys_kernel_version_get(void)
+uint32_t sys_kernel_version_get(void)
 {
 	return KERNELVERSION;
 }