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

bricknerb · 2025-10-27T15:36:36Z

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:

// 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;
}

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

Part of #6280.

…void*` it to C++ function 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.

jonmeow · 2025-10-27T16:04:58Z

toolchain/sem_ir/typed_insts.h

 };

+// A type for C++ `void`. Should only be used for pointers (`void*`).
+struct CustomCppVoidType {


I'm not sure what's "custom" here -- perhaps remove it?

For contrast, in "custom layout type", I believe "custom" refers to the way layout is determined externally ("customized").

Suggested change

struct CustomCppVoidType {

struct CppVoidType {

jonmeow · 2025-10-27T16:08:26Z

toolchain/sem_ir/stringify.cpp

+  auto StringifyInst(InstId /*inst_id*/, CustomCppVoidType /*inst*/) -> void {
+    *out_ << "<builtin Cpp.void>";
+  }
+


Functions here look lexically ordered, perhaps move this before CustomLayoutType?

jonmeow · 2025-10-27T16:14:07Z

toolchain/check/cpp/type_mapping.cpp

+  if (type_id == SemIR::CustomCppVoidType::TypeId && !wrapper_types.empty() &&
+      context.types().Is<SemIR::PointerType>(wrapper_types.back())) {


Can you add tests of things like const (Cpp.void*), (const Cpp.void)*, and Cpp.void**? Particularly the last case looks interesting, would it convert Cpp.void** to void* because wrapper_types.back() is PointerType?

Thinking about this further, (const Cpp.void)* is probably the awkward case. It's essentially a pointer to void, but the const is in a place this code won't like.

Thanks for the catch!
Added support for const void* and added tests for void** and const void*.

For (const Cpp.void)*, please note that we don't currently support C++ const pointers well.
For example, see #6284.

jonmeow · 2025-10-27T16:28:19Z

toolchain/check/cpp/type_mapping.cpp

+// If `type_id` is `Cpp.void` and the last wrapper type in `wrapper_types` is a
+// pointer, pops the pointer wrapper and returns non nullable `void*` QualType.
+// Otherwise returns a null QualType.


Just to note, I would've found this comment more helpful if it'd been a little more high level. Right now it seems to be just documenting the if/else in detail. For a suggestion on a different comment style:

Suggested change

// If `type_id` is `Cpp.void` and the last wrapper type in `wrapper_types` is a

// pointer, pops the pointer wrapper and returns non nullable `void*` QualType.

// Otherwise returns a null QualType.

// Returns `void*` if the type is a wrapped `Cpp.void*`, consuming the

// pointer from `wrapper_types`. Otherwise returns no type.

jonmeow · 2025-10-27T16:30:08Z

toolchain/sem_ir/stringify.cpp

  }

+  auto StringifyInst(InstId /*inst_id*/, CustomCppVoidType /*inst*/) -> void {
+    *out_ << "<builtin Cpp.void>";


This can show up in diagnostics, right? We probably don't want the "<builtin" wrapper as such -- it's a user-visible type.

…oid`.

…tomLayoutType`.

bricknerb · 2025-10-28T11:02:37Z

toolchain/check/cpp/type_mapping.cpp

+  llvm::SmallVector<SemIR::TypeId>::iterator pointer_iter;
+  if (!wrapper_types.empty() &&
+      context.types().Is<SemIR::PointerType>(wrapper_types.back())) {
+    // `void*`.
+    pointer_iter = wrapper_types.end() - 1;
+  } 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*`.
+    pointer_iter = wrapper_types.end() - 2;
+  } else {
+    return clang::QualType();
+  }
+
+  wrapper_types.erase(pointer_iter);


An alternative way to write this, which I'm not sure is better:

Suggested change

llvm::SmallVector<SemIR::TypeId>::iterator pointer_iter;

if (!wrapper_types.empty() &&

context.types().Is<SemIR::PointerType>(wrapper_types.back())) {

// `void*`.

pointer_iter = wrapper_types.end() - 1;

} 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*`.

pointer_iter = wrapper_types.end() - 2;

} else {

return clang::QualType();

}

wrapper_types.erase(pointer_iter);

llvm::SmallVector<SemIR::TypeId>::iterator wrapper_iter =

wrapper_types.end() - 1;

if (context.types().Is<SemIR::PointerType>(*wrapper_iter)) {

// This is `void*`, wrapper_iter points to the pointer type.

} else if (wrapper_iter != wrapper_types.begin() &&

context.types().Is<SemIR::ConstType>(*wrapper_iter) &&

context.types().Is<SemIR::PointerType>(*(wrapper_iter - 1))) {

// This is `const void*`, move `wrapper_iter` to point to the pointer type.

--wrapper_iter;

} else {

return clang::QualType();

}

wrapper_types.erase(wrapper_iter);

jonmeow

LG, with some TODO suggestions.

jonmeow · 2025-10-28T18:46:19Z

toolchain/check/type_completion.cpp

    requires(InstT::Kind.template IsAnyOf<
             SemIR::AssociatedEntityType, SemIR::CppOverloadSetType,
-             SemIR::CustomCppVoidType, SemIR::FunctionType,
+             SemIR::CppVoidType, SemIR::FunctionType,


Sorry, I'd missed this before... Can you please break CppVoidType out to its own function, and add a TODO that it should be always-incomplete?

That is, the changes in this file have the consequence of always treating void as a complete type. However, functionally we don't want it to behave that way -- only pointers are valid. So it should probably never be set as complete.

That should make todo_fail_void.carbon fail, for example.

Done.
FWIW, I was looking into making it always incomplete but didn't find the right setup for this and thought it shouldn't block this change.
Let me know if you have some pointers on how to do that.

jonmeow · 2025-10-28T18:59:56Z

toolchain/check/cpp/type_mapping.cpp

+  llvm::SmallVector<SemIR::TypeId>::iterator pointer_iter;
+  if (context.types().Is<SemIR::PointerType>(wrapper_types.back())) {
+    // `void*`.
+    pointer_iter = wrapper_types.end() - 1;
+  } 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*`.
+    pointer_iter = wrapper_types.end() - 2;
+  } else {
+    return clang::QualType();
+  }
+
+  wrapper_types.erase(pointer_iter);


Small suggestion to drop pointer_iter (mainly, the type information is complex, but also the direct erase seems helpfully succinct)

Suggested change

llvm::SmallVector<SemIR::TypeId>::iterator pointer_iter;

if (context.types().Is<SemIR::PointerType>(wrapper_types.back())) {

// `void*`.

pointer_iter = wrapper_types.end() - 1;

} 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*`.

pointer_iter = wrapper_types.end() - 2;

} else {

return clang::QualType();

}

wrapper_types.erase(pointer_iter);

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();

}

jonmeow · 2025-10-28T19:01:56Z

toolchain/check/cpp/type_mapping.cpp

-  return clang::QualType();
+
+  llvm::SmallVector<SemIR::TypeId>::iterator pointer_iter;
+  if (context.types().Is<SemIR::PointerType>(wrapper_types.back())) {


There are probably other instructions that could be here which should be ignored, e.g. MaybeUnformedType. It might be worth thinking about whether a while loop here would be a good fit, but not asking for a change since wrapper_types doesn't support MaybeUnformedType right now either.

Yes, this definitely makes sense to do when we can have a test that triggers this.

…l effect. (#6287) This is to avoid edge cases where there are multiple `ConstType` instructions, which code may not handle appropriately. I was thinking about this for #6279

…type directly.

…make it always-incomplete.

…6301) I missed this in #6279, just fixing it. See `IntLiteralType` in typed_insts.h (or similar) for comparison.

github-actions bot added the toolchain label Oct 27, 2025

C++ Interop: Support getting void* from C++ functions and passing `…

9e73edf

…void*` it to C++ function 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.

bricknerb force-pushed the void2 branch from 66a6461 to 9e73edf Compare October 27, 2025 15:52

bricknerb marked this pull request as ready for review October 27, 2025 16:00

bricknerb requested a review from a team as a code owner October 27, 2025 16:00

bricknerb requested review from jonmeow and removed request for a team October 27, 2025 16:00

jonmeow reviewed Oct 27, 2025

View reviewed changes

bricknerb added 6 commits October 28, 2025 09:26

Replace <builtin Cpp.void> with Cpp.void when stringifying `Cpp.v…

f252405

…oid`.

Add tests for void** and const void*. Add support for const void*.

6f40fed

Rename CustomCppVoidType to CppVoidType.

6b7a510

Move StringifyInst() for CppVoidType between ConstType and `Cus…

3c45ed3

…tomLayoutType`.

Remove commented out code.

68bbebd

In TryMapVoidPointer(), early return if there are no wrapper types.

2b17f69

bricknerb commented Oct 28, 2025

View reviewed changes

Merge branch 'main' into void2

9b32c15

bricknerb requested a review from jonmeow October 28, 2025 13:25

Use CppVoidType::TypeInstId directly instead of indirectly.

7a08553

jonmeow approved these changes Oct 28, 2025

View reviewed changes

jonmeow mentioned this pull request Oct 28, 2025

Make applying const repeatedly to the same type have less additional effect. #6287

Merged

bricknerb added 3 commits October 29, 2025 09:18

Remove pointer_iter in TryMapVoidPointer() and erase the pointer …

c942df1

…type directly.

Have a dedicate BuildInfoForInst() for CppVoidType and a TODO to …

bce120f

…make it always-incomplete.

Merge branch 'main' into void2

3b8ce38

bricknerb enabled auto-merge October 29, 2025 08:27

bricknerb added this pull request to the merge queue Oct 29, 2025

Merged via the queue into carbon-language:trunk with commit 4d4d720 Oct 29, 2025
8 checks passed

bricknerb deleted the void2 branch October 29, 2025 09:45

jonmeow mentioned this pull request Oct 29, 2025

Fix Cpp.void stringification to be consistent with other singletons #6301

Merged

github-merge-queue bot pushed a commit that referenced this pull request Oct 30, 2025

Fix Cpp.void stringification to be consistent with other singletons (#…

356ea7f

…6301) I missed this in #6279, just fixing it. See `IntLiteralType` in typed_insts.h (or similar) for comparison.

		if (type_id == SemIR::CustomCppVoidType::TypeId && !wrapper_types.empty() &&
		context.types().Is<SemIR::PointerType>(wrapper_types.back())) {

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

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

Uh oh!

Conversation

bricknerb commented Oct 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jonmeow left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

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

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

bricknerb commented Oct 27, 2025 •

edited

Loading