diff --git a/crates/gen-guest-c/src/lib.rs b/crates/gen-guest-c/src/lib.rs
index fe82415d3..cdb4f8e61 100644
--- a/crates/gen-guest-c/src/lib.rs
+++ b/crates/gen-guest-c/src/lib.rs
@@ -1405,6 +1405,7 @@ struct FunctionBindgen<'a, 'b> {
     locals: Ns,
     src: wit_bindgen_core::Source,
     sig: CSig,
+    has_ret_area: bool,
     func_to_call: &'a str,
     block_storage: Vec<wit_bindgen_core::Source>,
     blocks: Vec<(String, Vec<String>)>,
@@ -1422,6 +1423,7 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
         FunctionBindgen {
             gen,
             sig,
+            has_ret_area: false,
             locals: Default::default(),
             src: Default::default(),
             func_to_call,
@@ -1494,16 +1496,22 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             // Declare a stack-allocated return area. We only do this for
             // imports, because exports need their return area to be live until
             // the post-return call.
+            let ret_idx = if self.has_ret_area {
+                format!("_{}", ptr)
+            } else {
+                self.has_ret_area = true;
+                "".to_string()
+            };
             uwrite!(
                 self.src,
                 "\
                     __attribute__((aligned({})))
-                    uint8_t ret_area[{}];
+                    uint8_t ret_area{ret_idx}[{}];
                 ",
                 align,
                 size,
             );
-            uwriteln!(self.src, "int32_t {} = (int32_t) &ret_area;", ptr);
+            uwriteln!(self.src, "int32_t {} = (int32_t) &ret_area{ret_idx};", ptr);
         } else {
             self.gen.gen.return_pointer_area_size = self.gen.gen.return_pointer_area_size.max(size);
             self.gen.gen.return_pointer_area_align =
diff --git a/tests/runtime/flavorful/wasm.c b/tests/runtime/flavorful/wasm.c
index 875b41274..467b47a5b 100644
--- a/tests/runtime/flavorful/wasm.c
+++ b/tests/runtime/flavorful/wasm.c
@@ -16,11 +16,18 @@ void flavorful_test_imports() {
   }
 
   {
-    imports_list_in_record3_t a, b;
-    flavorful_string_set(&a.a, "list_in_record3 input");
-    imports_f_list_in_record3(&a, &b);
-    assert(memcmp(b.a.ptr, "list_in_record3 output", b.a.len) == 0);
-    imports_list_in_record3_free(&b);
+    imports_list_in_record3_t a;
+    a.a.is_some = true;
+    a.b.is_some = false;
+    a.c.is_some = false;
+    a.d.is_some = false;
+    a.e.is_some = false;
+    a.f.is_some = false;
+    flavorful_string_set(&a.a.val, "list_in_record3 input");
+    imports_result_list_in_record3_u32_t ret;
+    imports_f_list_in_record3(&a, &ret);
+    assert(memcmp(ret.val.ok.a.val.ptr, "list_in_record3 output", ret.val.ok.a.val.len) == 0);
+    imports_list_in_record3_free(&ret.val.ok);
   }
 
   {
diff --git a/tests/runtime/flavorful/wasm.rs b/tests/runtime/flavorful/wasm.rs
index 7b19017a9..f7560a103 100644
--- a/tests/runtime/flavorful/wasm.rs
+++ b/tests/runtime/flavorful/wasm.rs
@@ -19,9 +19,13 @@ impl Flavorful for Component {
 
         assert_eq!(
             f_list_in_record3(ListInRecord3Param {
-                a: "list_in_record3 input"
-            })
-            .a,
+                a: Some("list_in_record3 input"),
+                b: None,
+                c: None,
+                d: None,
+                e: None,
+                f: None,
+            }).unwrap().a.unwrap(),
             "list_in_record3 output"
         );
 
diff --git a/tests/runtime/flavorful/world.wit b/tests/runtime/flavorful/world.wit
index 114808cb1..7e939a1d6 100644
--- a/tests/runtime/flavorful/world.wit
+++ b/tests/runtime/flavorful/world.wit
@@ -1,13 +1,20 @@
 interface imports {
   record list-in-record1 { a: string }
   record list-in-record2 { a: string }
-  record list-in-record3 { a: string }
+  record list-in-record3 {
+    a: option<string>,
+    b: option<list<u8>>,
+    c: option<string>,
+    d: option<u32>,
+    e: option<string>,
+    f: option<string>,
+  }
   record list-in-record4 { a: string }
   type list-in-alias = list-in-record4
 
   f-list-in-record1: func(a: list-in-record1)
   f-list-in-record2: func() -> list-in-record2
-  f-list-in-record3: func(a: list-in-record3) -> list-in-record3
+  f-list-in-record3: func(a: list-in-record3) -> result<list-in-record3, u32>
   f-list-in-record4: func(a: list-in-alias) -> list-in-alias
 
   type list-in-variant1-v1 = option<string>