Index: kernel/arch/sparc64/src/smp/sun4v/smp.c
===================================================================
--- kernel/arch/sparc64/src/smp/sun4v/smp.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/arch/sparc64/src/smp/sun4v/smp.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -92,6 +92,6 @@
 
 	/* calculate the number of threads the core will steal */
-	int avg = atomic_get(&nrdy) / exec_unit_count;
-	int to_steal = avg - atomic_get(&(exec_units->nrdy));
+	int avg = atomic_load(&nrdy) / exec_unit_count;
+	int to_steal = avg - atomic_load(&(exec_units->nrdy));
 	if (to_steal < 0) {
 		return true;
@@ -104,5 +104,5 @@
 	for (k = 0; k < exec_unit->strand_count; k++) {
 		exec_units->cpus[k]->arch.proposed_nrdy =
-		    atomic_get(&(exec_unit->cpus[k]->nrdy));
+		    atomic_load(&(exec_unit->cpus[k]->nrdy));
 	}
 
@@ -338,5 +338,5 @@
 
 			cpus[cur_cpu].arch.exec_unit = &(exec_units[cur_core]);
-			atomic_add(&(exec_units[cur_core].nrdy), atomic_get(&(cpus[cur_cpu].nrdy)));
+			atomic_add(&(exec_units[cur_core].nrdy), atomic_load(&(cpus[cur_cpu].nrdy)));
 			cpus[cur_cpu].arch.id = exec_units[cur_core].cpuids[cur_core_strand];
 			exec_units[cur_core].cpus[cur_core_strand] = &(cpus[cur_cpu]);
Index: kernel/generic/include/atomic.h
===================================================================
--- kernel/generic/include/atomic.h	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/include/atomic.h	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -49,9 +49,4 @@
 }
 
-static inline atomic_count_t atomic_get(atomic_t *val)
-{
-	return atomic_load(val);
-}
-
 static inline size_t atomic_predec(atomic_t *val)
 {
Index: kernel/generic/src/adt/cht.c
===================================================================
--- kernel/generic/src/adt/cht.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/adt/cht.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -618,5 +618,5 @@
 
 	/* You must clear the table of items. Otherwise cht_destroy will leak. */
-	assert(atomic_get(&h->item_cnt) == 0);
+	assert(atomic_load(&h->item_cnt) == 0);
 }
 
@@ -625,5 +625,5 @@
 {
 	/* Wait for resize to complete. */
-	while (0 < atomic_get(&h->resize_reqs)) {
+	while (0 < atomic_load(&h->resize_reqs)) {
 		rcu_barrier();
 	}
@@ -2160,5 +2160,5 @@
 	/* Make resize_reqs visible. */
 	read_barrier();
-	assert(0 < atomic_get(&h->resize_reqs));
+	assert(0 < atomic_load(&h->resize_reqs));
 #endif
 
@@ -2168,5 +2168,5 @@
 		/* Load the most recent h->item_cnt. */
 		read_barrier();
-		size_t cur_items = (size_t) atomic_get(&h->item_cnt);
+		size_t cur_items = (size_t) atomic_load(&h->item_cnt);
 		size_t bucket_cnt = (1 << h->b->order);
 		size_t max_items = h->max_load * bucket_cnt;
Index: kernel/generic/src/console/chardev.c
===================================================================
--- kernel/generic/src/console/chardev.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/console/chardev.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -94,5 +94,5 @@
 wchar_t indev_pop_character(indev_t *indev)
 {
-	if (atomic_get(&haltstate)) {
+	if (atomic_load(&haltstate)) {
 		/*
 		 * If we are here, we are hopefully on the processor that
Index: kernel/generic/src/console/console.c
===================================================================
--- kernel/generic/src/console/console.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/console/console.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -292,5 +292,5 @@
 void kio_update(void *event)
 {
-	if (!atomic_get(&kio_inited))
+	if (!atomic_load(&kio_inited))
 		return;
 
Index: kernel/generic/src/ipc/ipc.c
===================================================================
--- kernel/generic/src/ipc/ipc.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/ipc/ipc.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -783,5 +783,5 @@
 static void ipc_wait_for_all_answered_calls(void)
 {
-	while (atomic_get(&TASK->answerbox.active_calls) != 0) {
+	while (atomic_load(&TASK->answerbox.active_calls) != 0) {
 		call_t *call = NULL;
 		if (ipc_wait_for_call(&TASK->answerbox,
@@ -873,5 +873,5 @@
 	ipc_wait_for_all_answered_calls();
 
-	assert(atomic_get(&TASK->answerbox.active_calls) == 0);
+	assert(atomic_load(&TASK->answerbox.active_calls) == 0);
 }
 
@@ -928,5 +928,5 @@
 	if (phone->state != IPC_PHONE_FREE) {
 		printf("%-11d %7" PRIun " ", (int) CAP_HANDLE_RAW(cap->handle),
-		    atomic_get(&phone->active_calls));
+		    atomic_load(&phone->active_calls));
 
 		switch (phone->state) {
@@ -981,5 +981,5 @@
 
 	printf("Active calls: %" PRIun "\n",
-	    atomic_get(&task->answerbox.active_calls));
+	    atomic_load(&task->answerbox.active_calls));
 
 #ifdef __32_BITS__
Index: kernel/generic/src/ipc/sysipc.c
===================================================================
--- kernel/generic/src/ipc/sysipc.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/ipc/sysipc.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -341,5 +341,5 @@
 static int check_call_limit(phone_t *phone)
 {
-	if (atomic_get(&phone->active_calls) >= IPC_MAX_ASYNC_CALLS)
+	if (atomic_load(&phone->active_calls) >= IPC_MAX_ASYNC_CALLS)
 		return -1;
 
Index: kernel/generic/src/lib/halt.c
===================================================================
--- kernel/generic/src/lib/halt.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/lib/halt.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -56,5 +56,5 @@
 	bool rundebugger = false;
 
-	if (!atomic_get(&haltstate)) {
+	if (!atomic_load(&haltstate)) {
 		atomic_set(&haltstate, 1);
 		rundebugger = true;
Index: kernel/generic/src/log/log.c
===================================================================
--- kernel/generic/src/log/log.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/log/log.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -190,5 +190,5 @@
 static void log_update(void *event)
 {
-	if (!atomic_get(&log_inited))
+	if (!atomic_load(&log_inited))
 		return;
 
Index: kernel/generic/src/mm/slab.c
===================================================================
--- kernel/generic/src/mm/slab.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/mm/slab.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -690,5 +690,5 @@
 	 * endless loop
 	 */
-	atomic_count_t magcount = atomic_get(&cache->magazine_counter);
+	atomic_count_t magcount = atomic_load(&cache->magazine_counter);
 
 	slab_magazine_t *mag;
@@ -876,7 +876,7 @@
 		size_t size = cache->size;
 		size_t objects = cache->objects;
-		long allocated_slabs = atomic_get(&cache->allocated_slabs);
-		long cached_objs = atomic_get(&cache->cached_objs);
-		long allocated_objs = atomic_get(&cache->allocated_objs);
+		long allocated_slabs = atomic_load(&cache->allocated_slabs);
+		long cached_objs = atomic_load(&cache->cached_objs);
+		long allocated_objs = atomic_load(&cache->allocated_objs);
 		unsigned int flags = cache->flags;
 
Index: kernel/generic/src/proc/scheduler.c
===================================================================
--- kernel/generic/src/proc/scheduler.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/proc/scheduler.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -205,5 +205,5 @@
 loop:
 
-	if (atomic_get(&CPU->nrdy) == 0) {
+	if (atomic_load(&CPU->nrdy) == 0) {
 		/*
 		 * For there was nothing to run, the CPU goes to sleep
@@ -327,5 +327,5 @@
 	ipl = interrupts_disable();
 
-	if (atomic_get(&haltstate))
+	if (atomic_load(&haltstate))
 		halt();
 
@@ -531,5 +531,5 @@
 	    "cpu%u: tid %" PRIu64 " (priority=%d, ticks=%" PRIu64
 	    ", nrdy=%zu)", CPU->id, THREAD->tid, THREAD->priority,
-	    THREAD->ticks, atomic_get(&CPU->nrdy));
+	    THREAD->ticks, atomic_load(&CPU->nrdy));
 #endif
 
@@ -587,6 +587,6 @@
 	 *
 	 */
-	average = atomic_get(&nrdy) / config.cpu_active + 1;
-	rdy = atomic_get(&CPU->nrdy);
+	average = atomic_load(&nrdy) / config.cpu_active + 1;
+	rdy = atomic_load(&CPU->nrdy);
 
 	if (average <= rdy)
@@ -616,5 +616,5 @@
 				continue;
 
-			if (atomic_get(&cpu->nrdy) <= average)
+			if (atomic_load(&cpu->nrdy) <= average)
 				continue;
 
@@ -678,6 +678,6 @@
 				    "kcpulb%u: TID %" PRIu64 " -> cpu%u, "
 				    "nrdy=%ld, avg=%ld", CPU->id, t->tid,
-				    CPU->id, atomic_get(&CPU->nrdy),
-				    atomic_get(&nrdy) / config.cpu_active);
+				    CPU->id, atomic_load(&CPU->nrdy),
+				    atomic_load(&nrdy) / config.cpu_active);
 #endif
 
@@ -705,5 +705,5 @@
 	}
 
-	if (atomic_get(&CPU->nrdy)) {
+	if (atomic_load(&CPU->nrdy)) {
 		/*
 		 * Be a little bit light-weight and let migrated threads run.
@@ -740,5 +740,5 @@
 
 		printf("cpu%u: address=%p, nrdy=%zu, needs_relink=%zu\n",
-		    cpus[cpu].id, &cpus[cpu], atomic_get(&cpus[cpu].nrdy),
+		    cpus[cpu].id, &cpus[cpu], atomic_load(&cpus[cpu].nrdy),
 		    cpus[cpu].needs_relink);
 
Index: kernel/generic/src/proc/task.c
===================================================================
--- kernel/generic/src/proc/task.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/proc/task.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -620,5 +620,5 @@
 	if (*additional)
 		printf("%-8" PRIu64 " %9zu", task->taskid,
-		    atomic_get(&task->refcount));
+		    atomic_load(&task->refcount));
 	else
 		printf("%-8" PRIu64 " %-14s %-5" PRIu32 " %10p %10p"
@@ -632,5 +632,5 @@
 		printf("%-8" PRIu64 " %9" PRIu64 "%c %9" PRIu64 "%c "
 		    "%9zu\n", task->taskid, ucycles, usuffix, kcycles,
-		    ksuffix, atomic_get(&task->refcount));
+		    ksuffix, atomic_load(&task->refcount));
 	else
 		printf("%-8" PRIu64 " %-14s %-5" PRIu32 " %18p %18p\n",
Index: kernel/generic/src/smp/smp_call.c
===================================================================
--- kernel/generic/src/smp/smp_call.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/smp/smp_call.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -271,5 +271,5 @@
 		 */
 		memory_barrier();
-	} while (atomic_get(&call_info->pending));
+	} while (atomic_load(&call_info->pending));
 }
 
Index: kernel/generic/src/synch/rcu.c
===================================================================
--- kernel/generic/src/synch/rcu.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/synch/rcu.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -1477,5 +1477,5 @@
 static bool wait_for_delaying_cpus(void)
 {
-	int delaying_cpu_cnt = atomic_get(&rcu.delaying_cpu_cnt);
+	int delaying_cpu_cnt = atomic_load(&rcu.delaying_cpu_cnt);
 
 	for (int i = 0; i < delaying_cpu_cnt; ++i) {
Index: kernel/generic/src/sysinfo/stats.c
===================================================================
--- kernel/generic/src/sysinfo/stats.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/generic/src/sysinfo/stats.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -239,5 +239,5 @@
 	stats_task->virtmem = get_task_virtmem(task->as);
 	stats_task->resmem = get_task_resmem(task->as);
-	stats_task->threads = atomic_get(&task->refcount);
+	stats_task->threads = atomic_load(&task->refcount);
 	task_get_accounting(task, &(stats_task->ucycles),
 	    &(stats_task->kcycles));
@@ -784,5 +784,5 @@
 
 	while (true) {
-		atomic_count_t ready = atomic_get(&nrdy);
+		atomic_count_t ready = atomic_load(&nrdy);
 
 		/* Mutually exclude with get_stats_load() */
Index: kernel/test/atomic/atomic1.c
===================================================================
--- kernel/test/atomic/atomic1.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/test/atomic/atomic1.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -37,26 +37,26 @@
 
 	atomic_set(&a, 10);
-	if (atomic_get(&a) != 10)
-		return "Failed atomic_set()/atomic_get()";
+	if (atomic_load(&a) != 10)
+		return "Failed atomic_set()/atomic_load()";
 
 	if (atomic_postinc(&a) != 10)
 		return "Failed atomic_postinc()";
-	if (atomic_get(&a) != 11)
-		return "Failed atomic_get() after atomic_postinc()";
+	if (atomic_load(&a) != 11)
+		return "Failed atomic_load() after atomic_postinc()";
 
 	if (atomic_postdec(&a) != 11)
 		return "Failed atomic_postdec()";
-	if (atomic_get(&a) != 10)
-		return "Failed atomic_get() after atomic_postdec()";
+	if (atomic_load(&a) != 10)
+		return "Failed atomic_load() after atomic_postdec()";
 
 	if (atomic_preinc(&a) != 11)
 		return "Failed atomic_preinc()";
-	if (atomic_get(&a) != 11)
-		return "Failed atomic_get() after atomic_preinc()";
+	if (atomic_load(&a) != 11)
+		return "Failed atomic_load() after atomic_preinc()";
 
 	if (atomic_predec(&a) != 10)
 		return "Failed atomic_predec()";
-	if (atomic_get(&a) != 10)
-		return "Failed atomic_get() after atomic_predec()";
+	if (atomic_load(&a) != 10)
+		return "Failed atomic_load() after atomic_predec()";
 
 	return NULL;
Index: kernel/test/mm/falloc2.c
===================================================================
--- kernel/test/mm/falloc2.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/test/mm/falloc2.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -130,11 +130,11 @@
 	}
 
-	while (atomic_get(&thread_count) > 0) {
+	while (atomic_load(&thread_count) > 0) {
 		TPRINTF("Threads left: %zu\n",
-		    atomic_get(&thread_count));
+		    atomic_load(&thread_count));
 		thread_sleep(1);
 	}
 
-	if (atomic_get(&thread_fail) == 0)
+	if (atomic_load(&thread_fail) == 0)
 		return NULL;
 
Index: kernel/test/synch/rcu1.c
===================================================================
--- kernel/test/synch/rcu1.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/test/synch/rcu1.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -282,5 +282,5 @@
 	size_t loop_cnt = 0, max_loops = 15;
 
-	while (exp_cnt != atomic_get(&nop_callbacks_cnt) && loop_cnt < max_loops) {
+	while (exp_cnt != atomic_load(&nop_callbacks_cnt) && loop_cnt < max_loops) {
 		++loop_cnt;
 		TPRINTF(".");
@@ -840,5 +840,5 @@
 	rcu_barrier();
 
-	if (1 == atomic_get(&barrier->done)) {
+	if (1 == atomic_load(&barrier->done)) {
 		free(barrier);
 		return true;
Index: kernel/test/synch/workq-test-core.h
===================================================================
--- kernel/test/synch/workq-test-core.h	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/test/synch/workq-test-core.h	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -179,5 +179,5 @@
 
 	for (int i = 0; i < WAVES; ++i) {
-		while (atomic_get(&call_cnt[i]) < exp_call_cnt &&
+		while (atomic_load(&call_cnt[i]) < exp_call_cnt &&
 		    sleep_cnt < max_sleep_cnt) {
 			TPRINTF(".");
@@ -190,11 +190,11 @@
 
 	for (int i = 0; i < WAVES; ++i) {
-		if (atomic_get(&call_cnt[i]) == exp_call_cnt) {
+		if (atomic_load(&call_cnt[i]) == exp_call_cnt) {
 			TPRINTF("Ok: %zu calls in wave %d, as expected.\n",
-			    atomic_get(&call_cnt[i]), i);
+			    atomic_load(&call_cnt[i]), i);
 		} else {
 			success = false;
 			TPRINTF("Error: %zu calls in wave %d, but %zu expected.\n",
-			    atomic_get(&call_cnt[i]), i, exp_call_cnt);
+			    atomic_load(&call_cnt[i]), i, exp_call_cnt);
 		}
 	}
Index: kernel/test/thread/thread1.c
===================================================================
--- kernel/test/thread/thread1.c	(revision e9d2905d090ff2994c1a8f2d7b4d0d4387d60ef7)
+++ kernel/test/thread/thread1.c	(revision 036e97cf14fc9f9a4783fbb16419e5aaf0793b2d)
@@ -46,5 +46,5 @@
 	thread_detach(THREAD);
 
-	while (atomic_get(&finish)) {
+	while (atomic_load(&finish)) {
 		TPRINTF("%" PRIu64 " ", THREAD->tid);
 		thread_usleep(100000);
@@ -76,6 +76,6 @@
 
 	atomic_set(&finish, 0);
-	while (atomic_get(&threads_finished) < total) {
-		TPRINTF("Threads left: %zu\n", total - atomic_get(&threads_finished));
+	while (atomic_load(&threads_finished) < total) {
+		TPRINTF("Threads left: %zu\n", total - atomic_load(&threads_finished));
 		thread_sleep(1);
 	}