C++ Interop: Support getting void* from C++ functions and passing void* it to C++ function (#6279)

This defines `Cpp.void` as a custom type.
`Cpp.void*` is mapped to C++ `void*`.

Not supported yet: Conversions from and to other pointer types.

C++ Interop Demo:

```carbon
// main.carbon

library "Main";

import Core library "io";

import Cpp inline '''
#include <cstdio>

auto GetPointer() -> void* _Nonnull {
  static int x = 8;
  return &x;
}

auto GetValue(void* _Nonnull ptr) -> int {
  return *static_cast<int*>(ptr);
}
''';

fn Run() -> i32 {
  let ptr: Cpp.void* = Cpp.GetPointer();
  Core.Print(Cpp.GetValue(ptr));
  return 0;
}
```

```shell
$ bazel-bin/toolchain/carbon compile main.carbon
$ bazel-bin/toolchain/carbon link main.o --output=demo
$ ./demo
8
```

Part of #6280.

Author: bricknerb

toolchain/check/cpp/import.cpp

@@ -1137,6 +1137,9 @@ static auto MapBuiltinType(Context& context, SemIR::LocId loc_id,
               context.ints().Add(ast_context.getTypeSize(qual_type))));
     }
     // TODO: Handle floating-point types that map to named aliases.
+  } else if (type.isVoidType()) {
+    return ExprAsType(context, Parse::NodeId::None,
+                      SemIR::CppVoidType::TypeInstId);
   }
 
   return TypeExpr::None;
@@ -2116,6 +2119,7 @@ static auto LookupBuiltinTypes(Context& context, SemIR::LocId loc_id,
           .Case("float", ast_context.FloatTy)
           .Case("double", ast_context.DoubleTy)
           .Case("long_double", ast_context.LongDoubleTy)
+          .Case("void", ast_context.VoidTy)
           .Default(clang::QualType());
   if (builtin_type.isNull()) {
     return SemIR::InstId::None;

toolchain/check/cpp/type_mapping.cpp

@@ -195,6 +195,33 @@ static auto MapNonWrapperType(Context& context, SemIR::InstId inst_id,
   }
 }
 
+// Returns `void*` if the type is a wrapped `Cpp.void*`, consuming the pointer
+// from `wrapper_types`. Otherwise returns no type.
+static auto TryMapVoidPointer(Context& context, SemIR::TypeId type_id,
+                              llvm::SmallVector<SemIR::TypeId>& wrapper_types)
+    -> clang::QualType {
+  if (type_id != SemIR::CppVoidType::TypeId || wrapper_types.empty()) {
+    return clang::QualType();
+  }
+
+  if (context.types().Is<SemIR::PointerType>(wrapper_types.back())) {
+    // `void*`.
+    wrapper_types.pop_back();
+  } else if (wrapper_types.size() >= 2 &&
+             context.types().Is<SemIR::ConstType>(wrapper_types.back()) &&
+             context.types().Is<SemIR::PointerType>(
+                 wrapper_types[wrapper_types.size() - 2])) {
+    // `const void*`.
+    wrapper_types.erase(wrapper_types.end() - 2);
+  } else {
+    return clang::QualType();
+  }
+
+  return context.ast_context().getAttributedType(
+      clang::attr::TypeNonNull, context.ast_context().VoidPtrTy,
+      context.ast_context().VoidPtrTy);
+}
+
 // Maps a Carbon type to a C++ type. Accepts an InstId, representing a value
 // whose type is mapped to a C++ type. Returns `clang::QualType` if the mapping
 // succeeds, or `clang::QualType::isNull()` if the type is not supported.
@@ -219,9 +246,13 @@ static auto MapToCppType(Context& context, SemIR::InstId inst_id)
     wrapper_types.push_back(orig_type_id);
   }
 
-  clang::QualType mapped_type = MapNonWrapperType(context, inst_id, type_id);
+  clang::QualType mapped_type =
+      TryMapVoidPointer(context, type_id, wrapper_types);
   if (mapped_type.isNull()) {
-    return mapped_type;
+    mapped_type = MapNonWrapperType(context, inst_id, type_id);
+    if (mapped_type.isNull()) {
+      return mapped_type;
+    }
   }
 
   for (auto wrapper_type_id : llvm::reverse(wrapper_types)) {

toolchain/check/testdata/basics/raw_sem_ir/builtins.carbon

@@ -20,7 +20,7 @@
 // CHECK:STDOUT:   import_ir_insts: {}
 // CHECK:STDOUT:   clang_decls:     {}
 // CHECK:STDOUT:   name_scopes:
-// CHECK:STDOUT:     name_scope00000000: {inst: inst0000000E, parent_scope: name_scope<none>, has_error: false, extended_scopes: [], names: {}}
+// CHECK:STDOUT:     name_scope00000000: {inst: inst0000000F, parent_scope: name_scope<none>, has_error: false, extended_scopes: [], names: {}}
 // CHECK:STDOUT:   entity_names:    {}
 // CHECK:STDOUT:   cpp_global_vars: {}
 // CHECK:STDOUT:   functions:       {}
@@ -42,6 +42,7 @@
 // CHECK:STDOUT:     'inst(BoolType)':  {kind: BoolType, type: type(TypeType)}
 // CHECK:STDOUT:     'inst(BoundMethodType)': {kind: BoundMethodType, type: type(TypeType)}
 // CHECK:STDOUT:     'inst(CharLiteralType)': {kind: CharLiteralType, type: type(TypeType)}
+// CHECK:STDOUT:     'inst(CppVoidType)': {kind: CppVoidType, type: type(TypeType)}
 // CHECK:STDOUT:     'inst(ErrorInst)': {kind: ErrorInst, type: type(Error)}
 // CHECK:STDOUT:     'inst(FloatLiteralType)': {kind: FloatLiteralType, type: type(TypeType)}
 // CHECK:STDOUT:     'inst(ImplWitnessTablePlaceholder)': {kind: ImplWitnessTablePlaceholder, type: type(TypeType)}
@@ -51,14 +52,15 @@
 // CHECK:STDOUT:     'inst(SpecificFunctionType)': {kind: SpecificFunctionType, type: type(TypeType)}
 // CHECK:STDOUT:     'inst(VtableType)': {kind: VtableType, type: type(TypeType)}
 // CHECK:STDOUT:     'inst(WitnessType)': {kind: WitnessType, type: type(TypeType)}
-// CHECK:STDOUT:     inst0000000E:    {kind: Namespace, arg0: name_scope00000000, arg1: inst<none>, type: type(inst(NamespaceType))}
+// CHECK:STDOUT:     inst0000000F:    {kind: Namespace, arg0: name_scope00000000, arg1: inst<none>, type: type(inst(NamespaceType))}
 // CHECK:STDOUT:   constant_values:
 // CHECK:STDOUT:     values:
 // CHECK:STDOUT:       'inst(TypeType)':  concrete_constant(inst(TypeType))
 // CHECK:STDOUT:       'inst(AutoType)':  concrete_constant(inst(AutoType))
 // CHECK:STDOUT:       'inst(BoolType)':  concrete_constant(inst(BoolType))
 // CHECK:STDOUT:       'inst(BoundMethodType)': concrete_constant(inst(BoundMethodType))
 // CHECK:STDOUT:       'inst(CharLiteralType)': concrete_constant(inst(CharLiteralType))
+// CHECK:STDOUT:       'inst(CppVoidType)': concrete_constant(inst(CppVoidType))
 // CHECK:STDOUT:       'inst(ErrorInst)': concrete_constant(inst(ErrorInst))
 // CHECK:STDOUT:       'inst(FloatLiteralType)': concrete_constant(inst(FloatLiteralType))
 // CHECK:STDOUT:       'inst(ImplWitnessTablePlaceholder)': concrete_constant(inst(ImplWitnessTablePlaceholder))
@@ -68,13 +70,13 @@
 // CHECK:STDOUT:       'inst(SpecificFunctionType)': concrete_constant(inst(SpecificFunctionType))
 // CHECK:STDOUT:       'inst(VtableType)': concrete_constant(inst(VtableType))
 // CHECK:STDOUT:       'inst(WitnessType)': concrete_constant(inst(WitnessType))
-// CHECK:STDOUT:       inst0000000E:    concrete_constant(inst0000000E)
+// CHECK:STDOUT:       inst0000000F:    concrete_constant(inst0000000F)
 // CHECK:STDOUT:     symbolic_constants: {}
 // CHECK:STDOUT:   inst_blocks:
 // CHECK:STDOUT:     inst_block_empty: {}
 // CHECK:STDOUT:     exports:         {}
 // CHECK:STDOUT:     imports:         {}
 // CHECK:STDOUT:     global_init:     {}
 // CHECK:STDOUT:     inst_block60000004:
-// CHECK:STDOUT:       0:               inst0000000E
+// CHECK:STDOUT:       0:               inst0000000F
 // CHECK:STDOUT: ...