Generate and use a C++ thunk to call non simple ABI C++ functions (#5850)

When the C++ function has a parameter that is not a pointer and not a
signed integer of 32 or 64 bits, generate a thunk.

Terminology:
* Callee function: The C++ function we actually want to call.
* Thunk function: The C++ function we generated that calls the callee
function.
* A simple ABI type, for now, is one of:
  * A pointer
  * signed integer with 32 bits
  * signed integer with 64 bits

The thunk function is marked `always_inline` and uses the `asm`
attribute to set its mangled to the callee function mangled name
suffixed with `".carbon_thunk"`.

When importing a C++ function, we decide whether calling it requires a
thunk and if so we generate it and import it as well, which is currently
a recursive call.

When calling the thunk function, we initialize a temporary storage for
each non simple ABI parameter type and take its address. This can be
optimized when the variable is already in storage.

Not supported yet:
* Functions with non void return values.
* Member methods.

Moved unsigned int param test from `arithmetic_types_direct.carbon` to
`arithmetic_types_bridged.carbon`, since only signed integers aren't
bridged using a thunk.

C++ Interop Demo:

```c++
// hello_world.h

struct S {
  S() {}
  S(const S&) { x = 1; }
  int x;
};

void hello_world(S s);
```

```c++
// hello_world.cpp

#include "hello_world.h"

#include <cstdio>

void hello_world2(S s) { printf("hello_world2: %d\n", s.x); }

void hello_world(S s) {
  printf("hello_world: %d\n", s.x);
  hello_world2(s);
}
```

```carbon
// main.carbon

library "Main";

import Cpp library "hello_world.h";

fn Run() -> i32 {
  var s : Cpp.S;
  Cpp.hello_world(s);
  return 0;
}
```

```shell
$ clang -c hello_world.cpp
$ bazel-bin/toolchain/carbon compile main.carbon
$ bazel-bin/toolchain/carbon link hello_world.o main.o --output=demo
$ ./demo
hello_world: 1
hello_world2: 1
```

Before this change (no thunk - copy constructor not called when calling
`hello_world()`):
```shell
$ ./demo
hello_world: -1219172304
hello_world2: 1
```

Author: bricknerb

toolchain/check/BUILD

@@ -21,6 +21,7 @@ cc_library(
         "context.cpp",
         "control_flow.cpp",
         "convert.cpp",
+        "cpp_thunk.cpp",
         "decl_name_stack.cpp",
         "deduce.cpp",
         "deferred_definition_worklist.cpp",
@@ -65,6 +66,7 @@ cc_library(
         "context.h",
         "control_flow.h",
         "convert.h",
+        "cpp_thunk.h",
         "decl_introducer_state.h",
         "decl_name_stack.h",
         "deduce.h",

toolchain/check/call.cpp

@@ -10,6 +10,7 @@
 #include "toolchain/check/context.h"
 #include "toolchain/check/control_flow.h"
 #include "toolchain/check/convert.h"
+#include "toolchain/check/cpp_thunk.h"
 #include "toolchain/check/deduce.h"
 #include "toolchain/check/facet_type.h"
 #include "toolchain/check/function.h"
@@ -255,27 +256,39 @@ static auto PerformCallToFunction(Context& context, SemIR::LocId loc_id,
       ConvertCallArgs(context, loc_id, callee_function.self_id, arg_ids,
                       return_slot_arg_id, callee, *callee_specific_id);
 
-  // If we're about to form a direct call to a thunk, inline it.
-  if (callee.special_function_kind ==
-      SemIR::Function::SpecialFunctionKind::Thunk) {
-    LoadImportRef(context, callee.thunk_decl_id());
+  switch (callee.special_function_kind) {
+    case SemIR::Function::SpecialFunctionKind::Thunk: {
+      // If we're about to form a direct call to a thunk, inline it.
+      LoadImportRef(context, callee.thunk_decl_id());
 
-    // Name the thunk target within the enclosing scope of the thunk.
-    auto thunk_ref_id =
-        BuildNameRef(context, loc_id, callee.name_id, callee.thunk_decl_id(),
-                     callee_function.enclosing_specific_id);
+      // Name the thunk target within the enclosing scope of the thunk.
+      auto thunk_ref_id =
+          BuildNameRef(context, loc_id, callee.name_id, callee.thunk_decl_id(),
+                       callee_function.enclosing_specific_id);
 
-    // This recurses back into `PerformCall`. However, we never form a thunk to
-    // a thunk, so we only recurse once.
-    return PerformThunkCall(context, loc_id, callee_function.function_id,
-                            context.inst_blocks().Get(converted_args_id),
-                            thunk_ref_id);
-  }
+      // This recurses back into `PerformCall`. However, we never form a thunk
+      // to a thunk, so we only recurse once.
+      return PerformThunkCall(context, loc_id, callee_function.function_id,
+                              context.inst_blocks().Get(converted_args_id),
+                              thunk_ref_id);
+    }
+
+    case SemIR::Function::SpecialFunctionKind::HasCppThunk: {
+      // This recurses back into `PerformCall`. However, we never form a C++
+      // thunk to a C++ thunk, so we only recurse once.
+      return PerformCppThunkCall(context, loc_id, callee_function.function_id,
+                                 context.inst_blocks().Get(converted_args_id),
+                                 callee.cpp_thunk_decl_id());
+    }
 
-  return GetOrAddInst<SemIR::Call>(context, loc_id,
-                                   {.type_id = return_info.type_id,
-                                    .callee_id = callee_id,
-                                    .args_id = converted_args_id});
+    case SemIR::Function::SpecialFunctionKind::None:
+    case SemIR::Function::SpecialFunctionKind::Builtin: {
+      return GetOrAddInst<SemIR::Call>(context, loc_id,
+                                       {.type_id = return_info.type_id,
+                                        .callee_id = callee_id,
+                                        .args_id = converted_args_id});
+    }
+  }
 }
 
 auto PerformCall(Context& context, SemIR::LocId loc_id, SemIR::InstId callee_id,