wiggle things around to use pinned heap reg

Author: awortman-fastly

lucet-runtime/lucet-runtime-internals/src/context/context_asm.S

@@ -44,7 +44,7 @@ _lucet_context_bootstrap:
 	mov %r12, %rsi
 	mov %r13, %rdx
 	mov %r14, %rcx
-	mov %r15, %r8
+	mov %r8, %r8
 	mov %rbx, %r9
 	/* the next thing on the stack is the guest function - return to it */
 	ret
@@ -64,9 +64,9 @@ lucet_context_backstop:
 _lucet_context_backstop:
     mov -16(%rbp), %rdi  /* parent context to arg 1 */
     mov -8(%rbp), %rsi  /* own context to arg 2 */
-    mov %rax, (8*8 + 8*16 + 8*0)(%rdi) /* store return values before swapping back -- offset is offsetof(struct lucet_context, retvals) */
-    mov %rdx, (8*8 + 8*16 + 8*1)(%rdi)
-    movdqu %xmm0, (8*8 + 8*16 + 8*2)(%rdi) /* floating-point return value */
+    mov %rax, (10*8 + 8*16 + 8*0)(%rdi) /* store return values before swapping back -- offset is offsetof(struct lucet_context, retvals) */
+    mov %rdx, (10*8 + 8*16 + 8*1)(%rdi)
+    movdqu %xmm0, (10*8 + 8*16 + 8*2)(%rdi) /* floating-point return value */
 #ifdef __ELF__
     jmp lucet_context_swap@PLT
 #else
@@ -95,15 +95,16 @@ _lucet_context_swap:
     mov %r13, (5*8)(%rdi)
     mov %r14, (6*8)(%rdi)
     mov %r15, (7*8)(%rdi)
+    mov %r8,  (8*8)(%rdi)
 
-    movdqu %xmm0, (8*8 + 0*16)(%rdi)
-    movdqu %xmm1, (8*8 + 1*16)(%rdi)
-    movdqu %xmm2, (8*8 + 2*16)(%rdi)
-    movdqu %xmm3, (8*8 + 3*16)(%rdi)
-    movdqu %xmm4, (8*8 + 4*16)(%rdi)
-    movdqu %xmm5, (8*8 + 5*16)(%rdi)
-    movdqu %xmm6, (8*8 + 6*16)(%rdi)
-    movdqu %xmm7, (8*8 + 7*16)(%rdi)
+    movdqu %xmm0, (10*8 + 0*16)(%rdi)
+    movdqu %xmm1, (10*8 + 1*16)(%rdi)
+    movdqu %xmm2, (10*8 + 2*16)(%rdi)
+    movdqu %xmm3, (10*8 + 3*16)(%rdi)
+    movdqu %xmm4, (10*8 + 4*16)(%rdi)
+    movdqu %xmm5, (10*8 + 5*16)(%rdi)
+    movdqu %xmm6, (10*8 + 6*16)(%rdi)
+    movdqu %xmm7, (10*8 + 7*16)(%rdi)
 
     // load everything from offsets from rsi (2nd arg)
     mov (0*8)(%rsi), %rbx
@@ -114,15 +115,16 @@ _lucet_context_swap:
     mov (5*8)(%rsi), %r13
     mov (6*8)(%rsi), %r14
     mov (7*8)(%rsi), %r15
-
-    movdqu (8*8 + 0*16)(%rsi), %xmm0
-    movdqu (8*8 + 1*16)(%rsi), %xmm1
-    movdqu (8*8 + 2*16)(%rsi), %xmm2
-    movdqu (8*8 + 3*16)(%rsi), %xmm3
-    movdqu (8*8 + 4*16)(%rsi), %xmm4
-    movdqu (8*8 + 5*16)(%rsi), %xmm5
-    movdqu (8*8 + 6*16)(%rsi), %xmm6
-    movdqu (8*8 + 7*16)(%rsi), %xmm7
+    mov (8*8)(%rsi), %r8
+
+    movdqu (10*8 + 0*16)(%rsi), %xmm0
+    movdqu (10*8 + 1*16)(%rsi), %xmm1
+    movdqu (10*8 + 2*16)(%rsi), %xmm2
+    movdqu (10*8 + 3*16)(%rsi), %xmm3
+    movdqu (10*8 + 4*16)(%rsi), %xmm4
+    movdqu (10*8 + 5*16)(%rsi), %xmm5
+    movdqu (10*8 + 6*16)(%rsi), %xmm6
+    movdqu (10*8 + 7*16)(%rsi), %xmm7
 
     ret
 #ifdef __ELF__

lucet-runtime/lucet-runtime-internals/src/context/mod.rs

@@ -34,6 +34,7 @@ struct GpRegs {
     r13: u64,
     r14: u64,
     r15: u64,
+    r8: u64
 }
 
 impl GpRegs {
@@ -47,6 +48,7 @@ impl GpRegs {
             r13: 0,
             r14: 0,
             r15: 0,
+            r8: 0,
         }
     }
 }
@@ -195,9 +197,10 @@ impl ContextHandle {
         parent: &mut ContextHandle,
         fptr: usize,
         args: &[Val],
+        heap: *mut core::ffi::c_void,
     ) -> Result<ContextHandle, Error> {
         let mut child = ContextHandle::new();
-        Context::init(stack, parent, &mut child, fptr, args)?;
+        Context::init(stack, parent, &mut child, fptr, args, heap)?;
         Ok(child)
     }
 }
@@ -287,6 +290,7 @@ impl Context {
         child: &mut Context,
         fptr: usize,
         args: &[Val],
+        heap: *mut core::ffi::c_void,
     ) -> Result<(), Error> {
         if !stack_is_aligned(stack) {
             xbail!(Error::UnalignedStack);
@@ -365,6 +369,9 @@ impl Context {
         // parent arguments set above.
         child.gpr.rbp = &mut stack[sp - 2] as *mut u64 as u64;
 
+        // testing out heap pinning
+        child.gpr.r15 = heap as u64;
+
         // Read the sigprocmask to be restored if we ever need to jump out of a signal handler. If
         // this isn't possible, die.
         signal::sigprocmask(
@@ -569,7 +576,7 @@ impl Context {
             // bootstraps into rcx
             3 => self.gpr.r14 = arg,
             // bootstraps into r8
-            4 => self.gpr.r15 = arg,
+            4 => self.gpr.r8 = arg,
             // bootstraps into r9
             5 => self.gpr.rbx = arg,
             _ => panic!("unexpected gp register index {}", ix),

lucet-runtime/lucet-runtime-internals/src/instance.rs

@@ -797,7 +797,8 @@ impl Instance {
 
         self.entrypoint = Some(func.ptr);
 
-        let mut args_with_vmctx = vec![Val::from(self.alloc.slot().heap)];
+        let heap = self.alloc.slot().heap;
+        let mut args_with_vmctx = vec![Val::from(heap)];
         args_with_vmctx.extend_from_slice(args);
 
         HOST_CTX.with(|host_ctx| {
@@ -807,6 +808,7 @@ impl Instance {
                 &mut self.ctx,
                 func.ptr.as_usize(),
                 &args_with_vmctx,
+                heap,
             )
         })?;
 

lucetc/src/compiler.rs

@@ -196,6 +196,8 @@ impl<'a> Compiler<'a> {
             cranelift_native::builder().expect("host machine is not a supported target");
         flags_builder.enable("enable_verifier").unwrap();
         flags_builder.enable("is_pic").unwrap();
+        flags_builder.enable("enable_pinned_reg");
+        flags_builder.enable("use_pinned_reg_as_heap_base");
         flags_builder.set("opt_level", opt_level.to_flag()).unwrap();
         isa_builder.finish(settings::Flags::new(flags_builder))
     }