From 1e47f29963ff81961b03531e2c36c28326a7caf3 Mon Sep 17 00:00:00 2001 From: Richard Smith Date: Tue, 16 Sep 2025 19:03:22 -0700 Subject: [PATCH] Add reference support to C++ interop. (#6082) For now this works as follows: * `T&&` is mapped to a by-value `param: T` parameter. * `T&` is mapped to an `addr param: T*` parameter. In either case, we will generate a thunk, which will internally pass the parameter as a pointer. --- toolchain/check/cpp_import.cpp | 36 +- toolchain/check/cpp_thunk.cpp | 33 +- .../function/arithmetic_types_bridged.carbon | 228 ------ .../function/arithmetic_types_direct.carbon | 227 ------ .../interop/cpp/function/reference.carbon | 755 ++++++++++++++++++ .../testdata/interop/cpp/reference.carbon | 179 +++++ 6 files changed, 990 insertions(+), 468 deletions(-) create mode 100644 toolchain/check/testdata/interop/cpp/function/reference.carbon create mode 100644 toolchain/lower/testdata/interop/cpp/reference.carbon diff --git a/toolchain/check/cpp_import.cpp b/toolchain/check/cpp_import.cpp index ed025f14cdf5..59ccac4dcb68 100644 --- a/toolchain/check/cpp_import.cpp +++ b/toolchain/check/cpp_import.cpp @@ -1393,22 +1393,32 @@ static auto MakeParamPatternsBlockId(Context& context, SemIR::LocId loc_id, // be cv-qualified. clang::QualType param_type = param->getType(); + // We map `T&` parameters to `addr param: T*`, and `T&&` parameters to + // `param: T`. + // TODO: Revisit this and decide what we really want to do here. + bool is_ref_param = param_type->isLValueReferenceType(); + param_type = param_type.getNonReferenceType(); + // Mark the start of a region of insts, needed for the type expression // created later with the call of `EndSubpatternAsExpr()`. BeginSubpattern(context); - auto [type_inst_id, type_id] = MapType(context, loc_id, param_type); + auto [orig_type_inst_id, type_id] = MapType(context, loc_id, param_type); // Type expression of the binding pattern - a single-entry/single-exit // region that allows control flow in the type expression e.g. fn F(x: if C // then i32 else i64). SemIR::ExprRegionId type_expr_region_id = - EndSubpatternAsExpr(context, type_inst_id); + EndSubpatternAsExpr(context, orig_type_inst_id); if (!type_id.has_value()) { context.TODO(loc_id, llvm::formatv("Unsupported: parameter type: {0}", - param_type.getAsString())); + param->getType().getAsString())); return SemIR::InstBlockId::None; } + if (is_ref_param) { + type_id = GetPointerType(context, orig_type_inst_id); + } + llvm::StringRef param_name = param->getName(); SemIR::NameId name_id = param_name.empty() @@ -1421,19 +1431,29 @@ static auto MakeParamPatternsBlockId(Context& context, SemIR::LocId loc_id, bool is_template = false; // TODO: Fix this once generics are supported. bool is_generic = false; - SemIR::InstId binding_pattern_id = + SemIR::InstId pattern_id = // TODO: Fill in a location once available. AddBindingPattern(context, SemIR::LocId::None, name_id, type_id, type_expr_region_id, is_generic, is_template) .pattern_id; - SemIR::InstId var_pattern_id = AddPatternInst( + pattern_id = AddPatternInst( context, // TODO: Fill in a location once available. SemIR::LocIdAndInst::NoLoc(SemIR::ValueParamPattern( - {.type_id = context.insts().Get(binding_pattern_id).type_id(), - .subpattern_id = binding_pattern_id, + {.type_id = context.insts().Get(pattern_id).type_id(), + .subpattern_id = pattern_id, .index = SemIR::CallParamIndex::None}))); - params.push_back(var_pattern_id); + if (is_ref_param) { + pattern_id = AddPatternInst( + context, + // TODO: Fill in a location once available. + SemIR::LocIdAndInst::NoLoc(SemIR::AddrPattern( + {.type_id = GetPatternType( + context, + context.types().GetTypeIdForTypeInstId(orig_type_inst_id)), + .inner_id = pattern_id}))); + } + params.push_back(pattern_id); } return context.inst_blocks().Add(params); } diff --git a/toolchain/check/cpp_thunk.cpp b/toolchain/check/cpp_thunk.cpp index 895f95dc96b7..77e57482d88b 100644 --- a/toolchain/check/cpp_thunk.cpp +++ b/toolchain/check/cpp_thunk.cpp @@ -89,6 +89,17 @@ auto IsCppThunkRequired(Context& context, const SemIR::Function& function) // we don't generate a thunk if any relevant type is erroneous. bool thunk_required = false; + // We require a thunk if any parameter is of reference type, even if the + // corresponding SemIR function has an acceptable parameter type. + // TODO: We should be able to avoid thunks for reference parameters. + const auto* decl = cast( + context.sem_ir().clang_decls().Get(function.clang_decl_id).decl); + for (auto* param : decl->parameters()) { + if (param->getType()->isReferenceType()) { + thunk_required = true; + } + } + SemIR::TypeId return_type_id = function.GetDeclaredReturnType(context.sem_ir()); if (return_type_id.has_value()) { @@ -217,7 +228,8 @@ static auto GetThunkParameterType(clang::ASTContext& ast_context, if (IsSimpleAbiType(ast_context, callee_type)) { return callee_type; } - return GetNonnullType(ast_context, ast_context.getPointerType(callee_type)); + return GetNonnullType(ast_context, ast_context.getPointerType( + callee_type.getNonReferenceType())); } // Creates the thunk parameter types given the callee function. @@ -358,13 +370,24 @@ static auto BuildThunkParamRef(clang::Sema& sema, thunk_param, thunk_param->getType().getNonReferenceType(), clang::VK_LValue, clang_loc); if (!type.isNull() && thunk_param->getType() != type) { - // TODO: Consider inserting a cast to an rvalue. Note that we currently - // pass pointers to non-temporary objects as the argument when calling a - // thunk, so we'll need to either change that or generate different thunks - // depending on whether we're moving from each parameter. clang::ExprResult deref_result = sema.BuildUnaryOp(nullptr, clang_loc, clang::UO_Deref, call_arg); CARBON_CHECK(deref_result.isUsable()); + + // Cast to an rvalue when initializing an rvalue reference. The validity of + // the initialization of the reference should be validated by the caller of + // the thunk. + // + // TODO: Consider inserting a cast to an rvalue in more cases. Note that we + // currently pass pointers to non-temporary objects as the argument when + // calling a thunk, so we'll need to either change that or generate + // different thunks depending on whether we're moving from each parameter. + if (type->isRValueReferenceType()) { + deref_result = clang::ImplicitCastExpr::Create( + sema.getASTContext(), deref_result.get()->getType(), clang::CK_NoOp, + deref_result.get(), nullptr, clang::ExprValueKind::VK_XValue, + clang::FPOptionsOverride()); + } call_arg = deref_result.get(); } return call_arg; diff --git a/toolchain/check/testdata/interop/cpp/function/arithmetic_types_bridged.carbon b/toolchain/check/testdata/interop/cpp/function/arithmetic_types_bridged.carbon index 9d1379ae6c4a..bc94d491924b 100644 --- a/toolchain/check/testdata/interop/cpp/function/arithmetic_types_bridged.carbon +++ b/toolchain/check/testdata/interop/cpp/function/arithmetic_types_bridged.carbon @@ -423,104 +423,6 @@ fn F() { //@dump-sem-ir-end } -// ============================================================================ -// short reference param -// ============================================================================ - -// --- short_ref_param.h - -auto foo(short& a) -> void; - -// --- fail_todo_import_short_ref_param.carbon - -library "[[@TEST_NAME]]"; - -import Cpp library "short_ref_param.h"; - -fn F() { - var a: i16 = 1; - //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_short_ref_param.carbon:[[@LINE+7]]:3: error: semantics TODO: `Unsupported: parameter type: short &` [SemanticsTodo] - // CHECK:STDERR: Cpp.foo(a); - // CHECK:STDERR: ^~~~~~~~~~ - // CHECK:STDERR: fail_todo_import_short_ref_param.carbon:[[@LINE+4]]:3: note: in call to Cpp function here [InCallToCppFunction] - // CHECK:STDERR: Cpp.foo(a); - // CHECK:STDERR: ^~~~~~~~~~ - // CHECK:STDERR: - Cpp.foo(a); - //@dump-sem-ir-end -} - -// ============================================================================ -// const short reference param -// ============================================================================ - -// --- const_short_ref_param.h - -auto foo(const short& a) -> void; - -// --- fail_todo_import_const_short_ref_param.carbon - -library "[[@TEST_NAME]]"; - -import Cpp library "const_short_ref_param.h"; - -fn F() { - var a: i16 = 1; - //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_const_short_ref_param.carbon:[[@LINE+7]]:3: error: semantics TODO: `Unsupported: parameter type: const short &` [SemanticsTodo] - // CHECK:STDERR: Cpp.foo(a); - // CHECK:STDERR: ^~~~~~~~~~ - // CHECK:STDERR: fail_todo_import_const_short_ref_param.carbon:[[@LINE+4]]:3: note: in call to Cpp function here [InCallToCppFunction] - // CHECK:STDERR: Cpp.foo(a); - // CHECK:STDERR: ^~~~~~~~~~ - // CHECK:STDERR: - Cpp.foo(a); - //@dump-sem-ir-end -} - -// ============================================================================ -// short pointer param -// ============================================================================ - -// --- short_pointer_param.h - -auto foo(short* _Nonnull a) -> void; - -// --- import_short_pointer_param.carbon - -library "[[@TEST_NAME]]"; - -import Cpp library "short_pointer_param.h"; - -fn F() { - var a: i16 = 1; - //@dump-sem-ir-begin - Cpp.foo(&a); - //@dump-sem-ir-end -} - -// ============================================================================ -// const short pointer param -// ============================================================================ - -// --- const_short_pointer_param.h - -auto foo(const short* _Nonnull a) -> void; - -// --- import_const_short_pointer_param.carbon - -library "[[@TEST_NAME]]"; - -import Cpp library "const_short_pointer_param.h"; - -fn F() { - var a: i16 = 1; - //@dump-sem-ir-begin - Cpp.foo(&a); - //@dump-sem-ir-end -} - // ============================================================================ // _Float16 param // ============================================================================ @@ -1931,136 +1833,6 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: --- fail_todo_import_short_ref_param.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %int_16: Core.IntLiteral = int_value 16 [concrete] -// CHECK:STDOUT: %i16: type = class_type @Int, @Int(%int_16) [concrete] -// CHECK:STDOUT: %.c5d: type = cpp_overload_set_type @ImplicitAs.Convert [concrete] -// CHECK:STDOUT: %empty_struct: %.c5d = struct_value () [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { -// CHECK:STDOUT: .foo = %.a21 -// CHECK:STDOUT: import Cpp//... -// CHECK:STDOUT: } -// CHECK:STDOUT: %.a21: %.c5d = cpp_overload_set_value @ImplicitAs.Convert [concrete = constants.%empty_struct] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F() { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %foo.ref: %.c5d = name_ref foo, imports.%.a21 [concrete = constants.%empty_struct] -// CHECK:STDOUT: %a.ref: ref %i16 = name_ref a, %a -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: --- fail_todo_import_const_short_ref_param.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %int_16: Core.IntLiteral = int_value 16 [concrete] -// CHECK:STDOUT: %i16: type = class_type @Int, @Int(%int_16) [concrete] -// CHECK:STDOUT: %.c5d: type = cpp_overload_set_type @ImplicitAs.Convert [concrete] -// CHECK:STDOUT: %empty_struct: %.c5d = struct_value () [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { -// CHECK:STDOUT: .foo = %.a21 -// CHECK:STDOUT: import Cpp//... -// CHECK:STDOUT: } -// CHECK:STDOUT: %.a21: %.c5d = cpp_overload_set_value @ImplicitAs.Convert [concrete = constants.%empty_struct] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F() { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %foo.ref: %.c5d = name_ref foo, imports.%.a21 [concrete = constants.%empty_struct] -// CHECK:STDOUT: %a.ref: ref %i16 = name_ref a, %a -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: --- import_short_pointer_param.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] -// CHECK:STDOUT: %int_16: Core.IntLiteral = int_value 16 [concrete] -// CHECK:STDOUT: %i16: type = class_type @Int, @Int(%int_16) [concrete] -// CHECK:STDOUT: %.c5d: type = cpp_overload_set_type @ImplicitAs.Convert [concrete] -// CHECK:STDOUT: %empty_struct: %.c5d = struct_value () [concrete] -// CHECK:STDOUT: %ptr.251: type = ptr_type %i16 [concrete] -// CHECK:STDOUT: %foo.type: type = fn_type @foo [concrete] -// CHECK:STDOUT: %foo: %foo.type = struct_value () [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { -// CHECK:STDOUT: .foo = %.a21 -// CHECK:STDOUT: import Cpp//... -// CHECK:STDOUT: } -// CHECK:STDOUT: %.a21: %.c5d = cpp_overload_set_value @ImplicitAs.Convert [concrete = constants.%empty_struct] -// CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { -// CHECK:STDOUT: -// CHECK:STDOUT: } { -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F() { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %foo.ref: %.c5d = name_ref foo, imports.%.a21 [concrete = constants.%empty_struct] -// CHECK:STDOUT: %a.ref: ref %i16 = name_ref a, %a -// CHECK:STDOUT: %addr.loc9: %ptr.251 = addr_of %a.ref -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call imports.%foo.decl(%addr.loc9) -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: --- import_const_short_pointer_param.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] -// CHECK:STDOUT: %int_16: Core.IntLiteral = int_value 16 [concrete] -// CHECK:STDOUT: %i16: type = class_type @Int, @Int(%int_16) [concrete] -// CHECK:STDOUT: %.c5d: type = cpp_overload_set_type @ImplicitAs.Convert [concrete] -// CHECK:STDOUT: %empty_struct: %.c5d = struct_value () [concrete] -// CHECK:STDOUT: %ptr.251: type = ptr_type %i16 [concrete] -// CHECK:STDOUT: %const: type = const_type %i16 [concrete] -// CHECK:STDOUT: %ptr.758: type = ptr_type %const [concrete] -// CHECK:STDOUT: %foo.type: type = fn_type @foo [concrete] -// CHECK:STDOUT: %foo: %foo.type = struct_value () [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { -// CHECK:STDOUT: .foo = %.a21 -// CHECK:STDOUT: import Cpp//... -// CHECK:STDOUT: } -// CHECK:STDOUT: %.a21: %.c5d = cpp_overload_set_value @ImplicitAs.Convert [concrete = constants.%empty_struct] -// CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { -// CHECK:STDOUT: -// CHECK:STDOUT: } { -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F() { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %foo.ref: %.c5d = name_ref foo, imports.%.a21 [concrete = constants.%empty_struct] -// CHECK:STDOUT: %a.ref: ref %i16 = name_ref a, %a -// CHECK:STDOUT: %addr.loc9: %ptr.251 = addr_of %a.ref -// CHECK:STDOUT: %.loc9_11.1: %ptr.758 = as_compatible %addr.loc9 -// CHECK:STDOUT: %.loc9_11.2: %ptr.758 = converted %addr.loc9, %.loc9_11.1 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call imports.%foo.decl(%.loc9_11.2) -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: // CHECK:STDOUT: --- import_float16_param.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { diff --git a/toolchain/check/testdata/interop/cpp/function/arithmetic_types_direct.carbon b/toolchain/check/testdata/interop/cpp/function/arithmetic_types_direct.carbon index 5aad8932e872..f60fd1cd15c7 100644 --- a/toolchain/check/testdata/interop/cpp/function/arithmetic_types_direct.carbon +++ b/toolchain/check/testdata/interop/cpp/function/arithmetic_types_direct.carbon @@ -327,104 +327,6 @@ fn F() { //@dump-sem-ir-end } -// ============================================================================ -// int reference param -// ============================================================================ - -// --- int_ref_param.h - -auto foo(int& a) -> int; - -// --- fail_todo_import_int_ref_param.carbon - -library "[[@TEST_NAME]]"; - -import Cpp library "int_ref_param.h"; - -fn F() { - var a: i32 = 1; - //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_int_ref_param.carbon:[[@LINE+7]]:3: error: semantics TODO: `Unsupported: parameter type: int &` [SemanticsTodo] - // CHECK:STDERR: Cpp.foo(a); - // CHECK:STDERR: ^~~~~~~~~~ - // CHECK:STDERR: fail_todo_import_int_ref_param.carbon:[[@LINE+4]]:3: note: in call to Cpp function here [InCallToCppFunction] - // CHECK:STDERR: Cpp.foo(a); - // CHECK:STDERR: ^~~~~~~~~~ - // CHECK:STDERR: - Cpp.foo(a); - //@dump-sem-ir-end -} - -// ============================================================================ -// const int reference param -// ============================================================================ - -// --- const_int_ref_param.h - -auto foo(const int& a) -> int; - -// --- fail_todo_import_const_int_ref_param.carbon - -library "[[@TEST_NAME]]"; - -import Cpp library "const_int_ref_param.h"; - -fn F() { - var a : i32 = 1; - //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_const_int_ref_param.carbon:[[@LINE+7]]:3: error: semantics TODO: `Unsupported: parameter type: const int &` [SemanticsTodo] - // CHECK:STDERR: Cpp.foo(a); - // CHECK:STDERR: ^~~~~~~~~~ - // CHECK:STDERR: fail_todo_import_const_int_ref_param.carbon:[[@LINE+4]]:3: note: in call to Cpp function here [InCallToCppFunction] - // CHECK:STDERR: Cpp.foo(a); - // CHECK:STDERR: ^~~~~~~~~~ - // CHECK:STDERR: - Cpp.foo(a); - //@dump-sem-ir-end -} - -// ============================================================================ -// int pointer param -// ============================================================================ - -// --- int_pointer_param.h - -auto foo(int* _Nonnull a) -> void; - -// --- import_int_pointer_param.carbon - -library "[[@TEST_NAME]]"; - -import Cpp library "int_pointer_param.h"; - -fn F() { - var a: i32 = 1; - //@dump-sem-ir-begin - Cpp.foo(&a); - //@dump-sem-ir-end -} - -// ============================================================================ -// const int pointer param -// ============================================================================ - -// --- const_int_pointer_param.h - -auto foo(const int* _Nonnull a) -> int; - -// --- import_const_int_pointer_param.carbon - -library "[[@TEST_NAME]]"; - -import Cpp library "const_int_pointer_param.h"; - -fn F() { - var a : i32 = 1; - //@dump-sem-ir-begin - Cpp.foo(&a); - //@dump-sem-ir-end -} - // ============================================================================ // int return // ============================================================================ @@ -1243,135 +1145,6 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: --- fail_todo_import_int_ref_param.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] -// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] -// CHECK:STDOUT: %.c5d: type = cpp_overload_set_type @ImplicitAs.Convert [concrete] -// CHECK:STDOUT: %empty_struct: %.c5d = struct_value () [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { -// CHECK:STDOUT: .foo = %.a21 -// CHECK:STDOUT: import Cpp//... -// CHECK:STDOUT: } -// CHECK:STDOUT: %.a21: %.c5d = cpp_overload_set_value @ImplicitAs.Convert [concrete = constants.%empty_struct] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F() { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %foo.ref: %.c5d = name_ref foo, imports.%.a21 [concrete = constants.%empty_struct] -// CHECK:STDOUT: %a.ref: ref %i32 = name_ref a, %a -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: --- fail_todo_import_const_int_ref_param.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] -// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] -// CHECK:STDOUT: %.c5d: type = cpp_overload_set_type @ImplicitAs.Convert [concrete] -// CHECK:STDOUT: %empty_struct: %.c5d = struct_value () [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { -// CHECK:STDOUT: .foo = %.a21 -// CHECK:STDOUT: import Cpp//... -// CHECK:STDOUT: } -// CHECK:STDOUT: %.a21: %.c5d = cpp_overload_set_value @ImplicitAs.Convert [concrete = constants.%empty_struct] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F() { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %foo.ref: %.c5d = name_ref foo, imports.%.a21 [concrete = constants.%empty_struct] -// CHECK:STDOUT: %a.ref: ref %i32 = name_ref a, %a -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: --- import_int_pointer_param.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] -// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] -// CHECK:STDOUT: %.c5d: type = cpp_overload_set_type @ImplicitAs.Convert [concrete] -// CHECK:STDOUT: %empty_struct: %.c5d = struct_value () [concrete] -// CHECK:STDOUT: %ptr.235: type = ptr_type %i32 [concrete] -// CHECK:STDOUT: %foo.type: type = fn_type @foo [concrete] -// CHECK:STDOUT: %foo: %foo.type = struct_value () [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { -// CHECK:STDOUT: .foo = %.a21 -// CHECK:STDOUT: import Cpp//... -// CHECK:STDOUT: } -// CHECK:STDOUT: %.a21: %.c5d = cpp_overload_set_value @ImplicitAs.Convert [concrete = constants.%empty_struct] -// CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { -// CHECK:STDOUT: -// CHECK:STDOUT: } { -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F() { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %foo.ref: %.c5d = name_ref foo, imports.%.a21 [concrete = constants.%empty_struct] -// CHECK:STDOUT: %a.ref: ref %i32 = name_ref a, %a -// CHECK:STDOUT: %addr.loc9: %ptr.235 = addr_of %a.ref -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call imports.%foo.decl(%addr.loc9) -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: --- import_const_int_pointer_param.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] -// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] -// CHECK:STDOUT: %.c5d: type = cpp_overload_set_type @ImplicitAs.Convert [concrete] -// CHECK:STDOUT: %empty_struct: %.c5d = struct_value () [concrete] -// CHECK:STDOUT: %ptr.235: type = ptr_type %i32 [concrete] -// CHECK:STDOUT: %const: type = const_type %i32 [concrete] -// CHECK:STDOUT: %ptr.36b: type = ptr_type %const [concrete] -// CHECK:STDOUT: %foo.type: type = fn_type @foo [concrete] -// CHECK:STDOUT: %foo: %foo.type = struct_value () [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { -// CHECK:STDOUT: .foo = %.a21 -// CHECK:STDOUT: import Cpp//... -// CHECK:STDOUT: } -// CHECK:STDOUT: %.a21: %.c5d = cpp_overload_set_value @ImplicitAs.Convert [concrete = constants.%empty_struct] -// CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { -// CHECK:STDOUT: -// CHECK:STDOUT: } { -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F() { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %foo.ref: %.c5d = name_ref foo, imports.%.a21 [concrete = constants.%empty_struct] -// CHECK:STDOUT: %a.ref: ref %i32 = name_ref a, %a -// CHECK:STDOUT: %addr.loc9: %ptr.235 = addr_of %a.ref -// CHECK:STDOUT: %.loc9_11.1: %ptr.36b = as_compatible %addr.loc9 -// CHECK:STDOUT: %.loc9_11.2: %ptr.36b = converted %addr.loc9, %.loc9_11.1 -// CHECK:STDOUT: %foo.call: init %i32 = call imports.%foo.decl(%.loc9_11.2) -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: // CHECK:STDOUT: --- import_int_return.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { diff --git a/toolchain/check/testdata/interop/cpp/function/reference.carbon b/toolchain/check/testdata/interop/cpp/function/reference.carbon new file mode 100644 index 000000000000..002ecc18ddaf --- /dev/null +++ b/toolchain/check/testdata/interop/cpp/function/reference.carbon @@ -0,0 +1,755 @@ +// Part of the Carbon Language 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-FILE: toolchain/testing/testdata/min_prelude/convert.carbon +// +// AUTOUPDATE +// TIP: To test this file alone, run: +// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/interop/cpp/function/reference.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/interop/cpp/function/reference.carbon + +// ============================================================================ +// Lvalue reference as a parameter type +// ============================================================================ + +// --- lvalue_ref.h + +struct S {}; +struct T {}; + +auto TakesLValue(S&) -> void; + +// --- call_lvalue_ref.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "lvalue_ref.h"; + +fn F() { + //@dump-sem-ir-begin + var s: Cpp.S = {}; + Cpp.TakesLValue(s); + //@dump-sem-ir-end +} + +// --- fail_lvalue_ref.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "lvalue_ref.h"; + +fn F() { + //@dump-sem-ir-begin + var v: Cpp.S; + let s: Cpp.S = v; + // CHECK:STDERR: fail_lvalue_ref.carbon:[[@LINE+7]]:3: error: no matching function for call to `TakesLValue` [CppOverloadingNoViableFunctionFound] + // CHECK:STDERR: Cpp.TakesLValue(s); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_lvalue_ref.carbon:[[@LINE+4]]:3: note: in call to Cpp function here [InCallToCppFunction] + // CHECK:STDERR: Cpp.TakesLValue(s); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: + Cpp.TakesLValue(s); + + var t: Cpp.T; + // CHECK:STDERR: fail_lvalue_ref.carbon:[[@LINE+7]]:3: error: no matching function for call to `TakesLValue` [CppOverloadingNoViableFunctionFound] + // CHECK:STDERR: Cpp.TakesLValue(t); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_lvalue_ref.carbon:[[@LINE+4]]:3: note: in call to Cpp function here [InCallToCppFunction] + // CHECK:STDERR: Cpp.TakesLValue(t); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: + Cpp.TakesLValue(t); + + var u: Cpp.S; + // CHECK:STDERR: fail_lvalue_ref.carbon:[[@LINE+7]]:3: error: no matching function for call to `TakesLValue` [CppOverloadingNoViableFunctionFound] + // CHECK:STDERR: Cpp.TakesLValue(u as const Cpp.S); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_lvalue_ref.carbon:[[@LINE+4]]:3: note: in call to Cpp function here [InCallToCppFunction] + // CHECK:STDERR: Cpp.TakesLValue(u as const Cpp.S); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: + Cpp.TakesLValue(u as const Cpp.S); + //@dump-sem-ir-end +} + +// ============================================================================ +// Rvalue reference as a parameter type +// ============================================================================ + +// --- rvalue_ref.h + +struct S {}; +struct T {}; + +auto TakesRValue(S&&) -> void; + +// --- call_rvalue_ref.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "rvalue_ref.h"; + +fn F() { + //@dump-sem-ir-begin + Cpp.TakesRValue({} as Cpp.S); + //@dump-sem-ir-end +} + +// --- todo_fail_value_arg_for_rvalue_ref.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "rvalue_ref.h"; + +fn F() { + //@dump-sem-ir-begin + // TODO: We should probably reject binding an rvalue reference to a value + // expression. If we don't reject, we should instead force a copy to be made, + // at least if the type has a pointer value representation, so that moving + // from the reference doesn't alter tne original value. + let s: Cpp.S = {}; + Cpp.TakesRValue(s); + //@dump-sem-ir-end +} + +// --- fail_rvalue_ref.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "rvalue_ref.h"; + +fn F() { + //@dump-sem-ir-begin + var s: Cpp.S; + // CHECK:STDERR: fail_rvalue_ref.carbon:[[@LINE+7]]:3: error: no matching function for call to `TakesRValue` [CppOverloadingNoViableFunctionFound] + // CHECK:STDERR: Cpp.TakesRValue(s); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_rvalue_ref.carbon:[[@LINE+4]]:3: note: in call to Cpp function here [InCallToCppFunction] + // CHECK:STDERR: Cpp.TakesRValue(s); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: + Cpp.TakesRValue(s); + + var t: Cpp.T; + // CHECK:STDERR: fail_rvalue_ref.carbon:[[@LINE+7]]:3: error: no matching function for call to `TakesRValue` [CppOverloadingNoViableFunctionFound] + // CHECK:STDERR: Cpp.TakesRValue(t); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_rvalue_ref.carbon:[[@LINE+4]]:3: note: in call to Cpp function here [InCallToCppFunction] + // CHECK:STDERR: Cpp.TakesRValue(t); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: + Cpp.TakesRValue(t); + + // CHECK:STDERR: fail_rvalue_ref.carbon:[[@LINE+7]]:3: error: no matching function for call to `TakesRValue` [CppOverloadingNoViableFunctionFound] + // CHECK:STDERR: Cpp.TakesRValue(({} as Cpp.S) as const Cpp.S); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_rvalue_ref.carbon:[[@LINE+4]]:3: note: in call to Cpp function here [InCallToCppFunction] + // CHECK:STDERR: Cpp.TakesRValue(({} as Cpp.S) as const Cpp.S); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: + Cpp.TakesRValue(({} as Cpp.S) as const Cpp.S); + //@dump-sem-ir-end +} + +// ============================================================================ +// Const reference as a parameter type +// ============================================================================ + +// --- const_lvalue_ref.h + +struct S {}; +struct T {}; + +auto TakesConstLValue(const S&) -> void; + +// --- call_const_lvalue_ref.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "const_lvalue_ref.h"; + +fn F() { + //@dump-sem-ir-begin + var s: Cpp.S = {}; + Cpp.TakesConstLValue(s as const Cpp.S); + + Cpp.TakesConstLValue(s); + //@dump-sem-ir-end +} + +// --- fail_const_lvalue_ref.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "const_lvalue_ref.h"; + +fn F() { + //@dump-sem-ir-begin + // TODO: Should this work? We could create a temporary. Overload resolution + // accepts this but the Carbon-side call fails. + // TODO: The diagnostic here is wrong; we're internally using `addr` but this + // is not `addr self`. + let s: Cpp.S = {}; + // CHECK:STDERR: fail_const_lvalue_ref.carbon:[[@LINE+5]]:24: error: `addr self` method cannot be invoked on a value [AddrSelfIsNonRef] + // CHECK:STDERR: Cpp.TakesConstLValue(s); + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_const_lvalue_ref.carbon: note: initializing function parameter [InCallToFunctionParam] + // CHECK:STDERR: + Cpp.TakesConstLValue(s); + + var t: Cpp.T; + // CHECK:STDERR: fail_const_lvalue_ref.carbon:[[@LINE+7]]:3: error: no matching function for call to `TakesConstLValue` [CppOverloadingNoViableFunctionFound] + // CHECK:STDERR: Cpp.TakesConstLValue(t); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_const_lvalue_ref.carbon:[[@LINE+4]]:3: note: in call to Cpp function here [InCallToCppFunction] + // CHECK:STDERR: Cpp.TakesConstLValue(t); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: + Cpp.TakesConstLValue(t); + //@dump-sem-ir-end +} + +// CHECK:STDOUT: --- call_lvalue_ref.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %S: type = class_type @S [concrete] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [concrete] +// CHECK:STDOUT: %pattern_type.7da: type = pattern_type %S [concrete] +// CHECK:STDOUT: %S.val: %S = struct_value () [concrete] +// CHECK:STDOUT: %.547: type = cpp_overload_set_type @TakesLValue [concrete] +// CHECK:STDOUT: %empty_struct: %.547 = struct_value () [concrete] +// CHECK:STDOUT: %ptr.5c7: type = ptr_type %S [concrete] +// CHECK:STDOUT: %TakesLValue__carbon_thunk.type: type = fn_type @TakesLValue__carbon_thunk [concrete] +// CHECK:STDOUT: %TakesLValue__carbon_thunk: %TakesLValue__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.type.d46: type = fn_type @T.as.Destroy.impl.Op, @T.as.Destroy.impl(%S) [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.062: %T.as.Destroy.impl.Op.type.d46 = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .S = %S.decl +// CHECK:STDOUT: .TakesLValue = %.a7f +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} +// CHECK:STDOUT: %.a7f: %.547 = cpp_overload_set_value @TakesLValue [concrete = constants.%empty_struct] +// CHECK:STDOUT: %TakesLValue__carbon_thunk.decl: %TakesLValue__carbon_thunk.type = fn_decl @TakesLValue__carbon_thunk [concrete = constants.%TakesLValue__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %s.patt: %pattern_type.7da = binding_pattern s [concrete] +// CHECK:STDOUT: %s.var_patt: %pattern_type.7da = var_pattern %s.patt [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.var: ref %S = var %s.var_patt +// CHECK:STDOUT: %.loc8_19.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc8_19.2: init %S = class_init (), %s.var [concrete = constants.%S.val] +// CHECK:STDOUT: %.loc8_3: init %S = converted %.loc8_19.1, %.loc8_19.2 [concrete = constants.%S.val] +// CHECK:STDOUT: assign %s.var, %.loc8_3 +// CHECK:STDOUT: %.loc8_13: type = splice_block %S.ref [concrete = constants.%S] { +// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s: ref %S = bind_name s, %s.var +// CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesLValue.ref: %.547 = name_ref TakesLValue, imports.%.a7f [concrete = constants.%empty_struct] +// CHECK:STDOUT: %s.ref: ref %S = name_ref s, %s +// CHECK:STDOUT: %addr.loc9: %ptr.5c7 = addr_of %s.ref +// CHECK:STDOUT: %TakesLValue__carbon_thunk.call: init %empty_tuple.type = call imports.%TakesLValue__carbon_thunk.decl(%addr.loc9) +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %s.var, constants.%T.as.Destroy.impl.Op.062 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method: = bound_method %s.var, %T.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %addr.loc8: %ptr.5c7 = addr_of %s.var +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr.loc8) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_lvalue_ref.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %S: type = class_type @S [concrete] +// CHECK:STDOUT: %pattern_type.7da: type = pattern_type %S [concrete] +// CHECK:STDOUT: %.547: type = cpp_overload_set_type @Destroy.Op [concrete] +// CHECK:STDOUT: %empty_struct: %.547 = struct_value () [concrete] +// CHECK:STDOUT: %T.e15: type = class_type @T [concrete] +// CHECK:STDOUT: %pattern_type.e6b: type = pattern_type %T.e15 [concrete] +// CHECK:STDOUT: %const: type = const_type %S [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.type.d46: type = fn_type @T.as.Destroy.impl.Op, @T.as.Destroy.impl(%S) [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.062: %T.as.Destroy.impl.Op.type.d46 = struct_value () [concrete] +// CHECK:STDOUT: %ptr.5c7: type = ptr_type %S [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.type.559: type = fn_type @T.as.Destroy.impl.Op, @T.as.Destroy.impl(%T.e15) [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.b53: %T.as.Destroy.impl.Op.type.559 = struct_value () [concrete] +// CHECK:STDOUT: %ptr.b04: type = ptr_type %T.e15 [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .S = %S.decl +// CHECK:STDOUT: .TakesLValue = %.a7f +// CHECK:STDOUT: .T = %T.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} +// CHECK:STDOUT: %.a7f: %.547 = cpp_overload_set_value @Destroy.Op [concrete = constants.%empty_struct] +// CHECK:STDOUT: %T.decl: type = class_decl @T [concrete = constants.%T.e15] {} {} +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %v.patt: %pattern_type.7da = binding_pattern v [concrete] +// CHECK:STDOUT: %v.var_patt: %pattern_type.7da = var_pattern %v.patt [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %v.var: ref %S = var %v.var_patt +// CHECK:STDOUT: %.loc8: type = splice_block %S.ref.loc8 [concrete = constants.%S] { +// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref.loc8: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: } +// CHECK:STDOUT: %v: ref %S = bind_name v, %v.var +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %s.patt: %pattern_type.7da = binding_pattern s [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %v.ref: ref %S = name_ref v, %v +// CHECK:STDOUT: %.loc9_13: type = splice_block %S.ref.loc9 [concrete = constants.%S] { +// CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref.loc9: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc9_18: %S = bind_value %v.ref +// CHECK:STDOUT: %s: %S = bind_name s, %.loc9_18 +// CHECK:STDOUT: %Cpp.ref.loc17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesLValue.ref.loc17: %.547 = name_ref TakesLValue, imports.%.a7f [concrete = constants.%empty_struct] +// CHECK:STDOUT: %s.ref: %S = name_ref s, %s +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %t.patt: %pattern_type.e6b = binding_pattern t [concrete] +// CHECK:STDOUT: %t.var_patt: %pattern_type.e6b = var_pattern %t.patt [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %t.var: ref %T.e15 = var %t.var_patt +// CHECK:STDOUT: %.loc19: type = splice_block %T.ref [concrete = constants.%T.e15] { +// CHECK:STDOUT: %Cpp.ref.loc19: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %T.ref: type = name_ref T, imports.%T.decl [concrete = constants.%T.e15] +// CHECK:STDOUT: } +// CHECK:STDOUT: %t: ref %T.e15 = bind_name t, %t.var +// CHECK:STDOUT: %Cpp.ref.loc27: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesLValue.ref.loc27: %.547 = name_ref TakesLValue, imports.%.a7f [concrete = constants.%empty_struct] +// CHECK:STDOUT: %t.ref: ref %T.e15 = name_ref t, %t +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %u.patt: %pattern_type.7da = binding_pattern u [concrete] +// CHECK:STDOUT: %u.var_patt: %pattern_type.7da = var_pattern %u.patt [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %u.var: ref %S = var %u.var_patt +// CHECK:STDOUT: %.loc29: type = splice_block %S.ref.loc29 [concrete = constants.%S] { +// CHECK:STDOUT: %Cpp.ref.loc29: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref.loc29: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: } +// CHECK:STDOUT: %u: ref %S = bind_name u, %u.var +// CHECK:STDOUT: %Cpp.ref.loc37_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesLValue.ref.loc37: %.547 = name_ref TakesLValue, imports.%.a7f [concrete = constants.%empty_struct] +// CHECK:STDOUT: %u.ref: ref %S = name_ref u, %u +// CHECK:STDOUT: %Cpp.ref.loc37_30: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref.loc37: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: %const: type = const_type %S.ref.loc37 [concrete = constants.%const] +// CHECK:STDOUT: %.loc37_21.1: ref %const = as_compatible %u.ref +// CHECK:STDOUT: %.loc37_21.2: ref %const = converted %u.ref, %.loc37_21.1 +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc29: = bound_method %u.var, constants.%T.as.Destroy.impl.Op.062 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc29: = bound_method %u.var, %T.as.Destroy.impl.Op.specific_fn.1 +// CHECK:STDOUT: %addr.loc29: %ptr.5c7 = addr_of %u.var +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call.loc29: init %empty_tuple.type = call %bound_method.loc29(%addr.loc29) +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc19: = bound_method %t.var, constants.%T.as.Destroy.impl.Op.b53 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc19: = bound_method %t.var, %T.as.Destroy.impl.Op.specific_fn.2 +// CHECK:STDOUT: %addr.loc19: %ptr.b04 = addr_of %t.var +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call.loc19: init %empty_tuple.type = call %bound_method.loc19(%addr.loc19) +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc8: = bound_method %v.var, constants.%T.as.Destroy.impl.Op.062 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc8: = bound_method %v.var, %T.as.Destroy.impl.Op.specific_fn.3 +// CHECK:STDOUT: %addr.loc8: %ptr.5c7 = addr_of %v.var +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call.loc8: init %empty_tuple.type = call %bound_method.loc8(%addr.loc8) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- call_rvalue_ref.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %S: type = class_type @S [concrete] +// CHECK:STDOUT: %.1b9: type = cpp_overload_set_type @TakesRValue [concrete] +// CHECK:STDOUT: %empty_struct: %.1b9 = struct_value () [concrete] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [concrete] +// CHECK:STDOUT: %S.val: %S = struct_value () [concrete] +// CHECK:STDOUT: %ptr.5c7: type = ptr_type %S [concrete] +// CHECK:STDOUT: %TakesRValue__carbon_thunk.type: type = fn_type @TakesRValue__carbon_thunk [concrete] +// CHECK:STDOUT: %TakesRValue__carbon_thunk: %TakesRValue__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.type.d46: type = fn_type @T.as.Destroy.impl.Op, @T.as.Destroy.impl(%S) [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.062: %T.as.Destroy.impl.Op.type.d46 = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .TakesRValue = %.1f6 +// CHECK:STDOUT: .S = %S.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} +// CHECK:STDOUT: %.1f6: %.1b9 = cpp_overload_set_value @TakesRValue [concrete = constants.%empty_struct] +// CHECK:STDOUT: %TakesRValue__carbon_thunk.decl: %TakesRValue__carbon_thunk.type = fn_decl @TakesRValue__carbon_thunk [concrete = constants.%TakesRValue__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesRValue.ref: %.1b9 = name_ref TakesRValue, imports.%.1f6 [concrete = constants.%empty_struct] +// CHECK:STDOUT: %.loc8_20.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_25: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: %.loc8_20.2: ref %S = temporary_storage +// CHECK:STDOUT: %.loc8_20.3: init %S = class_init (), %.loc8_20.2 [concrete = constants.%S.val] +// CHECK:STDOUT: %.loc8_20.4: ref %S = temporary %.loc8_20.2, %.loc8_20.3 +// CHECK:STDOUT: %.loc8_22.1: ref %S = converted %.loc8_20.1, %.loc8_20.4 +// CHECK:STDOUT: %.loc8_22.2: %S = bind_value %.loc8_22.1 +// CHECK:STDOUT: %.loc8_22.3: ref %S = value_as_ref %.loc8_22.2 +// CHECK:STDOUT: %addr.loc8_30: %ptr.5c7 = addr_of %.loc8_22.3 +// CHECK:STDOUT: %TakesRValue__carbon_thunk.call: init %empty_tuple.type = call imports.%TakesRValue__carbon_thunk.decl(%addr.loc8_30) +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc8_20.4, constants.%T.as.Destroy.impl.Op.062 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method: = bound_method %.loc8_20.4, %T.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %addr.loc8_20: %ptr.5c7 = addr_of %.loc8_20.4 +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr.loc8_20) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- todo_fail_value_arg_for_rvalue_ref.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %S: type = class_type @S [concrete] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [concrete] +// CHECK:STDOUT: %pattern_type.7da: type = pattern_type %S [concrete] +// CHECK:STDOUT: %S.val: %S = struct_value () [concrete] +// CHECK:STDOUT: %.1b9: type = cpp_overload_set_type @TakesRValue [concrete] +// CHECK:STDOUT: %empty_struct: %.1b9 = struct_value () [concrete] +// CHECK:STDOUT: %ptr.5c7: type = ptr_type %S [concrete] +// CHECK:STDOUT: %TakesRValue__carbon_thunk.type: type = fn_type @TakesRValue__carbon_thunk [concrete] +// CHECK:STDOUT: %TakesRValue__carbon_thunk: %TakesRValue__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.type.d46: type = fn_type @T.as.Destroy.impl.Op, @T.as.Destroy.impl(%S) [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.062: %T.as.Destroy.impl.Op.type.d46 = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .S = %S.decl +// CHECK:STDOUT: .TakesRValue = %.1f6 +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} +// CHECK:STDOUT: %.1f6: %.1b9 = cpp_overload_set_value @TakesRValue [concrete = constants.%empty_struct] +// CHECK:STDOUT: %TakesRValue__carbon_thunk.decl: %TakesRValue__carbon_thunk.type = fn_decl @TakesRValue__carbon_thunk [concrete = constants.%TakesRValue__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %s.patt: %pattern_type.7da = binding_pattern s [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc12_19.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc12_13: type = splice_block %S.ref [concrete = constants.%S] { +// CHECK:STDOUT: %Cpp.ref.loc12: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc12_19.2: ref %S = temporary_storage +// CHECK:STDOUT: %.loc12_19.3: init %S = class_init (), %.loc12_19.2 [concrete = constants.%S.val] +// CHECK:STDOUT: %.loc12_19.4: ref %S = temporary %.loc12_19.2, %.loc12_19.3 +// CHECK:STDOUT: %.loc12_19.5: ref %S = converted %.loc12_19.1, %.loc12_19.4 +// CHECK:STDOUT: %.loc12_19.6: %S = bind_value %.loc12_19.5 +// CHECK:STDOUT: %s: %S = bind_name s, %.loc12_19.6 +// CHECK:STDOUT: %Cpp.ref.loc13: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesRValue.ref: %.1b9 = name_ref TakesRValue, imports.%.1f6 [concrete = constants.%empty_struct] +// CHECK:STDOUT: %s.ref: %S = name_ref s, %s +// CHECK:STDOUT: %.loc13: ref %S = value_as_ref %s.ref +// CHECK:STDOUT: %addr.loc13: %ptr.5c7 = addr_of %.loc13 +// CHECK:STDOUT: %TakesRValue__carbon_thunk.call: init %empty_tuple.type = call imports.%TakesRValue__carbon_thunk.decl(%addr.loc13) +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc12_19.4, constants.%T.as.Destroy.impl.Op.062 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method: = bound_method %.loc12_19.4, %T.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %addr.loc12: %ptr.5c7 = addr_of %.loc12_19.4 +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr.loc12) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_rvalue_ref.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %S: type = class_type @S [concrete] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [concrete] +// CHECK:STDOUT: %pattern_type.7da: type = pattern_type %S [concrete] +// CHECK:STDOUT: %.1b9: type = cpp_overload_set_type @Destroy.Op [concrete] +// CHECK:STDOUT: %empty_struct: %.1b9 = struct_value () [concrete] +// CHECK:STDOUT: %T.e15: type = class_type @T [concrete] +// CHECK:STDOUT: %pattern_type.e6b: type = pattern_type %T.e15 [concrete] +// CHECK:STDOUT: %S.val: %S = struct_value () [concrete] +// CHECK:STDOUT: %const: type = const_type %S [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.type.d46: type = fn_type @T.as.Destroy.impl.Op, @T.as.Destroy.impl(%S) [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.062: %T.as.Destroy.impl.Op.type.d46 = struct_value () [concrete] +// CHECK:STDOUT: %ptr.5c7: type = ptr_type %S [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.type.559: type = fn_type @T.as.Destroy.impl.Op, @T.as.Destroy.impl(%T.e15) [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.b53: %T.as.Destroy.impl.Op.type.559 = struct_value () [concrete] +// CHECK:STDOUT: %ptr.b04: type = ptr_type %T.e15 [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .S = %S.decl +// CHECK:STDOUT: .TakesRValue = %.1f6 +// CHECK:STDOUT: .T = %T.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} +// CHECK:STDOUT: %.1f6: %.1b9 = cpp_overload_set_value @Destroy.Op [concrete = constants.%empty_struct] +// CHECK:STDOUT: %T.decl: type = class_decl @T [concrete = constants.%T.e15] {} {} +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %s.patt: %pattern_type.7da = binding_pattern s [concrete] +// CHECK:STDOUT: %s.var_patt: %pattern_type.7da = var_pattern %s.patt [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.var: ref %S = var %s.var_patt +// CHECK:STDOUT: %.loc8: type = splice_block %S.ref.loc8 [concrete = constants.%S] { +// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref.loc8: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s: ref %S = bind_name s, %s.var +// CHECK:STDOUT: %Cpp.ref.loc16: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesRValue.ref.loc16: %.1b9 = name_ref TakesRValue, imports.%.1f6 [concrete = constants.%empty_struct] +// CHECK:STDOUT: %s.ref: ref %S = name_ref s, %s +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %t.patt: %pattern_type.e6b = binding_pattern t [concrete] +// CHECK:STDOUT: %t.var_patt: %pattern_type.e6b = var_pattern %t.patt [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %t.var: ref %T.e15 = var %t.var_patt +// CHECK:STDOUT: %.loc18: type = splice_block %T.ref [concrete = constants.%T.e15] { +// CHECK:STDOUT: %Cpp.ref.loc18: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %T.ref: type = name_ref T, imports.%T.decl [concrete = constants.%T.e15] +// CHECK:STDOUT: } +// CHECK:STDOUT: %t: ref %T.e15 = bind_name t, %t.var +// CHECK:STDOUT: %Cpp.ref.loc26: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesRValue.ref.loc26: %.1b9 = name_ref TakesRValue, imports.%.1f6 [concrete = constants.%empty_struct] +// CHECK:STDOUT: %t.ref: ref %T.e15 = name_ref t, %t +// CHECK:STDOUT: %Cpp.ref.loc35_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesRValue.ref.loc35: %.1b9 = name_ref TakesRValue, imports.%.1f6 [concrete = constants.%empty_struct] +// CHECK:STDOUT: %.loc35_21.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc35_26: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref.loc35_29: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: %.loc35_21.2: ref %S = temporary_storage +// CHECK:STDOUT: %.loc35_21.3: init %S = class_init (), %.loc35_21.2 [concrete = constants.%S.val] +// CHECK:STDOUT: %.loc35_21.4: ref %S = temporary %.loc35_21.2, %.loc35_21.3 +// CHECK:STDOUT: %.loc35_23: ref %S = converted %.loc35_21.1, %.loc35_21.4 +// CHECK:STDOUT: %Cpp.ref.loc35_42: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref.loc35_45: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: %const: type = const_type %S.ref.loc35_45 [concrete = constants.%const] +// CHECK:STDOUT: %.loc35_33.1: ref %const = as_compatible %.loc35_23 +// CHECK:STDOUT: %.loc35_33.2: ref %const = converted %.loc35_23, %.loc35_33.1 +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc35: = bound_method %.loc35_21.4, constants.%T.as.Destroy.impl.Op.062 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc35: = bound_method %.loc35_21.4, %T.as.Destroy.impl.Op.specific_fn.1 +// CHECK:STDOUT: %addr.loc35: %ptr.5c7 = addr_of %.loc35_21.4 +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call.loc35: init %empty_tuple.type = call %bound_method.loc35(%addr.loc35) +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc18: = bound_method %t.var, constants.%T.as.Destroy.impl.Op.b53 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc18: = bound_method %t.var, %T.as.Destroy.impl.Op.specific_fn.2 +// CHECK:STDOUT: %addr.loc18: %ptr.b04 = addr_of %t.var +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call.loc18: init %empty_tuple.type = call %bound_method.loc18(%addr.loc18) +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc8: = bound_method %s.var, constants.%T.as.Destroy.impl.Op.062 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc8: = bound_method %s.var, %T.as.Destroy.impl.Op.specific_fn.3 +// CHECK:STDOUT: %addr.loc8: %ptr.5c7 = addr_of %s.var +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call.loc8: init %empty_tuple.type = call %bound_method.loc8(%addr.loc8) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- call_const_lvalue_ref.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %S: type = class_type @S [concrete] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [concrete] +// CHECK:STDOUT: %pattern_type.7da: type = pattern_type %S [concrete] +// CHECK:STDOUT: %S.val: %S = struct_value () [concrete] +// CHECK:STDOUT: %.4e1: type = cpp_overload_set_type @TakesConstLValue [concrete] +// CHECK:STDOUT: %empty_struct: %.4e1 = struct_value () [concrete] +// CHECK:STDOUT: %const: type = const_type %S [concrete] +// CHECK:STDOUT: %ptr.ff5: type = ptr_type %const [concrete] +// CHECK:STDOUT: %TakesConstLValue__carbon_thunk.type: type = fn_type @TakesConstLValue__carbon_thunk [concrete] +// CHECK:STDOUT: %TakesConstLValue__carbon_thunk: %TakesConstLValue__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %ptr.5c7: type = ptr_type %S [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.type.d46: type = fn_type @T.as.Destroy.impl.Op, @T.as.Destroy.impl(%S) [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.062: %T.as.Destroy.impl.Op.type.d46 = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .S = %S.decl +// CHECK:STDOUT: .TakesConstLValue = %.9bc +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} +// CHECK:STDOUT: %.9bc: %.4e1 = cpp_overload_set_value @TakesConstLValue [concrete = constants.%empty_struct] +// CHECK:STDOUT: %TakesConstLValue__carbon_thunk.decl: %TakesConstLValue__carbon_thunk.type = fn_decl @TakesConstLValue__carbon_thunk [concrete = constants.%TakesConstLValue__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %s.patt: %pattern_type.7da = binding_pattern s [concrete] +// CHECK:STDOUT: %s.var_patt: %pattern_type.7da = var_pattern %s.patt [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.var: ref %S = var %s.var_patt +// CHECK:STDOUT: %.loc8_19.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc8_19.2: init %S = class_init (), %s.var [concrete = constants.%S.val] +// CHECK:STDOUT: %.loc8_3: init %S = converted %.loc8_19.1, %.loc8_19.2 [concrete = constants.%S.val] +// CHECK:STDOUT: assign %s.var, %.loc8_3 +// CHECK:STDOUT: %.loc8_13: type = splice_block %S.ref.loc8 [concrete = constants.%S] { +// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref.loc8: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s: ref %S = bind_name s, %s.var +// CHECK:STDOUT: %Cpp.ref.loc9_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesConstLValue.ref.loc9: %.4e1 = name_ref TakesConstLValue, imports.%.9bc [concrete = constants.%empty_struct] +// CHECK:STDOUT: %s.ref.loc9: ref %S = name_ref s, %s +// CHECK:STDOUT: %Cpp.ref.loc9_35: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref.loc9: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: %const: type = const_type %S.ref.loc9 [concrete = constants.%const] +// CHECK:STDOUT: %.loc9_26.1: ref %const = as_compatible %s.ref.loc9 +// CHECK:STDOUT: %.loc9_26.2: ref %const = converted %s.ref.loc9, %.loc9_26.1 +// CHECK:STDOUT: %addr.loc9: %ptr.ff5 = addr_of %.loc9_26.2 +// CHECK:STDOUT: %TakesConstLValue__carbon_thunk.call.loc9: init %empty_tuple.type = call imports.%TakesConstLValue__carbon_thunk.decl(%addr.loc9) +// CHECK:STDOUT: %Cpp.ref.loc11: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesConstLValue.ref.loc11: %.4e1 = name_ref TakesConstLValue, imports.%.9bc [concrete = constants.%empty_struct] +// CHECK:STDOUT: %s.ref.loc11: ref %S = name_ref s, %s +// CHECK:STDOUT: %addr.loc11: %ptr.5c7 = addr_of %s.ref.loc11 +// CHECK:STDOUT: %.loc11_24.1: %ptr.ff5 = as_compatible %addr.loc11 +// CHECK:STDOUT: %.loc11_24.2: %ptr.ff5 = converted %addr.loc11, %.loc11_24.1 +// CHECK:STDOUT: %TakesConstLValue__carbon_thunk.call.loc11: init %empty_tuple.type = call imports.%TakesConstLValue__carbon_thunk.decl(%.loc11_24.2) +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %s.var, constants.%T.as.Destroy.impl.Op.062 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method: = bound_method %s.var, %T.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %addr.loc8: %ptr.5c7 = addr_of %s.var +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr.loc8) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_const_lvalue_ref.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %S: type = class_type @S [concrete] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [concrete] +// CHECK:STDOUT: %pattern_type.7da: type = pattern_type %S [concrete] +// CHECK:STDOUT: %S.val: %S = struct_value () [concrete] +// CHECK:STDOUT: %.4e1: type = cpp_overload_set_type @TakesConstLValue [concrete] +// CHECK:STDOUT: %empty_struct: %.4e1 = struct_value () [concrete] +// CHECK:STDOUT: %const: type = const_type %S [concrete] +// CHECK:STDOUT: %ptr.ff5: type = ptr_type %const [concrete] +// CHECK:STDOUT: %TakesConstLValue__carbon_thunk.type: type = fn_type @TakesConstLValue__carbon_thunk [concrete] +// CHECK:STDOUT: %TakesConstLValue__carbon_thunk: %TakesConstLValue__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %ptr.5c7: type = ptr_type %S [concrete] +// CHECK:STDOUT: %T.e15: type = class_type @T [concrete] +// CHECK:STDOUT: %pattern_type.e6b: type = pattern_type %T.e15 [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.type.559: type = fn_type @T.as.Destroy.impl.Op, @T.as.Destroy.impl(%T.e15) [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.b53: %T.as.Destroy.impl.Op.type.559 = struct_value () [concrete] +// CHECK:STDOUT: %ptr.b04: type = ptr_type %T.e15 [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.type.d46: type = fn_type @T.as.Destroy.impl.Op, @T.as.Destroy.impl(%S) [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.062: %T.as.Destroy.impl.Op.type.d46 = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .S = %S.decl +// CHECK:STDOUT: .TakesConstLValue = %.9bc +// CHECK:STDOUT: .T = %T.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} +// CHECK:STDOUT: %.9bc: %.4e1 = cpp_overload_set_value @TakesConstLValue [concrete = constants.%empty_struct] +// CHECK:STDOUT: %TakesConstLValue__carbon_thunk.decl: %TakesConstLValue__carbon_thunk.type = fn_decl @TakesConstLValue__carbon_thunk [concrete = constants.%TakesConstLValue__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %T.decl: type = class_decl @T [concrete = constants.%T.e15] {} {} +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %s.patt: %pattern_type.7da = binding_pattern s [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc12_19.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc12_13: type = splice_block %S.ref [concrete = constants.%S] { +// CHECK:STDOUT: %Cpp.ref.loc12: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc12_19.2: ref %S = temporary_storage +// CHECK:STDOUT: %.loc12_19.3: init %S = class_init (), %.loc12_19.2 [concrete = constants.%S.val] +// CHECK:STDOUT: %.loc12_19.4: ref %S = temporary %.loc12_19.2, %.loc12_19.3 +// CHECK:STDOUT: %.loc12_19.5: ref %S = converted %.loc12_19.1, %.loc12_19.4 +// CHECK:STDOUT: %.loc12_19.6: %S = bind_value %.loc12_19.5 +// CHECK:STDOUT: %s: %S = bind_name s, %.loc12_19.6 +// CHECK:STDOUT: %Cpp.ref.loc18: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesConstLValue.ref.loc18: %.4e1 = name_ref TakesConstLValue, imports.%.9bc [concrete = constants.%empty_struct] +// CHECK:STDOUT: %s.ref: %S = name_ref s, %s +// CHECK:STDOUT: %.loc18_24.1: ref %S = temporary_storage +// CHECK:STDOUT: %addr.loc18: %ptr.5c7 = addr_of %.loc18_24.1 +// CHECK:STDOUT: %.loc18_24.2: %ptr.ff5 = as_compatible %addr.loc18 +// CHECK:STDOUT: %.loc18_24.3: %ptr.ff5 = converted %addr.loc18, %.loc18_24.2 +// CHECK:STDOUT: %TakesConstLValue__carbon_thunk.call: init %empty_tuple.type = call imports.%TakesConstLValue__carbon_thunk.decl(%.loc18_24.3) +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %t.patt: %pattern_type.e6b = binding_pattern t [concrete] +// CHECK:STDOUT: %t.var_patt: %pattern_type.e6b = var_pattern %t.patt [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %t.var: ref %T.e15 = var %t.var_patt +// CHECK:STDOUT: %.loc20: type = splice_block %T.ref [concrete = constants.%T.e15] { +// CHECK:STDOUT: %Cpp.ref.loc20: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %T.ref: type = name_ref T, imports.%T.decl [concrete = constants.%T.e15] +// CHECK:STDOUT: } +// CHECK:STDOUT: %t: ref %T.e15 = bind_name t, %t.var +// CHECK:STDOUT: %Cpp.ref.loc28: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %TakesConstLValue.ref.loc28: %.4e1 = name_ref TakesConstLValue, imports.%.9bc [concrete = constants.%empty_struct] +// CHECK:STDOUT: %t.ref: ref %T.e15 = name_ref t, %t +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc20: = bound_method %t.var, constants.%T.as.Destroy.impl.Op.b53 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc20: = bound_method %t.var, %T.as.Destroy.impl.Op.specific_fn.1 +// CHECK:STDOUT: %addr.loc20: %ptr.b04 = addr_of %t.var +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call.loc20: init %empty_tuple.type = call %bound_method.loc20(%addr.loc20) +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc12: = bound_method %.loc12_19.4, constants.%T.as.Destroy.impl.Op.062 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc12: = bound_method %.loc12_19.4, %T.as.Destroy.impl.Op.specific_fn.2 +// CHECK:STDOUT: %addr.loc12: %ptr.5c7 = addr_of %.loc12_19.4 +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call.loc12: init %empty_tuple.type = call %bound_method.loc12(%addr.loc12) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/lower/testdata/interop/cpp/reference.carbon b/toolchain/lower/testdata/interop/cpp/reference.carbon new file mode 100644 index 000000000000..0769c77c27dc --- /dev/null +++ b/toolchain/lower/testdata/interop/cpp/reference.carbon @@ -0,0 +1,179 @@ +// Part of the Carbon Language 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-FILE: toolchain/testing/testdata/min_prelude/int.carbon +// +// AUTOUPDATE +// TIP: To test this file alone, run: +// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/lower/testdata/interop/cpp/reference.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/lower/testdata/interop/cpp/reference.carbon + +// --- reference_params.h + +class C {}; + +void TakeCRef(C&); +void TakeCRRef(C&&); +void TakeConstCRef(const C&); + +void TakeIntRef(int&); +void TakeIntRRef(int&&); +void TakeConstIntRef(const int&); + +// --- pass_references.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "reference_params.h"; + +fn PassRefs() { + var c: Cpp.C; + Cpp.TakeCRef(c); + Cpp.TakeCRRef({} as Cpp.C); + Cpp.TakeConstCRef(c); + + var n: i32; + Cpp.TakeIntRef(n); + Cpp.TakeIntRRef(42 as i32); + Cpp.TakeConstIntRef(n); +} + +// CHECK:STDOUT: ; ModuleID = 'pass_references.carbon' +// CHECK:STDOUT: source_filename = "pass_references.carbon" +// CHECK:STDOUT: target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128" +// CHECK:STDOUT: target triple = "x86_64-unknown-linux-gnu" +// CHECK:STDOUT: +// CHECK:STDOUT: @C.val.loc9_18.3 = internal constant {} zeroinitializer +// CHECK:STDOUT: +// CHECK:STDOUT: define void @_CPassRefs.Main() !dbg !7 { +// CHECK:STDOUT: entry: +// CHECK:STDOUT: %c.var = alloca {}, align 8, !dbg !10 +// CHECK:STDOUT: %.loc9_18.2.temp = alloca {}, align 8, !dbg !11 +// CHECK:STDOUT: %n.var = alloca i32, align 4, !dbg !12 +// CHECK:STDOUT: %.loc14_22.3.temp = alloca i32, align 4, !dbg !13 +// CHECK:STDOUT: call void @llvm.lifetime.start.p0(ptr %c.var), !dbg !10 +// CHECK:STDOUT: call void @_Z8TakeCRefR1C.carbon_thunk(ptr %c.var), !dbg !14 +// CHECK:STDOUT: call void @llvm.lifetime.start.p0(ptr %.loc9_18.2.temp), !dbg !11 +// CHECK:STDOUT: call void @llvm.memcpy.p0.p0.i64(ptr align 1 %.loc9_18.2.temp, ptr align 1 @C.val.loc9_18.3, i64 0, i1 false), !dbg !11 +// CHECK:STDOUT: call void @_Z9TakeCRRefO1C.carbon_thunk(ptr %.loc9_18.2.temp), !dbg !15 +// CHECK:STDOUT: call void @_Z13TakeConstCRefRK1C.carbon_thunk(ptr %c.var), !dbg !16 +// CHECK:STDOUT: call void @llvm.lifetime.start.p0(ptr %n.var), !dbg !12 +// CHECK:STDOUT: call void @_Z10TakeIntRefRi.carbon_thunk(ptr %n.var), !dbg !17 +// CHECK:STDOUT: call void @llvm.lifetime.start.p0(ptr %.loc14_22.3.temp), !dbg !13 +// CHECK:STDOUT: store i32 42, ptr %.loc14_22.3.temp, align 4, !dbg !13 +// CHECK:STDOUT: call void @_Z11TakeIntRRefOi.carbon_thunk(ptr %.loc14_22.3.temp), !dbg !18 +// CHECK:STDOUT: call void @_Z15TakeConstIntRefRKi.carbon_thunk(ptr %n.var), !dbg !19 +// CHECK:STDOUT: ret void, !dbg !20 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: declare void @_Z8TakeCRefR1C(ptr) +// CHECK:STDOUT: +// CHECK:STDOUT: declare void @_Z9TakeCRRefO1C(ptr) +// CHECK:STDOUT: +// CHECK:STDOUT: declare void @_Z13TakeConstCRefRK1C(ptr) +// CHECK:STDOUT: +// CHECK:STDOUT: declare void @_Z10TakeIntRefRi(ptr) +// CHECK:STDOUT: +// CHECK:STDOUT: declare void @_Z11TakeIntRRefOi(i32) +// CHECK:STDOUT: +// CHECK:STDOUT: declare void @_Z15TakeConstIntRefRKi(ptr) +// CHECK:STDOUT: +// CHECK:STDOUT: ; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) +// CHECK:STDOUT: declare void @llvm.lifetime.start.p0(ptr captures(none)) #0 +// CHECK:STDOUT: +// CHECK:STDOUT: ; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +// CHECK:STDOUT: declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #1 +// CHECK:STDOUT: +// CHECK:STDOUT: ; Function Attrs: alwaysinline mustprogress +// CHECK:STDOUT: define dso_local void @_Z8TakeCRefR1C.carbon_thunk(ptr %0) #2 { +// CHECK:STDOUT: entry: +// CHECK:STDOUT: %.addr = alloca ptr, align 8 +// CHECK:STDOUT: store ptr %0, ptr %.addr, align 8 +// CHECK:STDOUT: %1 = load ptr, ptr %.addr, align 8 +// CHECK:STDOUT: call void @_Z8TakeCRefR1C(ptr nonnull align 1 dereferenceable(1) %1) +// CHECK:STDOUT: ret void +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: ; Function Attrs: alwaysinline mustprogress +// CHECK:STDOUT: define dso_local void @_Z9TakeCRRefO1C.carbon_thunk(ptr %0) #2 { +// CHECK:STDOUT: entry: +// CHECK:STDOUT: %.addr = alloca ptr, align 8 +// CHECK:STDOUT: store ptr %0, ptr %.addr, align 8 +// CHECK:STDOUT: %1 = load ptr, ptr %.addr, align 8 +// CHECK:STDOUT: call void @_Z9TakeCRRefO1C(ptr nonnull align 1 dereferenceable(1) %1) +// CHECK:STDOUT: ret void +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: ; Function Attrs: alwaysinline mustprogress +// CHECK:STDOUT: define dso_local void @_Z13TakeConstCRefRK1C.carbon_thunk(ptr %0) #2 { +// CHECK:STDOUT: entry: +// CHECK:STDOUT: %.addr = alloca ptr, align 8 +// CHECK:STDOUT: store ptr %0, ptr %.addr, align 8 +// CHECK:STDOUT: %1 = load ptr, ptr %.addr, align 8 +// CHECK:STDOUT: call void @_Z13TakeConstCRefRK1C(ptr nonnull align 1 dereferenceable(1) %1) +// CHECK:STDOUT: ret void +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: ; Function Attrs: alwaysinline mustprogress +// CHECK:STDOUT: define dso_local void @_Z10TakeIntRefRi.carbon_thunk(ptr %0) #2 { +// CHECK:STDOUT: entry: +// CHECK:STDOUT: %.addr = alloca ptr, align 8 +// CHECK:STDOUT: store ptr %0, ptr %.addr, align 8 +// CHECK:STDOUT: %1 = load ptr, ptr %.addr, align 8 +// CHECK:STDOUT: call void @_Z10TakeIntRefRi(ptr nonnull align 4 dereferenceable(4) %1) +// CHECK:STDOUT: ret void +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: ; Function Attrs: alwaysinline mustprogress +// CHECK:STDOUT: define dso_local void @_Z11TakeIntRRefOi.carbon_thunk(ptr %0) #2 { +// CHECK:STDOUT: entry: +// CHECK:STDOUT: %.addr = alloca ptr, align 8 +// CHECK:STDOUT: store ptr %0, ptr %.addr, align 8 +// CHECK:STDOUT: %1 = load ptr, ptr %.addr, align 8 +// CHECK:STDOUT: call void @_Z11TakeIntRRefOi(ptr nonnull align 4 dereferenceable(4) %1) +// CHECK:STDOUT: ret void +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: ; Function Attrs: alwaysinline mustprogress +// CHECK:STDOUT: define dso_local void @_Z15TakeConstIntRefRKi.carbon_thunk(ptr %0) #2 { +// CHECK:STDOUT: entry: +// CHECK:STDOUT: %.addr = alloca ptr, align 8 +// CHECK:STDOUT: store ptr %0, ptr %.addr, align 8 +// CHECK:STDOUT: %1 = load ptr, ptr %.addr, align 8 +// CHECK:STDOUT: call void @_Z15TakeConstIntRefRKi(ptr nonnull align 4 dereferenceable(4) %1) +// CHECK:STDOUT: ret void +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: ; uselistorder directives +// CHECK:STDOUT: uselistorder ptr @llvm.lifetime.start.p0, { 3, 2, 1, 0 } +// CHECK:STDOUT: +// CHECK:STDOUT: attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) } +// CHECK:STDOUT: attributes #1 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } +// CHECK:STDOUT: attributes #2 = { alwaysinline mustprogress "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="0" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" } +// CHECK:STDOUT: +// CHECK:STDOUT: !llvm.module.flags = !{!0, !1, !2, !3, !4} +// CHECK:STDOUT: !llvm.dbg.cu = !{!5} +// CHECK:STDOUT: +// CHECK:STDOUT: !0 = !{i32 7, !"Dwarf Version", i32 5} +// CHECK:STDOUT: !1 = !{i32 2, !"Debug Info Version", i32 3} +// CHECK:STDOUT: !2 = !{i32 1, !"wchar_size", i32 4} +// CHECK:STDOUT: !3 = !{i32 8, !"PIC Level", i32 0} +// CHECK:STDOUT: !4 = !{i32 7, !"PIE Level", i32 2} +// CHECK:STDOUT: !5 = distinct !DICompileUnit(language: DW_LANG_C, file: !6, producer: "carbon", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +// CHECK:STDOUT: !6 = !DIFile(filename: "pass_references.carbon", directory: "") +// CHECK:STDOUT: !7 = distinct !DISubprogram(name: "PassRefs", linkageName: "_CPassRefs.Main", scope: null, file: !6, line: 6, type: !8, spFlags: DISPFlagDefinition, unit: !5) +// CHECK:STDOUT: !8 = !DISubroutineType(types: !9) +// CHECK:STDOUT: !9 = !{} +// CHECK:STDOUT: !10 = !DILocation(line: 7, column: 3, scope: !7) +// CHECK:STDOUT: !11 = !DILocation(line: 9, column: 17, scope: !7) +// CHECK:STDOUT: !12 = !DILocation(line: 12, column: 3, scope: !7) +// CHECK:STDOUT: !13 = !DILocation(line: 14, column: 19, scope: !7) +// CHECK:STDOUT: !14 = !DILocation(line: 8, column: 3, scope: !7) +// CHECK:STDOUT: !15 = !DILocation(line: 9, column: 3, scope: !7) +// CHECK:STDOUT: !16 = !DILocation(line: 10, column: 3, scope: !7) +// CHECK:STDOUT: !17 = !DILocation(line: 13, column: 3, scope: !7) +// CHECK:STDOUT: !18 = !DILocation(line: 14, column: 3, scope: !7) +// CHECK:STDOUT: !19 = !DILocation(line: 15, column: 3, scope: !7) +// CHECK:STDOUT: !20 = !DILocation(line: 6, column: 1, scope: !7)