Make task_sleep an intrinsic.

9 files changed, 189 insertions, 134 deletions

diff --git a/src/etc/gen-intrinsics b/src/etc/gen-intrinsics
index 45fd5482f4a..757df61596c 100755
--- a/src/etc/gen-intrinsics
+++ b/src/etc/gen-intrinsics
@@ -6,14 +6,21 @@
 
 for ARCH in i386 x86_64
 do
-    clang++ -emit-llvm -S -arch $ARCH -O3 -Isrc/rt/isaac -Isrc/rt/uthash \
+    if [ $ARCH = "i386" ]
+    then
+	BITS=32
+    else
+	BITS=64
+    fi
+
+    clang++ -emit-llvm -S -m$BITS -O3 -Isrc/rt/isaac -Isrc/rt/uthash \
         -Isrc/rt/arch/$ARCH -fno-stack-protector \
         -o src/rt/intrinsics/intrinsics.$ARCH.ll.in \
         src/rt/intrinsics/intrinsics.cpp
-    sed -i "" \
+    sed -i \
         -e 's/^target datalayout =/; target datalayout =/' \
         src/rt/intrinsics/intrinsics.$ARCH.ll.in
-    sed -i "" \
+    sed -i \
         -e 's/^target triple = "[^"]*"/target triple = "@CFG_TARGET_TRIPLE@"/' \
         src/rt/intrinsics/intrinsics.$ARCH.ll.in
 done
\ No newline at end of file
diff --git a/src/lib/task.rs b/src/lib/task.rs
index 1b225ceecf1..a9d6ae270da 100644
--- a/src/lib/task.rs
+++ b/src/lib/task.rs
@@ -50,7 +50,7 @@ export spawn;
 export spawn_notify;
 export spawn_joinable;
 
-native "cdecl" mod rustrt {
+native "rust-intrinsic" mod rustrt {
     // these must run on the Rust stack so that they can swap stacks etc:
     fn task_sleep(time_in_us: uint);
 }
diff --git a/src/rt/intrinsics/intrinsics.cpp b/src/rt/intrinsics/intrinsics.cpp
index 2d53f170e00..9e39a0a15a4 100644
--- a/src/rt/intrinsics/intrinsics.cpp
+++ b/src/rt/intrinsics/intrinsics.cpp
@@ -9,6 +9,12 @@
 extern "C" CDECL void
 upcall_fail(char const *expr, char const *file, size_t line);
 
+extern "C" CDECL void
+port_recv(uintptr_t *dptr, rust_port *port);
+
+extern "C" CDECL void
+rust_task_sleep(size_t time_in_us);
+
 extern "C" void
 rust_intrinsic_vec_len(rust_task *task, size_t *retptr, type_desc *ty,
                        rust_vec **vp)
@@ -54,3 +60,8 @@ rust_intrinsic_get_type_desc(rust_task *task, void **retptr,
     *(type_desc**)retptr = ty;
 }
 
+extern "C" void
+rust_intrinsic_task_sleep(rust_task *_task, void **retptr,
+			  size_t time_in_us) {
+  rust_task_sleep(time_in_us);
+}
diff --git a/src/rt/intrinsics/intrinsics.i386.ll.in b/src/rt/intrinsics/intrinsics.i386.ll.in
index 971314dba56..f62ad352ee6 100644
--- a/src/rt/intrinsics/intrinsics.i386.ll.in
+++ b/src/rt/intrinsics/intrinsics.i386.ll.in
@@ -1,93 +1,99 @@
 ; ModuleID = 'src/rt/intrinsics/intrinsics.cpp'
-; target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
+; target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128"
 target triple = "@CFG_TARGET_TRIPLE@"
 
-%0 = type { i32, %"struct.memory_region::alloc_header"**, i32 }
-%1 = type { i32, %struct.rust_scheduler**, i32 }
-%2 = type { %"struct.hash_map<long, rust_task *>::map_entry"* }
-%3 = type { %struct.rust_task*, i32, i32, %class.rust_chan** }
-%class.array_list = type { i32, %struct.rust_task**, i32 }
-%class.circular_buffer = type { %class.rust_kernel*, i32, i32, i32, i32, i8* }
+%struct.rust_task = type { %struct.rust_task_user, i32, %class.context, %struct.stk_seg*, i32, %struct.rust_scheduler*, %class.rust_crate_cache*, %class.rust_kernel*, i8*, %class.rust_task_list*, %struct.rust_cond*, i8*, %struct.rust_task*, i32, i32, %class.timer, i32*, %class.array_list.1, i32, i32, %class.memory_region, %"class.rust_task::wakeup_callback"*, i8, i8, i8, %class.lock_and_signal, %class.hash_map.4, %class.rust_obstack, %"class.std::map", i32, %"class.debug::task_debug_info" }
+%struct.rust_task_user = type { i32, i32, %struct.chan_handle, i32 }
+%struct.chan_handle = type { i32, i32 }
 %class.context = type { %struct.registers_t, %class.context* }
-%"class.debug::task_debug_info" = type { %"class.std::map" }
-%class.hash_map = type { %"struct.hash_map<long, rust_port *>::map_entry"* }
-%class.indexed_list = type { i32 (...)**, %class.array_list }
-%class.lock_and_signal = type { i32 (...)**, %struct._opaque_pthread_cond_t, %struct._opaque_pthread_mutex_t, %struct._opaque_pthread_t*, i8, i8 }
-%class.memory_region = type { i32 (...)**, %class.rust_srv*, %class.memory_region*, i32, %0, i8, i8, %class.lock_and_signal }
-%class.ptr_vec = type { %struct.rust_task*, i32, i32, %struct.rust_token** }
-%class.rust_chan = type { i32, %class.rust_kernel*, %struct.rust_task*, %class.rust_port*, i32, %class.circular_buffer }
-%class.rust_crate_cache = type { %struct.type_desc*, %struct.rust_scheduler*, i32 }
-%class.rust_kernel = type { i32 (...)**, %class.memory_region, %class.rust_log, %class.rust_srv*, %class.lock_and_signal, %1, %struct.randctx, i32, %2, i32, i32, i32, %struct.rust_env* }
+%struct.registers_t = type { i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i16, i16, i32, i32 }
+%struct.stk_seg = type { %struct.stk_seg*, i32, i32, i32, [0 x i8] }
+%struct.rust_scheduler = type { %class.rust_thread, i32, i32, %class.rust_log, i32, %class.rust_srv*, i8*, %class.rust_task_list, %class.rust_task_list, %class.rust_task_list, %class.rust_task_list, %class.rust_crate_cache, %struct.randctx, %class.rust_kernel*, i32, i32, %class.lock_and_signal, i32, %union.pthread_attr_t, %struct.rust_env*, %class.context }
+%class.rust_thread = type { i32 (...)**, i8, i32 }
 %class.rust_log = type { i32 (...)**, %class.rust_srv*, %struct.rust_scheduler*, i8 }
-%class.rust_obstack = type { %struct.rust_obstack_chunk*, %struct.rust_task* }
-%class.rust_port = type { i32, i32, %class.rust_kernel*, %struct.rust_task*, %class.rust_chan*, i32, %class.ptr_vec, %3, %class.lock_and_signal }
 %class.rust_srv = type { i32 (...)**, %struct.rust_env*, %class.memory_region }
-%"class.rust_task::wakeup_callback" = type { i32 (...)** }
+%struct.rust_env = type { i32, i32, i8*, i8, i8, i8* }
+%class.memory_region = type { i32 (...)**, %class.rust_srv*, %class.memory_region*, i32, %class.array_list, i8, i8, %class.lock_and_signal }
+%class.array_list = type { i32, %"struct.memory_region::alloc_header"**, i32 }
+%"struct.memory_region::alloc_header" = type { i32, i32, i8*, i32, [0 x i8] }
+%class.lock_and_signal = type { i32 (...)**, %union.pthread_cond_t, %union.pthread_mutex_t, i32, i8, i8 }
+%union.pthread_cond_t = type { %struct.anon, [4 x i8] }
+%struct.anon = type { i32, i32, i64, i64, i64, i8*, i32, i32 }
+%union.pthread_mutex_t = type { %"struct.<anonymous union>::__pthread_mutex_s" }
+%"struct.<anonymous union>::__pthread_mutex_s" = type { i32, i32, i32, i32, i32, %union.anon }
+%union.anon = type { i32 }
 %class.rust_task_list = type { %class.indexed_list, %struct.rust_scheduler*, i8* }
-%class.rust_thread = type { i32 (...)**, i8, %struct._opaque_pthread_t* }
-%"class.std::_Rb_tree" = type { %"struct.std::_Rb_tree<void *, std::pair<void *const, const type_desc *>, std::_Select1st<std::pair<void *const, const type_desc *> >, std::less<void *>, std::allocator<std::pair<void *const, const type_desc *> > >::_Rb_tree_impl" }
-%"class.std::map" = type { %"class.std::_Rb_tree" }
-%class.timer = type { i32 (...)**, i64, i64 }
-%struct.UT_hash_bucket = type { %struct.UT_hash_handle*, i32, i32 }
+%class.indexed_list = type { i32 (...)**, %class.array_list.1 }
+%class.array_list.1 = type { i32, %struct.rust_task**, i32 }
+%class.rust_crate_cache = type { %struct.type_desc*, %struct.rust_scheduler*, i32 }
+%struct.type_desc = type { %struct.type_desc**, i32, i32, void (i8*, i8*, %struct.type_desc**, i8*)*, void (i8*, i8*, %struct.type_desc**, i8*)*, void (i8*, i8*, %struct.type_desc**, i8*)*, i8*, void (i8*, i8*, %struct.type_desc**, i8*)*, void (i8*, i8*, %struct.type_desc**, i8*)*, i32, void (i8*, i8*, %struct.type_desc**, i8*, i8*, i8)*, i8*, %struct.rust_shape_tables*, i32, i32, %struct.UT_hash_handle, i32, [0 x %struct.type_desc*] }
+%struct.rust_shape_tables = type { i8*, i8* }
 %struct.UT_hash_handle = type { %struct.UT_hash_table*, i8*, i8*, %struct.UT_hash_handle*, %struct.UT_hash_handle*, i8*, i32, i32 }
 %struct.UT_hash_table = type { %struct.UT_hash_bucket*, i32, i32, i32, %struct.UT_hash_handle*, i32, i32, i32, i32, i32 }
-%struct.__darwin_pthread_handler_rec = type { void (i8*)*, i8*, %struct.__darwin_pthread_handler_rec* }
-%struct._opaque_pthread_attr_t = type { i32, [36 x i8] }
-%struct._opaque_pthread_cond_t = type { i32, [24 x i8] }
-%struct._opaque_pthread_mutex_t = type { i32, [40 x i8] }
-%struct._opaque_pthread_t = type { i32, %struct.__darwin_pthread_handler_rec*, [596 x i8] }
-%struct.chan_handle = type { i32, i32 }
-%"struct.hash_map<long, rust_port *>::map_entry" = type opaque
-%"struct.hash_map<long, rust_task *>::map_entry" = type opaque
-%"struct.memory_region::alloc_header" = type { i32, i32, i8*, i32, [0 x i8] }
+%struct.UT_hash_bucket = type { %struct.UT_hash_handle*, i32, i32 }
 %struct.randctx = type { i32, [256 x i32], [256 x i32], i32, i32, i32 }
-%struct.registers_t = type { i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i16, i16, i32, i32 }
+%class.rust_kernel = type { i32 (...)**, %class.memory_region, %class.rust_log, %class.rust_srv*, %class.lock_and_signal, %class.array_list.3, %struct.randctx, i32, %class.hash_map, i32, i32, i32, %struct.rust_env* }
+%class.array_list.3 = type { i32, %struct.rust_scheduler**, i32 }
+%class.hash_map = type { %"struct.hash_map<int, rust_task *>::map_entry"* }
+%"struct.hash_map<int, rust_task *>::map_entry" = type opaque
+%union.pthread_attr_t = type { i32, [32 x i8] }
 %struct.rust_cond = type { i8 }
-%struct.rust_env = type { i32, i32, i8*, i8, i8, i8* }
+%class.timer = type { i32 (...)**, i64, i64 }
+%"class.rust_task::wakeup_callback" = type { i32 (...)** }
+%class.hash_map.4 = type { %"struct.hash_map<int, rust_port *>::map_entry"* }
+%"struct.hash_map<int, rust_port *>::map_entry" = type opaque
+%class.rust_obstack = type { %struct.rust_obstack_chunk*, %struct.rust_task* }
 %struct.rust_obstack_chunk = type { %struct.rust_obstack_chunk*, i32, i32, i32, [0 x i8] }
-%struct.rust_scheduler = type { %class.rust_thread, i32, i32, %class.rust_log, i32, %class.rust_srv*, i8*, %class.rust_task_list, %class.rust_task_list, %class.rust_task_list, %class.rust_task_list, %class.rust_crate_cache, %struct.randctx, %class.rust_kernel*, i32, i32, %class.lock_and_signal, i32, %struct._opaque_pthread_attr_t, %struct.rust_env*, %class.context }
-%struct.rust_shape_tables = type { i8*, i8* }
-%struct.rust_task = type { %struct.rust_task_user, i32, %class.context, %struct.rust_vec*, i32, %struct.rust_scheduler*, %class.rust_crate_cache*, %class.rust_kernel*, i8*, %class.rust_task_list*, %struct.rust_cond*, i8*, %struct.rust_task*, i32, i32, %class.timer, i32*, %class.array_list, i32, i32, %class.memory_region, %"class.rust_task::wakeup_callback"*, i8, i8, i8, %class.lock_and_signal, %class.hash_map, %class.rust_obstack, %"class.std::map", i32, %"class.debug::task_debug_info" }
-%struct.rust_task_user = type { i32, i32, %struct.chan_handle, i32 }
-%struct.rust_token = type opaque
-%struct.rust_vec = type { i32, i32, [0 x i8] }
-%"struct.std::_Rb_tree<void *, std::pair<void *const, const type_desc *>, std::_Select1st<std::pair<void *const, const type_desc *> >, std::less<void *>, std::allocator<std::pair<void *const, const type_desc *> > >::_Rb_tree_impl" = type { %struct.rust_cond, %"struct.std::_Rb_tree_node_base", i32 }
+%"class.std::map" = type { %"class.std::_Rb_tree" }
+%"class.std::_Rb_tree" = type { %"struct.std::_Rb_tree<void *, std::pair<void *const, const type_desc *>, std::_Select1st<std::pair<void *const, const type_desc *> >, std::less<void *>, std::allocator<std::pair<void *const, const type_desc *> > >::_Rb_tree_impl" }
+%"struct.std::_Rb_tree<void *, std::pair<void *const, const type_desc *>, std::_Select1st<std::pair<void *const, const type_desc *> >, std::less<void *>, std::allocator<std::pair<void *const, const type_desc *> > >::_Rb_tree_impl" = type { %"struct.std::less", %"struct.std::_Rb_tree_node_base", i32 }
+%"struct.std::less" = type { i8 }
 %"struct.std::_Rb_tree_node_base" = type { i32, %"struct.std::_Rb_tree_node_base"*, %"struct.std::_Rb_tree_node_base"*, %"struct.std::_Rb_tree_node_base"* }
-%struct.type_desc = type { %struct.type_desc**, i32, i32, void (i8*, i8*, %struct.type_desc**, i8*)*, void (i8*, i8*, %struct.type_desc**, i8*)*, void (i8*, i8*, %struct.type_desc**, i8*)*, i8*, void (i8*, i8*, %struct.type_desc**, i8*)*, void (i8*, i8*, %struct.type_desc**, i8*)*, i32, void (i8*, i8*, %struct.type_desc**, i8*, i8*, i8)*, i8*, %struct.rust_shape_tables*, i32, i32, %struct.UT_hash_handle, i32, [0 x %struct.type_desc*] }
+%"class.debug::task_debug_info" = type { %"class.std::map.5" }
+%"class.std::map.5" = type { %"class.std::_Rb_tree.6" }
+%"class.std::_Rb_tree.6" = type { %"struct.std::_Rb_tree<void *, std::pair<void *const, std::basic_string<char> >, std::_Select1st<std::pair<void *const, std::basic_string<char> > >, std::less<void *>, std::allocator<std::pair<void *const, std::basic_string<char> > > >::_Rb_tree_impl" }
+%"struct.std::_Rb_tree<void *, std::pair<void *const, std::basic_string<char> >, std::_Select1st<std::pair<void *const, std::basic_string<char> > >, std::less<void *>, std::allocator<std::pair<void *const, std::basic_string<char> > > >::_Rb_tree_impl" = type { %"struct.std::less", %"struct.std::_Rb_tree_node_base", i32 }
+%struct.rust_vec = type { i32, i32, [0 x i8] }
+%class.rust_port = type { i32, i32, %class.rust_kernel*, %struct.rust_task*, %class.rust_chan*, i32, %class.ptr_vec, %class.ptr_vec.13, %class.lock_and_signal }
+%class.rust_chan = type { i32, %class.rust_kernel*, %struct.rust_task*, %class.rust_port*, i32, %class.circular_buffer }
+%class.circular_buffer = type { %class.rust_kernel*, i32, i32, i32, i32, i8* }
+%class.ptr_vec = type { %struct.rust_task*, i32, i32, %struct.rust_token** }
+%struct.rust_token = type opaque
+%class.ptr_vec.13 = type { %struct.rust_task*, i32, i32, %class.rust_chan** }
 
-@.str = private unnamed_addr constant [42 x i8] c"attempt to cast values of differing sizes\00"
-@.str1 = private unnamed_addr constant [33 x i8] c"src/rt/intrinsics/intrinsics.cpp\00"
+@.str = private unnamed_addr constant [42 x i8] c"attempt to cast values of differing sizes\00", align 1
+@.str1 = private unnamed_addr constant [33 x i8] c"src/rt/intrinsics/intrinsics.cpp\00", align 1
 
 define void @rust_intrinsic_vec_len(%struct.rust_task* nocapture %task, i32* nocapture %retptr, %struct.type_desc* nocapture %ty, %struct.rust_vec** nocapture %vp) nounwind {
-  %1 = load %struct.rust_vec** %vp, align 4
+  %1 = load %struct.rust_vec** %vp, align 4, !tbaa !0
   %2 = getelementptr inbounds %struct.rust_vec* %1, i32 0, i32 0
-  %3 = load i32* %2, align 4
+  %3 = load i32* %2, align 4, !tbaa !3
   %4 = getelementptr inbounds %struct.type_desc* %ty, i32 0, i32 1
-  %5 = load i32* %4, align 4
+  %5 = load i32* %4, align 4, !tbaa !3
   %6 = udiv i32 %3, %5
-  store i32 %6, i32* %retptr, align 4
+  store i32 %6, i32* %retptr, align 4, !tbaa !3
   ret void
 }
 
 define void @rust_intrinsic_ptr_offset(%struct.rust_task* nocapture %task, i8** nocapture %retptr, %struct.type_desc* nocapture %ty, i8* %ptr, i32 %count) nounwind {
   %1 = getelementptr inbounds %struct.type_desc* %ty, i32 0, i32 1
-  %2 = load i32* %1, align 4
+  %2 = load i32* %1, align 4, !tbaa !3
   %3 = mul i32 %2, %count
   %4 = getelementptr inbounds i8* %ptr, i32 %3
-  store i8* %4, i8** %retptr, align 4
+  store i8* %4, i8** %retptr, align 4, !tbaa !0
   ret void
 }
 
 define void @rust_intrinsic_cast(%struct.rust_task* nocapture %task, i8* nocapture %retptr, %struct.type_desc* nocapture %t1, %struct.type_desc* nocapture %t2, i8* nocapture %src) {
   %1 = getelementptr inbounds %struct.type_desc* %t1, i32 0, i32 1
-  %2 = load i32* %1, align 4
+  %2 = load i32* %1, align 4, !tbaa !3
   %3 = getelementptr inbounds %struct.type_desc* %t2, i32 0, i32 1
-  %4 = load i32* %3, align 4
+  %4 = load i32* %3, align 4, !tbaa !3
   %5 = icmp eq i32 %2, %4
   br i1 %5, label %7, label %6
 
 ; <label>:6                                       ; preds = %0
-  tail call void @upcall_fail(i8* getelementptr inbounds ([42 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([33 x i8]* @.str1, i32 0, i32 0), i32 32)
+  tail call void @upcall_fail(i8* getelementptr inbounds ([42 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([33 x i8]* @.str1, i32 0, i32 0), i32 38)
   br label %8
 
 ; <label>:7                                       ; preds = %0
@@ -103,7 +109,7 @@ declare void @upcall_fail(i8*, i8*, i32)
 declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
 
 define void @rust_intrinsic_addr_of(%struct.rust_task* nocapture %task, i8** nocapture %retptr, %struct.type_desc* nocapture %ty, i8* %valptr) nounwind {
-  store i8* %valptr, i8** %retptr, align 4
+  store i8* %valptr, i8** %retptr, align 4, !tbaa !0
   ret void
 }
 
@@ -117,6 +123,18 @@ declare void @port_recv(i32*, %class.rust_port*)
 
 define void @rust_intrinsic_get_type_desc(%struct.rust_task* nocapture %task, i8** nocapture %retptr, %struct.type_desc* %ty) nounwind {
   %ty.c = bitcast %struct.type_desc* %ty to i8*
-  store i8* %ty.c, i8** %retptr, align 4
+  store i8* %ty.c, i8** %retptr, align 4, !tbaa !0
   ret void
 }
+
+define void @rust_intrinsic_task_sleep(%struct.rust_task* nocapture %_task, i8** nocapture %retptr, i32 %time_in_us) {
+  tail call void @rust_task_sleep(i32 %time_in_us)
+  ret void
+}
+
+declare void @rust_task_sleep(i32)
+
+!0 = metadata !{metadata !"any pointer", metadata !1}
+!1 = metadata !{metadata !"omnipotent char", metadata !2}
+!2 = metadata !{metadata !"Simple C/C++ TBAA", null}
+!3 = metadata !{metadata !"int", metadata !1}
diff --git a/src/rt/intrinsics/intrinsics.x86_64.ll.in b/src/rt/intrinsics/intrinsics.x86_64.ll.in
index 77c05e1e1e5..a99870bc221 100644
--- a/src/rt/intrinsics/intrinsics.x86_64.ll.in
+++ b/src/rt/intrinsics/intrinsics.x86_64.ll.in
@@ -1,93 +1,99 @@
 ; ModuleID = 'src/rt/intrinsics/intrinsics.cpp'
-; target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
+; target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "@CFG_TARGET_TRIPLE@"
 
-%0 = type { i64, %"struct.memory_region::alloc_header"**, i64 }
-%1 = type { i64, %struct.rust_scheduler**, i64 }
-%2 = type { %"struct.hash_map<long, rust_task *>::map_entry"* }
-%3 = type { %struct.rust_task*, i64, i64, %class.rust_chan** }
-%class.array_list = type { i64, %struct.rust_task**, i64 }
-%class.circular_buffer = type { %class.rust_kernel*, i64, i64, i64, i64, i8* }
+%struct.rust_task = type { %struct.rust_task_user, i64, %class.context, %struct.stk_seg*, i64, %struct.rust_scheduler*, %class.rust_crate_cache*, %class.rust_kernel*, i8*, %class.rust_task_list*, %struct.rust_cond*, i8*, %struct.rust_task*, i32, i64, %class.timer, i64*, %class.array_list.1, i32, i32, %class.memory_region, %"class.rust_task::wakeup_callback"*, i8, i8, i8, %class.lock_and_signal, %class.hash_map.4, %class.rust_obstack, %"class.std::map", i32, %"class.debug::task_debug_info" }
+%struct.rust_task_user = type { i64, i32, %struct.chan_handle, i64 }
+%struct.chan_handle = type { i64, i64 }
 %class.context = type { %struct.registers_t, %class.context* }
-%"class.debug::task_debug_info" = type { %"class.std::map" }
-%class.hash_map = type { %"struct.hash_map<long, rust_port *>::map_entry"* }
-%class.indexed_list = type { i32 (...)**, %class.array_list }
-%class.lock_and_signal = type { i32 (...)**, %struct._opaque_pthread_cond_t, %struct._opaque_pthread_attr_t, %struct._opaque_pthread_t*, i8, i8 }
-%class.memory_region = type { i32 (...)**, %class.rust_srv*, %class.memory_region*, i32, %0, i8, i8, %class.lock_and_signal }
-%class.ptr_vec = type { %struct.rust_task*, i64, i64, %struct.rust_token** }
-%class.rust_chan = type { i64, %class.rust_kernel*, %struct.rust_task*, %class.rust_port*, i64, %class.circular_buffer }
-%class.rust_crate_cache = type { %struct.type_desc*, %struct.rust_scheduler*, i64 }
-%class.rust_kernel = type { i32 (...)**, %class.memory_region, %class.rust_log, %class.rust_srv*, %class.lock_and_signal, %1, %struct.randctx, i64, %2, i64, i32, i32, %struct.rust_env* }
+%struct.registers_t = type { [7 x i64], [6 x i64], i64 }
+%struct.stk_seg = type { %struct.stk_seg*, i64, i32, [0 x i8] }
+%struct.rust_scheduler = type { %class.rust_thread, i64, i64, %class.rust_log, i32, %class.rust_srv*, i8*, %class.rust_task_list, %class.rust_task_list, %class.rust_task_list, %class.rust_task_list, %class.rust_crate_cache, %struct.randctx, %class.rust_kernel*, i32, i32, %class.lock_and_signal, i64, %union.pthread_attr_t, %struct.rust_env*, %class.context }
+%class.rust_thread = type { i32 (...)**, i8, i64 }
 %class.rust_log = type { i32 (...)**, %class.rust_srv*, %struct.rust_scheduler*, i8 }
-%class.rust_obstack = type { %struct.rust_obstack_chunk*, %struct.rust_task* }
-%class.rust_port = type { i64, i64, %class.rust_kernel*, %struct.rust_task*, %class.rust_chan*, i64, %class.ptr_vec, %3, %class.lock_and_signal }
 %class.rust_srv = type { i32 (...)**, %struct.rust_env*, %class.memory_region }
-%"class.rust_task::wakeup_callback" = type { i32 (...)** }
+%struct.rust_env = type { i64, i64, i8*, i8, i8, i8* }
+%class.memory_region = type { i32 (...)**, %class.rust_srv*, %class.memory_region*, i32, %class.array_list, i8, i8, %class.lock_and_signal }
+%class.array_list = type { i64, %"struct.memory_region::alloc_header"**, i64 }
+%"struct.memory_region::alloc_header" = type { i32, i32, i8*, i32, [0 x i8] }
+%class.lock_and_signal = type { i32 (...)**, %union.pthread_cond_t, %union.pthread_mutex_t, i64, i8, i8 }
+%union.pthread_cond_t = type { %struct.anon }
+%struct.anon = type { i32, i32, i64, i64, i64, i8*, i32, i32 }
+%union.pthread_mutex_t = type { %"struct.<anonymous union>::__pthread_mutex_s" }
+%"struct.<anonymous union>::__pthread_mutex_s" = type { i32, i32, i32, i32, i32, i32, %struct.__pthread_internal_list }
+%struct.__pthread_internal_list = type { %struct.__pthread_internal_list*, %struct.__pthread_internal_list* }
 %class.rust_task_list = type { %class.indexed_list, %struct.rust_scheduler*, i8* }
-%class.rust_thread = type { i32 (...)**, i8, %struct._opaque_pthread_t* }
-%"class.std::_Rb_tree" = type { %"struct.std::_Rb_tree<void *, std::pair<void *const, const type_desc *>, std::_Select1st<std::pair<void *const, const type_desc *> >, std::less<void *>, std::allocator<std::pair<void *const, const type_desc *> > >::_Rb_tree_impl" }
-%"class.std::map" = type { %"class.std::_Rb_tree" }
-%class.timer = type { i32 (...)**, i64, i64 }
-%struct.UT_hash_bucket = type { %struct.UT_hash_handle*, i32, i32 }
+%class.indexed_list = type { i32 (...)**, %class.array_list.1 }
+%class.array_list.1 = type { i64, %struct.rust_task**, i64 }
+%class.rust_crate_cache = type { %struct.type_desc*, %struct.rust_scheduler*, i64 }
+%struct.type_desc = type { %struct.type_desc**, i64, i64, void (i8*, i8*, %struct.type_desc**, i8*)*, void (i8*, i8*, %struct.type_desc**, i8*)*, void (i8*, i8*, %struct.type_desc**, i8*)*, i8*, void (i8*, i8*, %struct.type_desc**, i8*)*, void (i8*, i8*, %struct.type_desc**, i8*)*, i64, void (i8*, i8*, %struct.type_desc**, i8*, i8*, i8)*, i8*, %struct.rust_shape_tables*, i64, i64, %struct.UT_hash_handle, i64, [0 x %struct.type_desc*] }
+%struct.rust_shape_tables = type { i8*, i8* }
 %struct.UT_hash_handle = type { %struct.UT_hash_table*, i8*, i8*, %struct.UT_hash_handle*, %struct.UT_hash_handle*, i8*, i32, i32 }
 %struct.UT_hash_table = type { %struct.UT_hash_bucket*, i32, i32, i32, %struct.UT_hash_handle*, i64, i32, i32, i32, i32 }
-%struct.__darwin_pthread_handler_rec = type { void (i8*)*, i8*, %struct.__darwin_pthread_handler_rec* }
-%struct._opaque_pthread_attr_t = type { i64, [56 x i8] }
-%struct._opaque_pthread_cond_t = type { i64, [40 x i8] }
-%struct._opaque_pthread_t = type { i64, %struct.__darwin_pthread_handler_rec*, [1168 x i8] }
-%struct.chan_handle = type { i64, i64 }
-%"struct.hash_map<long, rust_port *>::map_entry" = type opaque
-%"struct.hash_map<long, rust_task *>::map_entry" = type opaque
-%"struct.memory_region::alloc_header" = type { i32, i32, i8*, i32, [0 x i8] }
+%struct.UT_hash_bucket = type { %struct.UT_hash_handle*, i32, i32 }
 %struct.randctx = type { i64, [256 x i64], [256 x i64], i64, i64, i64 }
-%struct.registers_t = type { [7 x i64], [6 x i64], i64 }
+%class.rust_kernel = type { i32 (...)**, %class.memory_region, %class.rust_log, %class.rust_srv*, %class.lock_and_signal, %class.array_list.3, %struct.randctx, i64, %class.hash_map, i64, i32, i32, %struct.rust_env* }
+%class.array_list.3 = type { i64, %struct.rust_scheduler**, i64 }
+%class.hash_map = type { %"struct.hash_map<long, rust_task *>::map_entry"* }
+%"struct.hash_map<long, rust_task *>::map_entry" = type opaque
+%union.pthread_attr_t = type { i64, [48 x i8] }
 %struct.rust_cond = type { i8 }
-%struct.rust_env = type { i64, i64, i8*, i8, i8, i8* }
+%class.timer = type { i32 (...)**, i64, i64 }
+%"class.rust_task::wakeup_callback" = type { i32 (...)** }
+%class.hash_map.4 = type { %"struct.hash_map<long, rust_port *>::map_entry"* }
+%"struct.hash_map<long, rust_port *>::map_entry" = type opaque
+%class.rust_obstack = type { %struct.rust_obstack_chunk*, %struct.rust_task* }
 %struct.rust_obstack_chunk = type { %struct.rust_obstack_chunk*, i64, i64, i64, [0 x i8] }
-%struct.rust_scheduler = type { %class.rust_thread, i64, i64, %class.rust_log, i32, %class.rust_srv*, i8*, %class.rust_task_list, %class.rust_task_list, %class.rust_task_list, %class.rust_task_list, %class.rust_crate_cache, %struct.randctx, %class.rust_kernel*, i32, i32, %class.lock_and_signal, i64, %struct._opaque_pthread_attr_t, %struct.rust_env*, %class.context }
-%struct.rust_shape_tables = type { i8*, i8* }
-%struct.rust_task = type { %struct.rust_task_user, i64, %class.context, %struct.stk_seg*, i64, %struct.rust_scheduler*, %class.rust_crate_cache*, %class.rust_kernel*, i8*, %class.rust_task_list*, %struct.rust_cond*, i8*, %struct.rust_task*, i32, i64, %class.timer, i64*, %class.array_list, i32, i32, %class.memory_region, %"class.rust_task::wakeup_callback"*, i8, i8, i8, %class.lock_and_signal, %class.hash_map, %class.rust_obstack, %"class.std::map", i32, %"class.debug::task_debug_info" }
-%struct.rust_task_user = type { i64, i32, %struct.chan_handle, i64 }
-%struct.rust_token = type opaque
-%struct.rust_vec = type { i64, i64, [0 x i8] }
-%"struct.std::_Rb_tree<void *, std::pair<void *const, const type_desc *>, std::_Select1st<std::pair<void *const, const type_desc *> >, std::less<void *>, std::allocator<std::pair<void *const, const type_desc *> > >::_Rb_tree_impl" = type { %struct.rust_cond, %"struct.std::_Rb_tree_node_base", i64 }
+%"class.std::map" = type { %"class.std::_Rb_tree" }
+%"class.std::_Rb_tree" = type { %"struct.std::_Rb_tree<void *, std::pair<void *const, const type_desc *>, std::_Select1st<std::pair<void *const, const type_desc *> >, std::less<void *>, std::allocator<std::pair<void *const, const type_desc *> > >::_Rb_tree_impl" }
+%"struct.std::_Rb_tree<void *, std::pair<void *const, const type_desc *>, std::_Select1st<std::pair<void *const, const type_desc *> >, std::less<void *>, std::allocator<std::pair<void *const, const type_desc *> > >::_Rb_tree_impl" = type { %"struct.std::less", %"struct.std::_Rb_tree_node_base", i64 }
+%"struct.std::less" = type { i8 }
 %"struct.std::_Rb_tree_node_base" = type { i32, %"struct.std::_Rb_tree_node_base"*, %"struct.std::_Rb_tree_node_base"*, %"struct.std::_Rb_tree_node_base"* }
-%struct.stk_seg = type { i32, i64, [0 x i8] }
-%struct.type_desc = type { %struct.type_desc**, i64, i64, void (i8*, i8*, %struct.type_desc**, i8*)*, void (i8*, i8*, %struct.type_desc**, i8*)*, void (i8*, i8*, %struct.type_desc**, i8*)*, i8*, void (i8*, i8*, %struct.type_desc**, i8*)*, void (i8*, i8*, %struct.type_desc**, i8*)*, i64, void (i8*, i8*, %struct.type_desc**, i8*, i8*, i8)*, i8*, %struct.rust_shape_tables*, i64, i64, %struct.UT_hash_handle, i64, [0 x %struct.type_desc*] }
+%"class.debug::task_debug_info" = type { %"class.std::map.5" }
+%"class.std::map.5" = type { %"class.std::_Rb_tree.6" }
+%"class.std::_Rb_tree.6" = type { %"struct.std::_Rb_tree<void *, std::pair<void *const, std::basic_string<char> >, std::_Select1st<std::pair<void *const, std::basic_string<char> > >, std::less<void *>, std::allocator<std::pair<void *const, std::basic_string<char> > > >::_Rb_tree_impl" }
+%"struct.std::_Rb_tree<void *, std::pair<void *const, std::basic_string<char> >, std::_Select1st<std::pair<void *const, std::basic_string<char> > >, std::less<void *>, std::allocator<std::pair<void *const, std::basic_string<char> > > >::_Rb_tree_impl" = type { %"struct.std::less", %"struct.std::_Rb_tree_node_base", i64 }
+%struct.rust_vec = type { i64, i64, [0 x i8] }
+%class.rust_port = type { i64, i64, %class.rust_kernel*, %struct.rust_task*, %class.rust_chan*, i64, %class.ptr_vec, %class.ptr_vec.13, %class.lock_and_signal }
+%class.rust_chan = type { i64, %class.rust_kernel*, %struct.rust_task*, %class.rust_port*, i64, %class.circular_buffer }
+%class.circular_buffer = type { %class.rust_kernel*, i64, i64, i64, i64, i8* }
+%class.ptr_vec = type { %struct.rust_task*, i64, i64, %struct.rust_token** }
+%struct.rust_token = type opaque
+%class.ptr_vec.13 = type { %struct.rust_task*, i64, i64, %class.rust_chan** }
 
-@.str = private unnamed_addr constant [42 x i8] c"attempt to cast values of differing sizes\00"
-@.str1 = private unnamed_addr constant [33 x i8] c"src/rt/intrinsics/intrinsics.cpp\00"
+@.str = private unnamed_addr constant [42 x i8] c"attempt to cast values of differing sizes\00", align 1
+@.str1 = private unnamed_addr constant [33 x i8] c"src/rt/intrinsics/intrinsics.cpp\00", align 1
 
-define void @rust_intrinsic_vec_len(%struct.rust_task* nocapture %task, i64* nocapture %retptr, %struct.type_desc* nocapture %ty, %struct.rust_vec** nocapture %vp) nounwind {
-  %1 = load %struct.rust_vec** %vp, align 8
+define void @rust_intrinsic_vec_len(%struct.rust_task* nocapture %task, i64* nocapture %retptr, %struct.type_desc* nocapture %ty, %struct.rust_vec** nocapture %vp) nounwind uwtable {
+  %1 = load %struct.rust_vec** %vp, align 8, !tbaa !0
   %2 = getelementptr inbounds %struct.rust_vec* %1, i64 0, i32 0
-  %3 = load i64* %2, align 8
+  %3 = load i64* %2, align 8, !tbaa !3
   %4 = getelementptr inbounds %struct.type_desc* %ty, i64 0, i32 1
-  %5 = load i64* %4, align 8
+  %5 = load i64* %4, align 8, !tbaa !3
   %6 = udiv i64 %3, %5
-  store i64 %6, i64* %retptr, align 8
+  store i64 %6, i64* %retptr, align 8, !tbaa !3
   ret void
 }
 
-define void @rust_intrinsic_ptr_offset(%struct.rust_task* nocapture %task, i8** nocapture %retptr, %struct.type_desc* nocapture %ty, i8* %ptr, i64 %count) nounwind {
+define void @rust_intrinsic_ptr_offset(%struct.rust_task* nocapture %task, i8** nocapture %retptr, %struct.type_desc* nocapture %ty, i8* %ptr, i64 %count) nounwind uwtable {
   %1 = getelementptr inbounds %struct.type_desc* %ty, i64 0, i32 1
-  %2 = load i64* %1, align 8
+  %2 = load i64* %1, align 8, !tbaa !3
   %3 = mul i64 %2, %count
   %4 = getelementptr inbounds i8* %ptr, i64 %3
-  store i8* %4, i8** %retptr, align 8
+  store i8* %4, i8** %retptr, align 8, !tbaa !0
   ret void
 }
 
-define void @rust_intrinsic_cast(%struct.rust_task* nocapture %task, i8* nocapture %retptr, %struct.type_desc* nocapture %t1, %struct.type_desc* nocapture %t2, i8* nocapture %src) {
+define void @rust_intrinsic_cast(%struct.rust_task* nocapture %task, i8* nocapture %retptr, %struct.type_desc* nocapture %t1, %struct.type_desc* nocapture %t2, i8* nocapture %src) uwtable {
   %1 = getelementptr inbounds %struct.type_desc* %t1, i64 0, i32 1
-  %2 = load i64* %1, align 8
+  %2 = load i64* %1, align 8, !tbaa !3
   %3 = getelementptr inbounds %struct.type_desc* %t2, i64 0, i32 1
-  %4 = load i64* %3, align 8
+  %4 = load i64* %3, align 8, !tbaa !3
   %5 = icmp eq i64 %2, %4
   br i1 %5, label %7, label %6
 
 ; <label>:6                                       ; preds = %0
-  tail call void @upcall_fail(i8* getelementptr inbounds ([42 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([33 x i8]* @.str1, i64 0, i64 0), i64 32)
+  tail call void @upcall_fail(i8* getelementptr inbounds ([42 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([33 x i8]* @.str1, i64 0, i64 0), i64 38)
   br label %8
 
 ; <label>:7                                       ; preds = %0
@@ -102,12 +108,12 @@ declare void @upcall_fail(i8*, i8*, i64)
 
 declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind
 
-define void @rust_intrinsic_addr_of(%struct.rust_task* nocapture %task, i8** nocapture %retptr, %struct.type_desc* nocapture %ty, i8* %valptr) nounwind {
-  store i8* %valptr, i8** %retptr, align 8
+define void @rust_intrinsic_addr_of(%struct.rust_task* nocapture %task, i8** nocapture %retptr, %struct.type_desc* nocapture %ty, i8* %valptr) nounwind uwtable {
+  store i8* %valptr, i8** %retptr, align 8, !tbaa !0
   ret void
 }
 
-define void @rust_intrinsic_recv(%struct.rust_task* nocapture %task, i8** %retptr, %struct.type_desc* nocapture %ty, %class.rust_port* %port) {
+define void @rust_intrinsic_recv(%struct.rust_task* nocapture %task, i8** %retptr, %struct.type_desc* nocapture %ty, %class.rust_port* %port) uwtable {
   %1 = bitcast i8** %retptr to i64*
   tail call void @port_recv(i64* %1, %class.rust_port* %port)
   ret void
@@ -115,8 +121,20 @@ define void @rust_intrinsic_recv(%struct.rust_task* nocapture %task, i8** %retpt
 
 declare void @port_recv(i64*, %class.rust_port*)
 
-define void @rust_intrinsic_get_type_desc(%struct.rust_task* nocapture %task, i8** nocapture %retptr, %struct.type_desc* %ty) nounwind {
+define void @rust_intrinsic_get_type_desc(%struct.rust_task* nocapture %task, i8** nocapture %retptr, %struct.type_desc* %ty) nounwind uwtable {
   %ty.c = bitcast %struct.type_desc* %ty to i8*
-  store i8* %ty.c, i8** %retptr, align 8
+  store i8* %ty.c, i8** %retptr, align 8, !tbaa !0
   ret void
 }
+
+define void @rust_intrinsic_task_sleep(%struct.rust_task* nocapture %_task, i8** nocapture %retptr, i64 %time_in_us) uwtable {
+  tail call void @rust_task_sleep(i64 %time_in_us)
+  ret void
+}
+
+declare void @rust_task_sleep(i64)
+
+!0 = metadata !{metadata !"any pointer", metadata !1}
+!1 = metadata !{metadata !"omnipotent char", metadata !2}
+!2 = metadata !{metadata !"Simple C/C++ TBAA", null}
+!3 = metadata !{metadata !"long", metadata !1}
diff --git a/src/rt/rust_builtin.cpp b/src/rt/rust_builtin.cpp
index dd1e6a2c15c..53650beea38 100644
--- a/src/rt/rust_builtin.cpp
+++ b/src/rt/rust_builtin.cpp
@@ -165,12 +165,6 @@ rand_free(randctx *rctx) {
     task->free(rctx);
 }
 
-extern "C" CDECL void
-task_sleep(size_t time_in_us) {
-    rust_task *task = rust_scheduler::get_task();
-    task->yield(time_in_us);
-}
-
 /* Debug builtins for std::dbg. */
 
 static void
@@ -544,6 +538,16 @@ chan_id_send(type_desc *t, rust_task_id target_task_id,
     }
 }
 
+// This is called by an intrinsic on the Rust stack.
+// Do not call on the C stack.
+extern "C" CDECL void
+rust_task_sleep(size_t time_in_us) {
+    rust_task *task = rust_scheduler::get_task();
+    task->yield(time_in_us);
+}
+
+// This is called by an intrinsic on the Rust stack.
+// Do not call on the C stack.
 extern "C" CDECL void
 port_recv(uintptr_t *dptr, rust_port *port) {
     rust_task *task = rust_scheduler::get_task();
diff --git a/src/rt/rust_internal.h b/src/rt/rust_internal.h
index 06790fccd58..f144d668b13 100644
--- a/src/rt/rust_internal.h
+++ b/src/rt/rust_internal.h
@@ -287,9 +287,6 @@ struct type_desc {
 #include "rust_port.h"
 #include "memory.h"
 
-extern "C" CDECL void
-port_recv(uintptr_t *dptr, rust_port *port);
-
 #include "test/rust_test_harness.h"
 #include "test/rust_test_util.h"
 #include "test/rust_test_runtime.h"
diff --git a/src/rt/rustrt.def.in b/src/rt/rustrt.def.in
index d75a6dc00f1..3063d57f801 100644
--- a/src/rt/rustrt.def.in
+++ b/src/rt/rustrt.def.in
@@ -52,6 +52,7 @@ rust_ptr_eq
 rust_run_program
 rust_start
 rust_getcwd
+rust_task_sleep
 set_min_stack
 sched_threads
 size_of
@@ -59,7 +60,6 @@ squareroot
 start_task
 vec_reserve_shared
 vec_from_buf_shared
-task_sleep
 unsupervise
 upcall_alloc_c_stack
 upcall_call_c_stack
diff --git a/src/test/run-pass/bind-native.rs b/src/test/run-pass/bind-native.rs
index f67fb96c4d4..e0a191f292c 100644
--- a/src/test/run-pass/bind-native.rs
+++ b/src/test/run-pass/bind-native.rs
@@ -3,7 +3,7 @@ Can we bind native things?
 */
 
 native "c-stack-cdecl" mod rustrt {
-    fn task_sleep();
+    fn pin_task();
 }
 
-fn main() { bind rustrt::task_sleep(); }
+fn main() { bind rustrt::pin_task(); }