diff --git a/bazel/llvm.bzl b/bazel/llvm.bzl
index 962a650..c088b91 100644
--- a/bazel/llvm.bzl
+++ b/bazel/llvm.bzl
@@ -53,7 +53,7 @@
             executable = False,
         )
 
-LLVM_COMMIT_SHA = "7102eae4c0640492e1fcea3da7f22f4e75a4f062"
+LLVM_COMMIT_SHA = "de88b2cb16af4bba659d0bb2ddf10bda681ec84d"
 
 def llvm_loader_repository_dependencies():
     # This *declares* the dependency, but it won't actually be *downloaded* unless it's used.
diff --git a/rs_bindings_from_cc/test/function/non_extern_c/BUILD b/rs_bindings_from_cc/test/function/non_extern_c/BUILD
new file mode 100644
index 0000000..e707490
--- /dev/null
+++ b/rs_bindings_from_cc/test/function/non_extern_c/BUILD
@@ -0,0 +1,18 @@
+"""End-to-end example of using simple functions."""
+
+load("//common:crubit_wrapper_macros_oss.bzl", "crubit_rust_test")
+load("//rs_bindings_from_cc/test:test_bindings.bzl", "crubit_test_cc_library")
+
+package(default_applicable_licenses = ["//:license"])
+
+crubit_test_cc_library(
+    name = "simple_functions",
+    srcs = ["simple_functions.cc"],
+    hdrs = ["simple_functions.h"],
+)
+
+crubit_rust_test(
+    name = "main",
+    srcs = ["test.rs"],
+    cc_deps = [":simple_functions"],
+)
diff --git a/rs_bindings_from_cc/test/function/non_extern_c/simple_functions.cc b/rs_bindings_from_cc/test/function/non_extern_c/simple_functions.cc
new file mode 100644
index 0000000..43333cd
--- /dev/null
+++ b/rs_bindings_from_cc/test/function/non_extern_c/simple_functions.cc
@@ -0,0 +1,40 @@
+// Part of the Crubit project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "rs_bindings_from_cc/test/function/non_extern_c/simple_functions.h"
+
+int return_value() { return 42; }
+
+int* return_pointer() {
+  static int i = 42;
+  return &i;
+}
+
+int& return_reference() {
+  static int i = 42;
+  return i;
+}
+
+void take_pointer(int* i) {
+  if (i) {
+    *i = 42;
+  }
+}
+
+void take_reference(int& i) { i = 42; }
+
+const int* forward_pointer(const int* i) { return i; }
+
+const int& forward_reference(const int& i) { return i; }
+
+int multiply(int x, int y) { return x * y; }
+
+int multiply_with_unnamed_parameters(int x, int y) { return x * y; }
+
+int multiply_with_keyword_named_parameters(int self, int crate, int super) {
+  return self * crate * super;
+}
+
+int (*get_pointer_to_multiply_function())(int, int) { return multiply; }
+int (&get_reference_to_multiply_function())(int, int) { return multiply; }
diff --git a/rs_bindings_from_cc/test/function/non_extern_c/simple_functions.h b/rs_bindings_from_cc/test/function/non_extern_c/simple_functions.h
new file mode 100644
index 0000000..ce35a0f
--- /dev/null
+++ b/rs_bindings_from_cc/test/function/non_extern_c/simple_functions.h
@@ -0,0 +1,41 @@
+// Part of the Crubit project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef CRUBIT_RS_BINDINGS_FROM_CC_TEST_FUNCTION_SIMPLE_SIMPLE_FUNCTIONS_H_
+#define CRUBIT_RS_BINDINGS_FROM_CC_TEST_FUNCTION_SIMPLE_SIMPLE_FUNCTIONS_H_
+
+int return_value();
+int* return_pointer();
+int& return_reference();
+void take_pointer(int* i);
+void take_reference(int& i);
+const int* forward_pointer(const int* i);
+const int& forward_reference(const int& i);
+int multiply(int x, int y);
+int multiply_with_unnamed_parameters(int, int);
+int multiply_with_keyword_named_parameters(int self, int crate, int super);
+
+// https://cdecl.org/?q=int+%28*get_multiply_function%28%29%29%28int%2C+int%29:
+// declare foo as function returning pointer to function (int, int) returning
+// int
+int (*get_pointer_to_multiply_function())(int, int);
+
+// Same as above, but returning a *reference* to a function.
+int (&get_reference_to_multiply_function())(int, int);
+
+inline int (*inline_get_pointer_to_multiply_function())(int, int) {
+  return multiply;
+}
+
+inline int apply_binary_op(int x, int y, int (*op)(int, int)) {
+  return op(x, y);
+}
+
+// TODO(b/217419782): Add testcases for pointers to functions that take or
+// return takes/returns non-trivially-movable types by value. In particular,
+// some function signatures might require going through a C++ thunk - such
+// function pointers can't work without a thunk. See also
+// <internal link>
+
+#endif  // CRUBIT_RS_BINDINGS_FROM_CC_TEST_FUNCTION_SIMPLE_SIMPLE_FUNCTIONS_H_
diff --git a/rs_bindings_from_cc/test/function/non_extern_c/test.rs b/rs_bindings_from_cc/test/function/non_extern_c/test.rs
new file mode 100644
index 0000000..8f1aebf
--- /dev/null
+++ b/rs_bindings_from_cc/test/function/non_extern_c/test.rs
@@ -0,0 +1,119 @@
+// Part of the Crubit project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_return_value() {
+        use simple_functions::return_value;
+        assert_eq!(return_value(), 42);
+    }
+
+    #[test]
+    fn test_return_pointer() {
+        use simple_functions::return_pointer;
+        unsafe {
+            assert_eq!(*return_pointer(), 42);
+        }
+    }
+
+    #[test]
+    fn test_return_reference() {
+        use simple_functions::return_reference;
+        unsafe {
+            assert_eq!(*return_reference(), 42);
+        }
+    }
+
+    #[test]
+    fn test_take_pointer() {
+        use simple_functions::take_pointer;
+        unsafe {
+            take_pointer(std::ptr::null_mut());
+        }
+        let mut i: i32 = 0;
+        unsafe {
+            take_pointer(&mut i);
+        }
+        assert_eq!(i, 42);
+    }
+
+    #[test]
+    fn test_take_reference() {
+        use simple_functions::take_reference;
+        let mut i: i32 = 0;
+        unsafe {
+            take_reference(&mut i);
+        }
+        assert_eq!(i, 42);
+    }
+
+    #[test]
+    fn test_forward_pointer() {
+        use simple_functions::forward_pointer;
+        assert_eq!(unsafe { forward_pointer(std::ptr::null()) }, std::ptr::null());
+        let i: i32 = 42;
+        assert_eq!(unsafe { *forward_pointer(&i) }, 42);
+    }
+
+    #[test]
+    fn test_forward_reference() {
+        use simple_functions::forward_reference;
+        let i: i32 = 42;
+        assert_eq!(unsafe { *forward_reference(&i) }, 42);
+    }
+
+    #[test]
+    fn test_multiply() {
+        assert_eq!(simple_functions::multiply(42, 123), 42 * 123);
+    }
+
+    #[test]
+    fn test_multiply_with_unnamed_parameters() {
+        assert_eq!(simple_functions::multiply_with_unnamed_parameters(42, 456), 42 * 456);
+    }
+
+    #[test]
+    fn test_multiply_with_keyword_named_parameters() {
+        assert_eq!(
+            42 * 123 * 456,
+            simple_functions::multiply_with_keyword_named_parameters(42, 123, 456)
+        );
+    }
+
+    #[test]
+    fn test_function_pointer() {
+        let maybe_mul_fn = simple_functions::get_pointer_to_multiply_function();
+        let mul_fn = maybe_mul_fn.expect("Expecting non-null / non-None function pointer");
+        assert_eq!(mul_fn(123, 456), 123 * 456);
+    }
+
+    #[test]
+    fn test_function_reference() {
+        // TODO(b/217419782): Replicate `test_function_pointer`, but for C++
+        // references. (e.g. no `expect` / `Option` unwrapping should be
+        // needed).
+    }
+
+    #[test]
+    fn test_function_pointer_returned_from_inline_function() {
+        let maybe_mul_fn = simple_functions::inline_get_pointer_to_multiply_function();
+        let mul_fn = maybe_mul_fn.expect("Expecting non-null / non-None function pointer");
+        assert_eq!(mul_fn(123, 456), 123 * 456);
+    }
+
+    /// Test that function pointers can be accepted as function parameters.
+    #[test]
+    fn test_apply_binary_op() {
+        extern "C" fn multiply(x: i32, y: i32) -> i32 {
+            x * y
+        }
+        extern "C" fn add(x: i32, y: i32) -> i32 {
+            x + y
+        }
+
+        assert_eq!(100 * 200, simple_functions::apply_binary_op(100, 200, Some(multiply)),);
+        assert_eq!(300 + 400, simple_functions::apply_binary_op(300, 400, Some(add)),);
+    }
+}