From ac2428acaf4766fbefb6da0b695c1d06b17a89e1 Mon Sep 17 00:00:00 2001 From: Jon Ross-Perkins Date: Fri, 7 Jun 2024 13:08:31 -0700 Subject: [PATCH] Start unifying let/var handling. (#4032) Merges handle_let.cpp and handle_variable.cpp into a single file in order to take better advantage of commonalities. Both still have a bunch of kludges, and there's still divergent handling in handle_binding_pattern that will yield different results. However, this fixes some things about `let` like starting to make use of global_init (imperfectly, due to how VarStorage works, I grant), and in particular adding `let` names to a name scope, not just lexical lookup. --- toolchain/check/handle_let_and_var.cpp | 276 ++++++++++-------- .../testdata/alias/fail_bool_value.carbon | 10 +- .../alias/no_prelude/alias_of_alias.carbon | 20 +- .../fail_aliased_name_in_diag.carbon | 5 +- .../alias/no_prelude/in_namespace.carbon | 28 +- .../testdata/array/canonicalize_index.carbon | 7 +- .../testdata/as/adapter_conversion.carbon | 145 +++++---- toolchain/check/testdata/as/as_type.carbon | 12 +- .../testdata/as/fail_no_conversion.carbon | 14 +- .../check/testdata/as/fail_not_type.carbon | 12 +- .../testdata/basics/builtin_types.carbon | 5 +- .../fail_numeric_literal_overflow.carbon | 20 +- .../check/testdata/builtins/float/div.carbon | 36 +-- .../testdata/builtins/float/negate.carbon | 18 +- .../check/testdata/builtins/int/and.carbon | 12 +- .../testdata/builtins/int/complement.carbon | 12 +- .../testdata/builtins/int/left_shift.carbon | 145 +++++---- .../check/testdata/builtins/int/or.carbon | 12 +- .../testdata/builtins/int/right_shift.carbon | 104 ++++--- .../check/testdata/builtins/int/sadd.carbon | 47 +-- .../check/testdata/builtins/int/sdiv.carbon | 111 ++++--- .../check/testdata/builtins/int/smod.carbon | 111 ++++--- .../check/testdata/builtins/int/smul.carbon | 47 +-- .../testdata/builtins/int/snegate.carbon | 66 +++-- .../check/testdata/builtins/int/ssub.carbon | 58 ++-- .../check/testdata/builtins/int/uadd.carbon | 47 +-- .../check/testdata/builtins/int/udiv.carbon | 111 ++++--- .../check/testdata/builtins/int/umod.carbon | 111 ++++--- .../check/testdata/builtins/int/umul.carbon | 47 +-- .../testdata/builtins/int/unegate.carbon | 66 +++-- .../check/testdata/builtins/int/usub.carbon | 58 ++-- .../check/testdata/builtins/int/xor.carbon | 12 +- .../testdata/class/fail_base_unbound.carbon | 12 +- .../class/fail_field_modifiers.carbon | 2 + .../testdata/class/fail_member_of_let.carbon | 15 +- .../check/testdata/class/init_adapt.carbon | 94 +++--- .../if_expr/fail_not_in_function.carbon | 22 +- .../fail_assoc_const_not_binding.carbon | 2 +- .../testdata/let/fail_generic_import.carbon | 16 +- .../testdata/let/fail_missing_value.carbon | 1 + .../check/testdata/let/fail_modifiers.carbon | 45 ++- .../check/testdata/let/generic_import.carbon | 10 +- toolchain/check/testdata/let/global.carbon | 12 +- toolchain/check/testdata/let/import.carbon | 74 ----- .../testdata/let/no_prelude/import.carbon | 136 +++++++++ .../let/no_prelude/import_access.carbon | 35 ++- .../operators/builtin/unary_op.carbon | 19 +- .../testdata/pointer/fail_deref_error.carbon | 19 +- .../struct/fail_duplicate_name.carbon | 14 +- .../check/testdata/struct/two_entries.carbon | 18 +- .../check/testdata/tuples/two_elements.carbon | 18 +- 51 files changed, 1456 insertions(+), 893 deletions(-) delete mode 100644 toolchain/check/testdata/let/import.carbon create mode 100644 toolchain/check/testdata/let/no_prelude/import.carbon diff --git a/toolchain/check/handle_let_and_var.cpp b/toolchain/check/handle_let_and_var.cpp index b9088c6f0e53..c4126ed1766d 100644 --- a/toolchain/check/handle_let_and_var.cpp +++ b/toolchain/check/handle_let_and_var.cpp @@ -4,47 +4,44 @@ #include "toolchain/check/context.h" #include "toolchain/check/convert.h" +#include "toolchain/check/decl_introducer_state.h" #include "toolchain/check/handle.h" #include "toolchain/check/interface.h" #include "toolchain/check/modifiers.h" #include "toolchain/diagnostics/diagnostic_emitter.h" +#include "toolchain/lex/token_kind.h" #include "toolchain/sem_ir/inst.h" #include "toolchain/sem_ir/name_scope.h" #include "toolchain/sem_ir/typed_insts.h" namespace Carbon::Check { -auto HandleLetIntroducer(Context& context, Parse::LetIntroducerId node_id) - -> bool { - context.decl_introducer_state_stack().Push(); +template +static auto HandleIntroducer(Context& context, Parse::NodeId node_id) -> bool { + context.decl_introducer_state_stack().Push(); // Push a bracketing node to establish the pattern context. context.node_stack().Push(node_id); return true; } +auto HandleLetIntroducer(Context& context, Parse::LetIntroducerId node_id) + -> bool { + return HandleIntroducer(context, node_id); +} + auto HandleVariableIntroducer(Context& context, Parse::VariableIntroducerId node_id) -> bool { - // No action, just a bracketing node. - context.node_stack().Push(node_id); - context.decl_introducer_state_stack().Push(); - return true; + return HandleIntroducer(context, node_id); } auto HandleReturnedModifier(Context& context, Parse::ReturnedModifierId node_id) -> bool { - // No action, just a bracketing node. + // This is pushed to be seen by HandleBindingPattern. context.node_stack().Push(node_id); return true; } -auto HandleLetInitializer(Context& context, Parse::LetInitializerId node_id) - -> bool { - context.node_stack().Push(node_id); - return true; -} - -auto HandleVariableInitializer(Context& context, - Parse::VariableInitializerId node_id) -> bool { +static auto HandleInitializer(Context& context, Parse::NodeId node_id) -> bool { if (context.scope_stack().PeekIndex() == ScopeIndex::Package) { context.inst_block_stack().PushGlobalInit(); } @@ -52,6 +49,17 @@ auto HandleVariableInitializer(Context& context, return true; } +auto HandleLetInitializer(Context& context, Parse::LetInitializerId node_id) + -> bool { + return HandleInitializer(context, node_id); +} + +auto HandleVariableInitializer(Context& context, + Parse::VariableInitializerId node_id) -> bool { + return HandleInitializer(context, node_id); +} + +// Builds an associated constant declaration for a `let`. static auto BuildAssociatedConstantDecl(Context& context, Parse::LetDeclId node_id, SemIR::InstId pattern_id, @@ -90,64 +98,140 @@ static auto BuildAssociatedConstantDecl(Context& context, access_kind); } -auto HandleLetDecl(Context& context, Parse::LetDeclId node_id) -> bool { - // Pop the optional initializer. - std::optional value_id; - if (context.node_stack().PeekNextIs()) { - value_id = context.node_stack().PopExpr(); - context.node_stack() - .PopAndDiscardSoloNodeId(); +// Adds name bindings. Returns the resulting ID for the references. +static auto HandleNameBinding(Context& context, SemIR::InstId pattern_id, + SemIR::AccessKind access_kind) -> SemIR::InstId { + // Extract the name binding. + if (auto bind_name = + context.insts().TryGetAs(pattern_id)) { + // Form a corresponding name in the current context, and bind the name to + // the variable. + auto name_context = context.decl_name_stack().MakeUnqualifiedName( + context.insts().GetLocId(pattern_id), + context.bind_names().Get(bind_name->bind_name_id).name_id); + context.decl_name_stack().AddNameOrDiagnoseDuplicate( + name_context, pattern_id, access_kind); + return bind_name->value_id; + } else if (auto field_decl = + context.insts().TryGetAs(pattern_id)) { + // Introduce the field name into the class. + auto name_context = context.decl_name_stack().MakeUnqualifiedName( + context.insts().GetLocId(pattern_id), field_decl->name_id); + context.decl_name_stack().AddNameOrDiagnoseDuplicate( + name_context, pattern_id, access_kind); + return pattern_id; + } else { + // TODO: Handle other kinds of pattern. + return pattern_id; + } +} + +namespace { +// State from HandleDecl, returned for type-specific handling. +struct DeclInfo { + // The optional initializer. + std::optional init_id = std::nullopt; + SemIR::InstId pattern_id = SemIR::InstId::Invalid; + std::optional parent_scope_inst = std::nullopt; + DeclIntroducerState introducer = DeclIntroducerState(); +}; +} // namespace + +// Handles common logic for `let` and `var` declarations. +// TODO: There's still a lot of divergence here, including logic in +// handle_binding_pattern. These should really be better unified. +template +static auto HandleDecl(Context& context, NodeT node_id) + -> std::optional { + std::optional decl_info = DeclInfo(); + // Handle the optional initializer. + if (context.node_stack().PeekNextIs()) { + decl_info->init_id = context.node_stack().PopExpr(); + context.node_stack().PopAndDiscardSoloNodeId(); } if (context.node_stack().PeekIs()) { - return context.TODO(node_id, "tuple pattern in let"); + if (decl_info->init_id && + context.scope_stack().PeekIndex() == ScopeIndex::Package) { + context.inst_block_stack().PopGlobalInit(); + } + context.TODO(node_id, "tuple pattern in let/var"); + decl_info = std::nullopt; + return decl_info; } - SemIR::InstId pattern_id = context.node_stack().PopPattern(); - context.node_stack() - .PopAndDiscardSoloNodeId(); + + decl_info->pattern_id = context.node_stack().PopPattern(); + + if constexpr (IntroducerTokenKind == Lex::TokenKind::Var) { + // Pop the `returned` modifier if present. + context.node_stack() + .PopAndDiscardSoloNodeIdIf(); + } + + context.node_stack().PopAndDiscardSoloNodeId(); + // Process declaration modifiers. - // TODO: For a qualified `let` declaration, this should use the target scope - // of the name introduced in the declaration. See #2590. - auto [parent_scope_inst_id, parent_scope_inst] = - context.name_scopes().GetInstIfValid( - context.scope_stack().PeekNameScopeId()); - auto introducer = - context.decl_introducer_state_stack().Pop(); - CheckAccessModifiersOnDecl(context, introducer, parent_scope_inst); - RequireDefaultFinalOnlyInInterfaces(context, introducer, parent_scope_inst); + // TODO: For a qualified `let` or `var` declaration, this should use the + // target scope of the name introduced in the declaration. See #2590. + decl_info->parent_scope_inst = + context.name_scopes() + .GetInstIfValid(context.scope_stack().PeekNameScopeId()) + .second; + decl_info->introducer = + context.decl_introducer_state_stack().Pop(); + CheckAccessModifiersOnDecl(context, decl_info->introducer, + decl_info->parent_scope_inst); + + return decl_info; +} + +auto HandleLetDecl(Context& context, Parse::LetDeclId node_id) -> bool { + auto decl_info = + HandleDecl(context, node_id); + if (!decl_info) { + return false; + } + + RequireDefaultFinalOnlyInInterfaces(context, decl_info->introducer, + decl_info->parent_scope_inst); LimitModifiersOnDecl( - context, introducer, + context, decl_info->introducer, KeywordModifierSet::Access | KeywordModifierSet::Interface); - if (introducer.modifier_set.HasAnyOf(KeywordModifierSet::Interface)) { - context.TODO(introducer.modifier_node_id(ModifierOrder::Decl), + if (decl_info->introducer.modifier_set.HasAnyOf( + KeywordModifierSet::Interface)) { + context.TODO(decl_info->introducer.modifier_node_id(ModifierOrder::Decl), "interface modifier"); } - auto pattern = context.insts().GetWithLocId(pattern_id); - auto interface_scope = context.GetCurrentScopeAs(); + auto pattern = context.insts().GetWithLocId(decl_info->pattern_id); - if (value_id) { + if (decl_info->init_id) { // Convert the value to match the type of the pattern. - value_id = ConvertToValueOfType(context, node_id, *value_id, - pattern.inst.type_id()); + decl_info->init_id = ConvertToValueOfType( + context, node_id, *decl_info->init_id, pattern.inst.type_id()); } + auto interface_scope = context.GetCurrentScopeAs(); + // At interface scope, we are forming an associated constant, which has // different rules. if (interface_scope) { - BuildAssociatedConstantDecl(context, node_id, pattern_id, pattern, - interface_scope->interface_id, - introducer.modifier_set.GetAccessKind()); + BuildAssociatedConstantDecl( + context, node_id, decl_info->pattern_id, pattern, + interface_scope->interface_id, + decl_info->introducer.modifier_set.GetAccessKind()); return true; } - if (!value_id) { + if (!decl_info->init_id) { CARBON_DIAGNOSTIC( ExpectedInitializerAfterLet, Error, "Expected `=`; `let` declaration must have an initializer."); context.emitter().Emit(TokenOnly(node_id), ExpectedInitializerAfterLet); - value_id = SemIR::InstId::BuiltinError; } // Update the binding with its value and add it to the current block, after @@ -156,89 +240,53 @@ auto HandleLetDecl(Context& context, Parse::LetDeclId node_id) -> bool { auto bind_name = pattern.inst.As(); CARBON_CHECK(!bind_name.value_id.is_valid()) << "Binding should not already have a value!"; - bind_name.value_id = *value_id; - context.ReplaceInstBeforeConstantUse(pattern_id, bind_name); - context.inst_block_stack().AddInstId(pattern_id); + bind_name.value_id = + decl_info->init_id ? *decl_info->init_id : SemIR::InstId::BuiltinError; + context.ReplaceInstBeforeConstantUse(decl_info->pattern_id, bind_name); + context.inst_block_stack().AddInstId(decl_info->pattern_id); - // Add the name of the binding to the current scope. - auto name_id = context.bind_names().Get(bind_name.bind_name_id).name_id; - context.AddNameToLookup(name_id, pattern_id); - if (parent_scope_inst_id == SemIR::InstId::PackageNamespace && - introducer.modifier_set.GetAccessKind() == SemIR::AccessKind::Public) { - context.AddExport(pattern_id); + HandleNameBinding(context, decl_info->pattern_id, + decl_info->introducer.modifier_set.GetAccessKind()); + + if (decl_info->init_id && + context.scope_stack().PeekIndex() == ScopeIndex::Package) { + context.inst_block_stack().PopGlobalInit(); } + return true; } auto HandleVariableDecl(Context& context, Parse::VariableDeclId node_id) -> bool { - // Handle the optional initializer. - std::optional init_id; - if (context.node_stack().PeekNextIs()) { - init_id = context.node_stack().PopExpr(); - context.node_stack() - .PopAndDiscardSoloNodeId(); + auto decl_info = + HandleDecl(context, node_id); + if (!decl_info) { + return false; } - if (context.node_stack().PeekIs()) { - if (init_id && context.scope_stack().PeekIndex() == ScopeIndex::Package) { - context.inst_block_stack().PopGlobalInit(); - } - return context.TODO(node_id, "tuple pattern in var"); - } + LimitModifiersOnDecl(context, decl_info->introducer, + KeywordModifierSet::Access); - auto value_id = context.node_stack().PopPattern(); - - // Pop the `returned` specifier if present. - context.node_stack() - .PopAndDiscardSoloNodeIdIf(); - - context.node_stack() - .PopAndDiscardSoloNodeId(); - - // Process declaration modifiers. - // TODO: For a qualified `var` declaration, this should use the target scope - // of the name introduced in the declaration. See #2590. - auto [_, parent_scope_inst] = context.name_scopes().GetInstIfValid( - context.scope_stack().PeekNameScopeId()); - auto introducer = - context.decl_introducer_state_stack().Pop(); - CheckAccessModifiersOnDecl(context, introducer, parent_scope_inst); - LimitModifiersOnDecl(context, introducer, KeywordModifierSet::Access); - - // Extract the name binding. - if (auto bind_name = context.insts().TryGetAs(value_id)) { - // Form a corresponding name in the current context, and bind the name to - // the variable. - auto name_context = context.decl_name_stack().MakeUnqualifiedName( - context.insts().GetLocId(value_id), - context.bind_names().Get(bind_name->bind_name_id).name_id); - context.decl_name_stack().AddNameOrDiagnoseDuplicate( - name_context, value_id, introducer.modifier_set.GetAccessKind()); - value_id = bind_name->value_id; - } else if (auto field_decl = - context.insts().TryGetAs(value_id)) { - // Introduce the field name into the class. - auto name_context = context.decl_name_stack().MakeUnqualifiedName( - context.insts().GetLocId(value_id), field_decl->name_id); - context.decl_name_stack().AddNameOrDiagnoseDuplicate( - name_context, value_id, introducer.modifier_set.GetAccessKind()); - } - // TODO: Handle other kinds of pattern. + decl_info->pattern_id = + HandleNameBinding(context, decl_info->pattern_id, + decl_info->introducer.modifier_set.GetAccessKind()); // If there was an initializer, assign it to the storage. - if (init_id) { + if (decl_info->init_id) { if (context.GetCurrentScopeAs()) { // TODO: In a class scope, we should instead save the initializer // somewhere so that we can use it as a default. context.TODO(node_id, "Field initializer"); } else { - init_id = Initialize(context, node_id, value_id, *init_id); - // TODO: Consider using different instruction kinds for assignment versus - // initialization. - context.AddInst(node_id, - {.lhs_id = value_id, .rhs_id = *init_id}); + decl_info->init_id = Initialize(context, node_id, decl_info->pattern_id, + *decl_info->init_id); + // TODO: Consider using different instruction kinds for assignment + // versus initialization. + context.AddInst(node_id, {.lhs_id = decl_info->pattern_id, + .rhs_id = *decl_info->init_id}); } + if (context.scope_stack().PeekIndex() == ScopeIndex::Package) { context.inst_block_stack().PopGlobalInit(); } diff --git a/toolchain/check/testdata/alias/fail_bool_value.carbon b/toolchain/check/testdata/alias/fail_bool_value.carbon index 70c9c2c878b6..f34ca1c850e9 100644 --- a/toolchain/check/testdata/alias/fail_bool_value.carbon +++ b/toolchain/check/testdata/alias/fail_bool_value.carbon @@ -27,6 +27,7 @@ let a_test: bool = a; // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .a = %a +// CHECK:STDOUT: .a_test = @__global_init.%a_test // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %.loc14: bool = bool_literal false [template = constants.%.1] @@ -35,9 +36,14 @@ let a_test: bool = a; // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] // CHECK:STDOUT: %.loc15_13.1: type = value_of_initializer %bool.make_type [template = bool] // CHECK:STDOUT: %.loc15_13.2: type = converted %bool.make_type, %.loc15_13.1 [template = bool] -// CHECK:STDOUT: %a.ref: = name_ref a, %a [template = ] -// CHECK:STDOUT: %a_test: bool = bind_name a_test, // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Bool() -> type = "bool.make_type"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %a.ref: = name_ref a, file.%a [template = ] +// CHECK:STDOUT: %a_test: bool = bind_name a_test, +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/alias/no_prelude/alias_of_alias.carbon b/toolchain/check/testdata/alias/no_prelude/alias_of_alias.carbon index 673cb3c74d86..8b66f599344b 100644 --- a/toolchain/check/testdata/alias/no_prelude/alias_of_alias.carbon +++ b/toolchain/check/testdata/alias/no_prelude/alias_of_alias.carbon @@ -30,6 +30,7 @@ let d: c = {}; // CHECK:STDOUT: .a = %a // CHECK:STDOUT: .b = %b // CHECK:STDOUT: .c = %c +// CHECK:STDOUT: .d = @__global_init.%d // CHECK:STDOUT: } // CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} // CHECK:STDOUT: %C.ref: type = name_ref C, %C.decl [template = constants.%C] @@ -39,13 +40,6 @@ let d: c = {}; // CHECK:STDOUT: %b.ref: type = name_ref b, %b [template = constants.%C] // CHECK:STDOUT: %c: type = bind_alias c, %b [template = constants.%C] // CHECK:STDOUT: %c.ref: type = name_ref c, %c [template = constants.%C] -// CHECK:STDOUT: %.loc15_13.1: %.1 = struct_literal () -// CHECK:STDOUT: %.loc15_13.2: ref %C = temporary_storage -// CHECK:STDOUT: %.loc15_13.3: init %C = class_init (), %.loc15_13.2 [template = constants.%struct] -// CHECK:STDOUT: %.loc15_13.4: ref %C = temporary %.loc15_13.2, %.loc15_13.3 -// CHECK:STDOUT: %.loc15_14.1: ref %C = converted %.loc15_13.1, %.loc15_13.4 -// CHECK:STDOUT: %.loc15_14.2: %C = bind_value %.loc15_14.1 -// CHECK:STDOUT: %d: %C = bind_name d, %.loc15_14.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { @@ -53,3 +47,15 @@ let d: c = {}; // CHECK:STDOUT: .Self = constants.%C // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc15_13.1: %.1 = struct_literal () +// CHECK:STDOUT: %.loc15_13.2: ref %C = temporary_storage +// CHECK:STDOUT: %.loc15_13.3: init %C = class_init (), %.loc15_13.2 [template = constants.%struct] +// CHECK:STDOUT: %.loc15_13.4: ref %C = temporary %.loc15_13.2, %.loc15_13.3 +// CHECK:STDOUT: %.loc15_14.1: ref %C = converted %.loc15_13.1, %.loc15_13.4 +// CHECK:STDOUT: %.loc15_14.2: %C = bind_value %.loc15_14.1 +// CHECK:STDOUT: %d: %C = bind_name d, %.loc15_14.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/alias/no_prelude/fail_aliased_name_in_diag.carbon b/toolchain/check/testdata/alias/no_prelude/fail_aliased_name_in_diag.carbon index c0b2c56f577b..0291a42de759 100644 --- a/toolchain/check/testdata/alias/no_prelude/fail_aliased_name_in_diag.carbon +++ b/toolchain/check/testdata/alias/no_prelude/fail_aliased_name_in_diag.carbon @@ -36,6 +36,7 @@ let c_var: c = d; // CHECK:STDOUT: .D = %D.decl // CHECK:STDOUT: .c = %c // CHECK:STDOUT: .d = %d +// CHECK:STDOUT: .c_var = @__global_init.%c_var // CHECK:STDOUT: } // CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} // CHECK:STDOUT: %D.decl: type = class_decl @D [template = constants.%D] {} @@ -45,8 +46,6 @@ let c_var: c = d; // CHECK:STDOUT: %d.var: ref %D = var d // CHECK:STDOUT: %d: ref %D = bind_name d, %d.var // CHECK:STDOUT: %c.ref: type = name_ref c, %c [template = constants.%C] -// CHECK:STDOUT: %d.ref: ref %D = name_ref d, %d -// CHECK:STDOUT: %c_var: %C = bind_name c_var, // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { @@ -65,6 +64,8 @@ let c_var: c = d; // CHECK:STDOUT: %.loc15_13.2: init %D = class_init (), file.%d.var [template = constants.%struct] // CHECK:STDOUT: %.loc15_14: init %D = converted %.loc15_13.1, %.loc15_13.2 [template = constants.%struct] // CHECK:STDOUT: assign file.%d.var, %.loc15_14 +// CHECK:STDOUT: %d.ref: ref %D = name_ref d, file.%d +// CHECK:STDOUT: %c_var: %C = bind_name c_var, // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/alias/no_prelude/in_namespace.carbon b/toolchain/check/testdata/alias/no_prelude/in_namespace.carbon index 246238b723fc..3a09375cf363 100644 --- a/toolchain/check/testdata/alias/no_prelude/in_namespace.carbon +++ b/toolchain/check/testdata/alias/no_prelude/in_namespace.carbon @@ -37,6 +37,7 @@ fn F() -> NS.a { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .C = %C.decl // CHECK:STDOUT: .NS = %NS +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: .F = %F.decl // CHECK:STDOUT: } // CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} @@ -47,17 +48,6 @@ fn F() -> NS.a { // CHECK:STDOUT: %a: type = bind_alias a, %C.decl [template = constants.%C] // CHECK:STDOUT: %NS.ref.loc16: = name_ref NS, %NS [template = %NS] // CHECK:STDOUT: %a.ref.loc16: type = name_ref a, %a [template = constants.%C] -// CHECK:STDOUT: %.loc16_22.1: %.1 = tuple_literal () -// CHECK:STDOUT: %.loc16_23.1: %.3 = struct_literal (%.loc16_22.1) -// CHECK:STDOUT: %.loc16_23.2: ref %C = temporary_storage -// CHECK:STDOUT: %.loc16_23.3: ref %.1 = class_element_access %.loc16_23.2, element0 -// CHECK:STDOUT: %.loc16_22.2: init %.1 = tuple_init () to %.loc16_23.3 [template = constants.%tuple] -// CHECK:STDOUT: %.loc16_23.4: init %.1 = converted %.loc16_22.1, %.loc16_22.2 [template = constants.%tuple] -// CHECK:STDOUT: %.loc16_23.5: init %C = class_init (%.loc16_23.4), %.loc16_23.2 [template = constants.%struct] -// CHECK:STDOUT: %.loc16_23.6: ref %C = temporary %.loc16_23.2, %.loc16_23.5 -// CHECK:STDOUT: %.loc16_24.1: ref %C = converted %.loc16_23.1, %.loc16_23.6 -// CHECK:STDOUT: %.loc16_24.2: %C = bind_value %.loc16_24.1 -// CHECK:STDOUT: %b: %C = bind_name b, %.loc16_24.2 // CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { // CHECK:STDOUT: %NS.ref.loc18: = name_ref NS, %NS [template = %NS] // CHECK:STDOUT: %a.ref.loc18: type = name_ref a, %a [template = constants.%C] @@ -87,3 +77,19 @@ fn F() -> NS.a { // CHECK:STDOUT: return %.loc19_19 to %return // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc16_22.1: %.1 = tuple_literal () +// CHECK:STDOUT: %.loc16_23.1: %.3 = struct_literal (%.loc16_22.1) +// CHECK:STDOUT: %.loc16_23.2: ref %C = temporary_storage +// CHECK:STDOUT: %.loc16_23.3: ref %.1 = class_element_access %.loc16_23.2, element0 +// CHECK:STDOUT: %.loc16_22.2: init %.1 = tuple_init () to %.loc16_23.3 [template = constants.%tuple] +// CHECK:STDOUT: %.loc16_23.4: init %.1 = converted %.loc16_22.1, %.loc16_22.2 [template = constants.%tuple] +// CHECK:STDOUT: %.loc16_23.5: init %C = class_init (%.loc16_23.4), %.loc16_23.2 [template = constants.%struct] +// CHECK:STDOUT: %.loc16_23.6: ref %C = temporary %.loc16_23.2, %.loc16_23.5 +// CHECK:STDOUT: %.loc16_24.1: ref %C = converted %.loc16_23.1, %.loc16_23.6 +// CHECK:STDOUT: %.loc16_24.2: %C = bind_value %.loc16_24.1 +// CHECK:STDOUT: %b: %C = bind_name b, %.loc16_24.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/array/canonicalize_index.carbon b/toolchain/check/testdata/array/canonicalize_index.carbon index a092653d7a03..103478d2b6b5 100644 --- a/toolchain/check/testdata/array/canonicalize_index.carbon +++ b/toolchain/check/testdata/array/canonicalize_index.carbon @@ -36,6 +36,7 @@ let b: [i32; 3]* = &a; // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Add = %Add.decl // CHECK:STDOUT: .a = %a.loc13 +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -75,9 +76,6 @@ let b: [i32; 3]* = &a; // CHECK:STDOUT: %.loc14_9.2: type = converted %int.make_type_32.loc14, %.loc14_9.1 [template = i32] // CHECK:STDOUT: %.loc14_15: type = array_type %.loc14_14, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc14_16: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %a.ref: ref %.5 = name_ref a, %a.loc13 -// CHECK:STDOUT: %.loc14_20: %.6 = addr_of %a.ref -// CHECK:STDOUT: %b.loc14: %.6 = bind_name b, %.loc14_20 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; @@ -102,6 +100,9 @@ let b: [i32; 3]* = &a; // CHECK:STDOUT: %.loc13_35.11: init %.5 = array_init (%.loc13_35.4, %.loc13_35.7, %.loc13_35.10) to file.%a.var [template = constants.%array] // CHECK:STDOUT: %.loc13_36: init %.5 = converted %.loc13_35.1, %.loc13_35.11 [template = constants.%array] // CHECK:STDOUT: assign file.%a.var, %.loc13_36 +// CHECK:STDOUT: %a.ref: ref %.5 = name_ref a, file.%a.loc13 +// CHECK:STDOUT: %.loc14: %.6 = addr_of %a.ref +// CHECK:STDOUT: %b: %.6 = bind_name b, %.loc14 // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/as/adapter_conversion.carbon b/toolchain/check/testdata/as/adapter_conversion.carbon index 2fd01ae3cf95..66db4845cc0b 100644 --- a/toolchain/check/testdata/as/adapter_conversion.carbon +++ b/toolchain/check/testdata/as/adapter_conversion.carbon @@ -127,6 +127,9 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: .A = %A.decl // CHECK:STDOUT: .B = %B.decl // CHECK:STDOUT: .a_ref = %a_ref +// CHECK:STDOUT: .a_val = @__global_init.%a_val +// CHECK:STDOUT: .b_val = @__global_init.%b_val +// CHECK:STDOUT: .b_ptr = @__global_init.%b_ptr // CHECK:STDOUT: .b_factory = %b_factory // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -138,23 +141,9 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: %a_ref.var: ref %A = var a_ref // CHECK:STDOUT: %a_ref: ref %A = bind_name a_ref, %a_ref.var // CHECK:STDOUT: %A.ref.loc18: type = name_ref A, %A.decl [template = constants.%A] -// CHECK:STDOUT: %a_ref.ref.loc18: ref %A = name_ref a_ref, %a_ref -// CHECK:STDOUT: %.loc18: %A = bind_value %a_ref.ref.loc18 -// CHECK:STDOUT: %a_val: %A = bind_name a_val, %.loc18 -// CHECK:STDOUT: %B.ref.loc21_12: type = name_ref B, %B.decl [template = constants.%B] -// CHECK:STDOUT: %a_val.ref: %A = name_ref a_val, %a_val -// CHECK:STDOUT: %B.ref.loc21_25: type = name_ref B, %B.decl [template = constants.%B] -// CHECK:STDOUT: %.loc21_22.1: %B = as_compatible %a_val.ref -// CHECK:STDOUT: %.loc21_22.2: %B = converted %a_val.ref, %.loc21_22.1 -// CHECK:STDOUT: %b_val: %B = bind_name b_val, %.loc21_22.2 -// CHECK:STDOUT: %B.ref.loc22_12: type = name_ref B, %B.decl [template = constants.%B] -// CHECK:STDOUT: %.loc22_13: type = ptr_type %B [template = constants.%.7] -// CHECK:STDOUT: %a_ref.ref.loc22: ref %A = name_ref a_ref, %a_ref -// CHECK:STDOUT: %B.ref.loc22_28: type = name_ref B, %B.decl [template = constants.%B] -// CHECK:STDOUT: %.loc22_25.1: ref %B = as_compatible %a_ref.ref.loc22 -// CHECK:STDOUT: %.loc22_25.2: ref %B = converted %a_ref.ref.loc22, %.loc22_25.1 -// CHECK:STDOUT: %.loc22_17: %.7 = addr_of %.loc22_25.2 -// CHECK:STDOUT: %b_ptr: %.7 = bind_name b_ptr, %.loc22_17 +// CHECK:STDOUT: %B.ref.loc21: type = name_ref B, %B.decl [template = constants.%B] +// CHECK:STDOUT: %B.ref.loc22: type = name_ref B, %B.decl [template = constants.%B] +// CHECK:STDOUT: %.loc22: type = ptr_type %B [template = constants.%.7] // CHECK:STDOUT: %B.ref.loc24: type = name_ref B, %B.decl [template = constants.%B] // CHECK:STDOUT: %b_factory.var: ref %B = var b_factory // CHECK:STDOUT: %b_factory: ref %B = bind_name b_factory, %b_factory.var @@ -217,11 +206,25 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: %.loc17_31.6: init %A = class_init (%.loc17_31.3, %.loc17_31.5), file.%a_ref.var [template = constants.%struct] // CHECK:STDOUT: %.loc17_32: init %A = converted %.loc17_31.1, %.loc17_31.6 [template = constants.%struct] // CHECK:STDOUT: assign file.%a_ref.var, %.loc17_32 +// CHECK:STDOUT: %a_ref.ref.loc18: ref %A = name_ref a_ref, file.%a_ref +// CHECK:STDOUT: %.loc18: %A = bind_value %a_ref.ref.loc18 +// CHECK:STDOUT: %a_val: %A = bind_name a_val, %.loc18 +// CHECK:STDOUT: %a_val.ref: %A = name_ref a_val, %a_val +// CHECK:STDOUT: %B.ref.loc21: type = name_ref B, file.%B.decl [template = constants.%B] +// CHECK:STDOUT: %.loc21_22.1: %B = as_compatible %a_val.ref +// CHECK:STDOUT: %.loc21_22.2: %B = converted %a_val.ref, %.loc21_22.1 +// CHECK:STDOUT: %b_val: %B = bind_name b_val, %.loc21_22.2 +// CHECK:STDOUT: %a_ref.ref.loc22: ref %A = name_ref a_ref, file.%a_ref +// CHECK:STDOUT: %B.ref.loc22: type = name_ref B, file.%B.decl [template = constants.%B] +// CHECK:STDOUT: %.loc22_25.1: ref %B = as_compatible %a_ref.ref.loc22 +// CHECK:STDOUT: %.loc22_25.2: ref %B = converted %a_ref.ref.loc22, %.loc22_25.1 +// CHECK:STDOUT: %.loc22_17: %.7 = addr_of %.loc22_25.2 +// CHECK:STDOUT: %b_ptr: %.7 = bind_name b_ptr, %.loc22_17 // CHECK:STDOUT: %A.ref: type = name_ref A, file.%A.decl [template = constants.%A] // CHECK:STDOUT: %Make.ref: %Make.type = name_ref Make, @A.%Make.decl [template = constants.%Make] // CHECK:STDOUT: %.loc24_5: ref %B = splice_block file.%b_factory.var {} // CHECK:STDOUT: %Make.call: init %A = call %Make.ref() to %.loc24_5 -// CHECK:STDOUT: %B.ref: type = name_ref B, file.%B.decl [template = constants.%B] +// CHECK:STDOUT: %B.ref.loc24: type = name_ref B, file.%B.decl [template = constants.%B] // CHECK:STDOUT: %.loc24_29.1: init %B = as_compatible %Make.call // CHECK:STDOUT: %.loc24_29.2: init %B = converted %Make.call, %.loc24_29.1 // CHECK:STDOUT: assign file.%b_factory.var, %.loc24_29.2 @@ -242,32 +245,19 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .A = %A.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .n = @__global_init.%n // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %A.decl: type = class_decl @A [template = constants.%A] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %A.ref.loc8_8: type = name_ref A, %A.decl [template = constants.%A] -// CHECK:STDOUT: %.loc8_13: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %A.ref: type = name_ref A, %A.decl [template = constants.%A] // CHECK:STDOUT: %import_ref.2: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc8: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc8_18.1: type = value_of_initializer %int.make_type_32.loc8 [template = i32] -// CHECK:STDOUT: %.loc8_18.2: type = converted %int.make_type_32.loc8, %.loc8_18.1 [template = i32] -// CHECK:STDOUT: %A.ref.loc8_26: type = name_ref A, %A.decl [template = constants.%A] -// CHECK:STDOUT: %.loc8_23.1: %A = as_compatible %.loc8_13 [template = constants.%.2] -// CHECK:STDOUT: %.loc8_23.2: %A = converted %.loc8_13, %.loc8_23.1 [template = constants.%.2] -// CHECK:STDOUT: %a: %A = bind_name a, %.loc8_23.2 // CHECK:STDOUT: %import_ref.3: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc9_8: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc9_8.1: type = value_of_initializer %int.make_type_32.loc9_8 [template = i32] -// CHECK:STDOUT: %.loc9_8.2: type = converted %int.make_type_32.loc9_8, %.loc9_8.1 [template = i32] -// CHECK:STDOUT: %a.ref: %A = name_ref a, %a +// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc9_8.1: type = value_of_initializer %int.make_type_32 [template = i32] +// CHECK:STDOUT: %.loc9_8.2: type = converted %int.make_type_32, %.loc9_8.1 [template = i32] // CHECK:STDOUT: %import_ref.4: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc9_19: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc9_19.1: type = value_of_initializer %int.make_type_32.loc9_19 [template = i32] -// CHECK:STDOUT: %.loc9_19.2: type = converted %int.make_type_32.loc9_19, %.loc9_19.1 [template = i32] -// CHECK:STDOUT: %.loc9_16.1: i32 = as_compatible %a.ref -// CHECK:STDOUT: %.loc9_16.2: i32 = converted %a.ref, %.loc9_16.1 -// CHECK:STDOUT: %n: i32 = bind_name n, %.loc9_16.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @A { @@ -282,6 +272,26 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc8_13: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %int.make_type_32.loc8: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc8_18.1: type = value_of_initializer %int.make_type_32.loc8 [template = i32] +// CHECK:STDOUT: %.loc8_18.2: type = converted %int.make_type_32.loc8, %.loc8_18.1 [template = i32] +// CHECK:STDOUT: %A.ref: type = name_ref A, file.%A.decl [template = constants.%A] +// CHECK:STDOUT: %.loc8_23.1: %A = as_compatible %.loc8_13 [template = constants.%.2] +// CHECK:STDOUT: %.loc8_23.2: %A = converted %.loc8_13, %.loc8_23.1 [template = constants.%.2] +// CHECK:STDOUT: %a: %A = bind_name a, %.loc8_23.2 +// CHECK:STDOUT: %a.ref: %A = name_ref a, %a +// CHECK:STDOUT: %int.make_type_32.loc9: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc9_19.1: type = value_of_initializer %int.make_type_32.loc9 [template = i32] +// CHECK:STDOUT: %.loc9_19.2: type = converted %int.make_type_32.loc9, %.loc9_19.1 [template = i32] +// CHECK:STDOUT: %.loc9_16.1: i32 = as_compatible %a.ref +// CHECK:STDOUT: %.loc9_16.2: i32 = converted %a.ref, %.loc9_16.1 +// CHECK:STDOUT: %n: i32 = bind_name n, %.loc9_16.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- multi_level_adapt.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -301,19 +311,14 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: .B = %B.decl // CHECK:STDOUT: .C = %C.decl // CHECK:STDOUT: .D = %D.decl +// CHECK:STDOUT: .d = @__global_init.%d // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %A.decl: type = class_decl @A [template = constants.%A] {} // CHECK:STDOUT: %B.decl: type = class_decl @B [template = constants.%B] {} // CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} // CHECK:STDOUT: %D.decl: type = class_decl @D [template = constants.%D] {} -// CHECK:STDOUT: %D.ref.loc9_8: type = name_ref D, %D.decl [template = constants.%D] -// CHECK:STDOUT: %.loc9_13: %.1 = struct_literal () -// CHECK:STDOUT: %D.ref.loc9_18: type = name_ref D, %D.decl [template = constants.%D] -// CHECK:STDOUT: %struct: %.1 = struct_value () [template = constants.%struct] -// CHECK:STDOUT: %.loc9_15.1: %D = as_compatible %struct [template = constants.%struct] -// CHECK:STDOUT: %.loc9_15.2: %D = converted %.loc9_13, %.loc9_15.1 [template = constants.%struct] -// CHECK:STDOUT: %d: %D = bind_name d, %.loc9_15.2 +// CHECK:STDOUT: %D.ref: type = name_ref D, %D.decl [template = constants.%D] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @A { @@ -349,6 +354,17 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: .Self = constants.%D // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc9_13: %.1 = struct_literal () +// CHECK:STDOUT: %D.ref: type = name_ref D, file.%D.decl [template = constants.%D] +// CHECK:STDOUT: %struct: %.1 = struct_value () [template = constants.%struct] +// CHECK:STDOUT: %.loc9_15.1: %D = as_compatible %struct [template = constants.%struct] +// CHECK:STDOUT: %.loc9_15.2: %D = converted %.loc9_13, %.loc9_15.1 [template = constants.%struct] +// CHECK:STDOUT: %d: %D = bind_name d, %.loc9_15.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_init_class.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -370,6 +386,7 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .A = %A.decl // CHECK:STDOUT: .B = %B.decl +// CHECK:STDOUT: .b_value = @__global_init.%b_value // CHECK:STDOUT: .b_init = %b_init // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -377,24 +394,7 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.2: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %B.decl: type = class_decl @B [template = constants.%B] {} -// CHECK:STDOUT: %B.ref.loc13_14: type = name_ref B, %B.decl [template = constants.%B] -// CHECK:STDOUT: %.loc13_25: i32 = int_literal 1 [template = constants.%.5] -// CHECK:STDOUT: %.loc13_33: i32 = int_literal 2 [template = constants.%.6] -// CHECK:STDOUT: %.loc13_34.1: %.3 = struct_literal (%.loc13_25, %.loc13_33) -// CHECK:STDOUT: %A.ref: type = name_ref A, %A.decl [template = constants.%A] -// CHECK:STDOUT: %.loc13_34.2: ref %A = temporary_storage -// CHECK:STDOUT: %.loc13_34.3: ref i32 = class_element_access %.loc13_34.2, element0 -// CHECK:STDOUT: %.loc13_34.4: init i32 = initialize_from %.loc13_25 to %.loc13_34.3 [template = constants.%.5] -// CHECK:STDOUT: %.loc13_34.5: ref i32 = class_element_access %.loc13_34.2, element1 -// CHECK:STDOUT: %.loc13_34.6: init i32 = initialize_from %.loc13_33 to %.loc13_34.5 [template = constants.%.6] -// CHECK:STDOUT: %.loc13_34.7: init %A = class_init (%.loc13_34.4, %.loc13_34.6), %.loc13_34.2 [template = constants.%struct] -// CHECK:STDOUT: %.loc13_34.8: ref %A = temporary %.loc13_34.2, %.loc13_34.7 -// CHECK:STDOUT: %.loc13_36: ref %A = converted %.loc13_34.1, %.loc13_34.8 -// CHECK:STDOUT: %B.ref.loc13_45: type = name_ref B, %B.decl [template = constants.%B] -// CHECK:STDOUT: %.loc13_42.1: ref %B = as_compatible %.loc13_36 -// CHECK:STDOUT: %.loc13_42.2: ref %B = converted %.loc13_36, %.loc13_42.1 -// CHECK:STDOUT: %.loc13_42.3: %B = bind_value %.loc13_42.2 -// CHECK:STDOUT: %b_value: %B = bind_name b_value, %.loc13_42.3 +// CHECK:STDOUT: %B.ref.loc13: type = name_ref B, %B.decl [template = constants.%B] // CHECK:STDOUT: %B.ref.loc24: type = name_ref B, %B.decl [template = constants.%B] // CHECK:STDOUT: %b_init.var: ref %B = var b_init // CHECK:STDOUT: %b_init: ref %B = bind_name b_init, %b_init.var @@ -428,10 +428,27 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { // CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc13_25: i32 = int_literal 1 [template = constants.%.5] +// CHECK:STDOUT: %.loc13_33: i32 = int_literal 2 [template = constants.%.6] +// CHECK:STDOUT: %.loc13_34.1: %.3 = struct_literal (%.loc13_25, %.loc13_33) +// CHECK:STDOUT: %A.ref.loc13: type = name_ref A, file.%A.decl [template = constants.%A] +// CHECK:STDOUT: %.loc13_34.2: ref %A = temporary_storage +// CHECK:STDOUT: %.loc13_34.3: ref i32 = class_element_access %.loc13_34.2, element0 +// CHECK:STDOUT: %.loc13_34.4: init i32 = initialize_from %.loc13_25 to %.loc13_34.3 [template = constants.%.5] +// CHECK:STDOUT: %.loc13_34.5: ref i32 = class_element_access %.loc13_34.2, element1 +// CHECK:STDOUT: %.loc13_34.6: init i32 = initialize_from %.loc13_33 to %.loc13_34.5 [template = constants.%.6] +// CHECK:STDOUT: %.loc13_34.7: init %A = class_init (%.loc13_34.4, %.loc13_34.6), %.loc13_34.2 [template = constants.%struct] +// CHECK:STDOUT: %.loc13_34.8: ref %A = temporary %.loc13_34.2, %.loc13_34.7 +// CHECK:STDOUT: %.loc13_36: ref %A = converted %.loc13_34.1, %.loc13_34.8 +// CHECK:STDOUT: %B.ref.loc13: type = name_ref B, file.%B.decl [template = constants.%B] +// CHECK:STDOUT: %.loc13_42.1: ref %B = as_compatible %.loc13_36 +// CHECK:STDOUT: %.loc13_42.2: ref %B = converted %.loc13_36, %.loc13_42.1 +// CHECK:STDOUT: %.loc13_42.3: %B = bind_value %.loc13_42.2 +// CHECK:STDOUT: %b_value: %B = bind_name b_value, %.loc13_42.3 // CHECK:STDOUT: %.loc24_24: i32 = int_literal 1 [template = constants.%.5] // CHECK:STDOUT: %.loc24_32: i32 = int_literal 2 [template = constants.%.6] // CHECK:STDOUT: %.loc24_33.1: %.3 = struct_literal (%.loc24_24, %.loc24_32) -// CHECK:STDOUT: %A.ref: type = name_ref A, file.%A.decl [template = constants.%A] +// CHECK:STDOUT: %A.ref.loc24: type = name_ref A, file.%A.decl [template = constants.%A] // CHECK:STDOUT: %.loc24_33.2: ref %A = temporary_storage // CHECK:STDOUT: %.loc24_33.3: ref i32 = class_element_access %.loc24_33.2, element0 // CHECK:STDOUT: %.loc24_33.4: init i32 = initialize_from %.loc24_24 to %.loc24_33.3 [template = constants.%.5] @@ -440,7 +457,7 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: %.loc24_33.7: init %A = class_init (%.loc24_33.4, %.loc24_33.6), %.loc24_33.2 [template = constants.%struct] // CHECK:STDOUT: %.loc24_33.8: ref %A = temporary %.loc24_33.2, %.loc24_33.7 // CHECK:STDOUT: %.loc24_35: ref %A = converted %.loc24_33.1, %.loc24_33.8 -// CHECK:STDOUT: %B.ref: type = name_ref B, file.%B.decl [template = constants.%B] +// CHECK:STDOUT: %B.ref.loc24: type = name_ref B, file.%B.decl [template = constants.%B] // CHECK:STDOUT: %.loc24_41.1: ref %B = as_compatible %.loc24_35 // CHECK:STDOUT: %.loc24_41.2: ref %B = converted %.loc24_35, %.loc24_41.1 // CHECK:STDOUT: %.loc24_41.3: %B = bind_value %.loc24_41.2 diff --git a/toolchain/check/testdata/as/as_type.carbon b/toolchain/check/testdata/as/as_type.carbon index 610de94e68e5..496a5847dd54 100644 --- a/toolchain/check/testdata/as/as_type.carbon +++ b/toolchain/check/testdata/as/as_type.carbon @@ -23,11 +23,18 @@ let t: type = (i32, i32) as type; // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .t = @__global_init.%t // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc11_16: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %import_ref.2: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %int.make_type_32.loc11_16: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %int.make_type_32.loc11_21: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc11_24: %.2 = tuple_literal (%int.make_type_32.loc11_16, %int.make_type_32.loc11_21) // CHECK:STDOUT: %.loc11_26.1: type = value_of_initializer %int.make_type_32.loc11_16 [template = i32] @@ -36,7 +43,6 @@ let t: type = (i32, i32) as type; // CHECK:STDOUT: %.loc11_26.4: type = converted %int.make_type_32.loc11_21, %.loc11_26.3 [template = i32] // CHECK:STDOUT: %.loc11_26.5: type = converted %.loc11_24, constants.%.3 [template = constants.%.3] // CHECK:STDOUT: %t: type = bind_name t, %.loc11_26.5 +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; -// CHECK:STDOUT: diff --git a/toolchain/check/testdata/as/fail_no_conversion.carbon b/toolchain/check/testdata/as/fail_no_conversion.carbon index 52318638d8de..809e3759c5da 100644 --- a/toolchain/check/testdata/as/fail_no_conversion.carbon +++ b/toolchain/check/testdata/as/fail_no_conversion.carbon @@ -28,6 +28,7 @@ let n: (i32, i32) = 1 as (i32, i32); // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .n = @__global_init.%n // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -40,10 +41,16 @@ let n: (i32, i32) = 1 as (i32, i32); // CHECK:STDOUT: %.loc14_17.4: type = value_of_initializer %int.make_type_32.loc14_14 [template = i32] // CHECK:STDOUT: %.loc14_17.5: type = converted %int.make_type_32.loc14_14, %.loc14_17.4 [template = i32] // CHECK:STDOUT: %.loc14_17.6: type = converted %.loc14_17.1, constants.%.3 [template = constants.%.3] -// CHECK:STDOUT: %.loc14_21: i32 = int_literal 1 [template = constants.%.5] // CHECK:STDOUT: %import_ref.3: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc14_27: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %import_ref.4: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc14_21: i32 = int_literal 1 [template = constants.%.5] +// CHECK:STDOUT: %int.make_type_32.loc14_27: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %int.make_type_32.loc14_32: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc14_35.1: %.2 = tuple_literal (%int.make_type_32.loc14_27, %int.make_type_32.loc14_32) // CHECK:STDOUT: %.loc14_35.2: type = value_of_initializer %int.make_type_32.loc14_27 [template = i32] @@ -52,7 +59,6 @@ let n: (i32, i32) = 1 as (i32, i32); // CHECK:STDOUT: %.loc14_35.5: type = converted %int.make_type_32.loc14_32, %.loc14_35.4 [template = i32] // CHECK:STDOUT: %.loc14_35.6: type = converted %.loc14_35.1, constants.%.3 [template = constants.%.3] // CHECK:STDOUT: %n: %.3 = bind_name n, +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; -// CHECK:STDOUT: diff --git a/toolchain/check/testdata/as/fail_not_type.carbon b/toolchain/check/testdata/as/fail_not_type.carbon index 9f33b9da4ad6..c7be07f883ab 100644 --- a/toolchain/check/testdata/as/fail_not_type.carbon +++ b/toolchain/check/testdata/as/fail_not_type.carbon @@ -26,16 +26,22 @@ let n: i32 = 1 as 2; // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .n = @__global_init.%n // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc14_8.1: type = value_of_initializer %int.make_type_32 [template = i32] // CHECK:STDOUT: %.loc14_8.2: type = converted %int.make_type_32, %.loc14_8.1 [template = i32] -// CHECK:STDOUT: %.loc14_14: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc14_19: i32 = int_literal 2 [template = constants.%.3] -// CHECK:STDOUT: %n: i32 = bind_name n, // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc14_14: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc14_19: i32 = int_literal 2 [template = constants.%.3] +// CHECK:STDOUT: %n: i32 = bind_name n, +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/basics/builtin_types.carbon b/toolchain/check/testdata/basics/builtin_types.carbon index 68ece9160ec1..6fbd076d3a08 100644 --- a/toolchain/check/testdata/basics/builtin_types.carbon +++ b/toolchain/check/testdata/basics/builtin_types.carbon @@ -33,6 +33,7 @@ var test_type: type = i32; // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .test_i32 = %test_i32 // CHECK:STDOUT: .test_f64 = %test_f64 +// CHECK:STDOUT: .test_str = @__global_init.%test_str // CHECK:STDOUT: .test_type = %test_type // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -49,8 +50,6 @@ var test_type: type = i32; // CHECK:STDOUT: %.loc12_15.3: type = converted %float.make_type, %.loc12_15.2 [template = f64] // CHECK:STDOUT: %test_f64.var: ref f64 = var test_f64 // CHECK:STDOUT: %test_f64: ref f64 = bind_name test_f64, %test_f64.var -// CHECK:STDOUT: %.loc13: String = string_literal "Test" [template = constants.%.6] -// CHECK:STDOUT: %test_str: String = bind_name test_str, %.loc13 // CHECK:STDOUT: %test_type.var: ref type = var test_type // CHECK:STDOUT: %test_type: ref type = bind_name test_type, %test_type.var // CHECK:STDOUT: %import_ref.3: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -66,6 +65,8 @@ var test_type: type = i32; // CHECK:STDOUT: assign file.%test_i32.var, %.loc11 // CHECK:STDOUT: %.loc12: f64 = float_literal 0.10000000000000001 [template = constants.%.4] // CHECK:STDOUT: assign file.%test_f64.var, %.loc12 +// CHECK:STDOUT: %.loc13: String = string_literal "Test" [template = constants.%.6] +// CHECK:STDOUT: %test_str: String = bind_name test_str, %.loc13 // CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: assign file.%test_type.var, %int.make_type_32 // CHECK:STDOUT: return diff --git a/toolchain/check/testdata/basics/fail_numeric_literal_overflow.carbon b/toolchain/check/testdata/basics/fail_numeric_literal_overflow.carbon index b327841a8812..2392cd1019af 100644 --- a/toolchain/check/testdata/basics/fail_numeric_literal_overflow.carbon +++ b/toolchain/check/testdata/basics/fail_numeric_literal_overflow.carbon @@ -51,38 +51,48 @@ let e: f64 = 5.0e39999999999999999993; // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: .c = @__global_init.%c +// CHECK:STDOUT: .d = @__global_init.%d +// CHECK:STDOUT: .e = @__global_init.%e // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc15: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc15_8.1: type = value_of_initializer %int.make_type_32.loc15 [template = i32] // CHECK:STDOUT: %.loc15_8.2: type = converted %int.make_type_32.loc15, %.loc15_8.1 [template = i32] -// CHECK:STDOUT: %a: i32 = bind_name a, // CHECK:STDOUT: %import_ref.2: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc21: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc21_8.1: type = value_of_initializer %int.make_type_32.loc21 [template = i32] // CHECK:STDOUT: %.loc21_8.2: type = converted %int.make_type_32.loc21, %.loc21_8.1 [template = i32] -// CHECK:STDOUT: %b: i32 = bind_name b, // CHECK:STDOUT: %import_ref.3: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc27: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc27_8.1: type = value_of_initializer %int.make_type_32.loc27 [template = i32] // CHECK:STDOUT: %.loc27_8.2: type = converted %int.make_type_32.loc27, %.loc27_8.1 [template = i32] -// CHECK:STDOUT: %c: i32 = bind_name c, // CHECK:STDOUT: %.loc33_8.1: i32 = int_literal 64 [template = constants.%.2] // CHECK:STDOUT: %import_ref.4: %Float.type = import_ref ir3, inst+31, loaded [template = constants.%Float] // CHECK:STDOUT: %float.make_type.loc33: init type = call constants.%Float(%.loc33_8.1) [template = f64] // CHECK:STDOUT: %.loc33_8.2: type = value_of_initializer %float.make_type.loc33 [template = f64] // CHECK:STDOUT: %.loc33_8.3: type = converted %float.make_type.loc33, %.loc33_8.2 [template = f64] -// CHECK:STDOUT: %d: f64 = bind_name d, // CHECK:STDOUT: %.loc38_8.1: i32 = int_literal 64 [template = constants.%.2] // CHECK:STDOUT: %import_ref.5: %Float.type = import_ref ir3, inst+31, loaded [template = constants.%Float] // CHECK:STDOUT: %float.make_type.loc38: init type = call constants.%Float(%.loc38_8.1) [template = f64] // CHECK:STDOUT: %.loc38_8.2: type = value_of_initializer %float.make_type.loc38 [template = f64] // CHECK:STDOUT: %.loc38_8.3: type = converted %float.make_type.loc38, %.loc38_8.2 [template = f64] -// CHECK:STDOUT: %e: f64 = bind_name e, // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: // CHECK:STDOUT: fn @Float(%size: i32) -> type = "float.make_type"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %a: i32 = bind_name a, +// CHECK:STDOUT: %b: i32 = bind_name b, +// CHECK:STDOUT: %c: i32 = bind_name c, +// CHECK:STDOUT: %d: f64 = bind_name d, +// CHECK:STDOUT: %e: f64 = bind_name e, +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/float/div.carbon b/toolchain/check/testdata/builtins/float/div.carbon index aae4ee62d1e3..9879779c448b 100644 --- a/toolchain/check/testdata/builtins/float/div.carbon +++ b/toolchain/check/testdata/builtins/float/div.carbon @@ -78,6 +78,8 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: .Div = %Div.decl // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: .a = %a.loc8 +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: .c = @__global_init.%c // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Float.type = import_ref ir3, inst+31, loaded [template = constants.%Float] @@ -136,25 +138,11 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %float.make_type.loc9: init type = call constants.%Float(%.loc9_8.1) [template = f64] // CHECK:STDOUT: %.loc9_8.2: type = value_of_initializer %float.make_type.loc9 [template = f64] // CHECK:STDOUT: %.loc9_8.3: type = converted %float.make_type.loc9, %.loc9_8.2 [template = f64] -// CHECK:STDOUT: %Div.ref.loc9: %Div.type = name_ref Div, %Div.decl [template = constants.%Div] -// CHECK:STDOUT: %.loc9_18: f64 = float_literal 1 [template = constants.%.6] -// CHECK:STDOUT: %.loc9_23: f64 = float_literal 0 [template = constants.%.7] -// CHECK:STDOUT: %float.div.loc9: init f64 = call %Div.ref.loc9(%.loc9_18, %.loc9_23) [template = constants.%.8] -// CHECK:STDOUT: %.loc9_27.1: f64 = value_of_initializer %float.div.loc9 [template = constants.%.8] -// CHECK:STDOUT: %.loc9_27.2: f64 = converted %float.div.loc9, %.loc9_27.1 [template = constants.%.8] -// CHECK:STDOUT: %b.loc9: f64 = bind_name b, %.loc9_27.2 // CHECK:STDOUT: %.loc10_8.1: i32 = int_literal 64 [template = constants.%.1] // CHECK:STDOUT: %import_ref.9: %Float.type = import_ref ir3, inst+31, loaded [template = constants.%Float] // CHECK:STDOUT: %float.make_type.loc10: init type = call constants.%Float(%.loc10_8.1) [template = f64] // CHECK:STDOUT: %.loc10_8.2: type = value_of_initializer %float.make_type.loc10 [template = f64] // CHECK:STDOUT: %.loc10_8.3: type = converted %float.make_type.loc10, %.loc10_8.2 [template = f64] -// CHECK:STDOUT: %Div.ref.loc10: %Div.type = name_ref Div, %Div.decl [template = constants.%Div] -// CHECK:STDOUT: %.loc10_18: f64 = float_literal 0 [template = constants.%.7] -// CHECK:STDOUT: %.loc10_23: f64 = float_literal 0 [template = constants.%.7] -// CHECK:STDOUT: %float.div.loc10: init f64 = call %Div.ref.loc10(%.loc10_18, %.loc10_23) [template = constants.%.9] -// CHECK:STDOUT: %.loc10_27.1: f64 = value_of_initializer %float.div.loc10 [template = constants.%.9] -// CHECK:STDOUT: %.loc10_27.2: f64 = converted %float.div.loc10, %.loc10_27.1 [template = constants.%.9] -// CHECK:STDOUT: %c: f64 = bind_name c, %.loc10_27.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Float(%size: i32) -> type = "float.make_type"; @@ -174,11 +162,25 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Div.ref: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %Div.ref.loc8: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] // CHECK:STDOUT: %.loc8_18: f64 = float_literal 10 [template = constants.%.3] // CHECK:STDOUT: %.loc8_24: f64 = float_literal 2.5 [template = constants.%.4] -// CHECK:STDOUT: %float.div: init f64 = call %Div.ref(%.loc8_18, %.loc8_24) [template = constants.%.5] -// CHECK:STDOUT: assign file.%a.var, %float.div +// CHECK:STDOUT: %float.div.loc8: init f64 = call %Div.ref.loc8(%.loc8_18, %.loc8_24) [template = constants.%.5] +// CHECK:STDOUT: assign file.%a.var, %float.div.loc8 +// CHECK:STDOUT: %Div.ref.loc9: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %.loc9_18: f64 = float_literal 1 [template = constants.%.6] +// CHECK:STDOUT: %.loc9_23: f64 = float_literal 0 [template = constants.%.7] +// CHECK:STDOUT: %float.div.loc9: init f64 = call %Div.ref.loc9(%.loc9_18, %.loc9_23) [template = constants.%.8] +// CHECK:STDOUT: %.loc9_27.1: f64 = value_of_initializer %float.div.loc9 [template = constants.%.8] +// CHECK:STDOUT: %.loc9_27.2: f64 = converted %float.div.loc9, %.loc9_27.1 [template = constants.%.8] +// CHECK:STDOUT: %b: f64 = bind_name b, %.loc9_27.2 +// CHECK:STDOUT: %Div.ref.loc10: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %.loc10_18: f64 = float_literal 0 [template = constants.%.7] +// CHECK:STDOUT: %.loc10_23: f64 = float_literal 0 [template = constants.%.7] +// CHECK:STDOUT: %float.div.loc10: init f64 = call %Div.ref.loc10(%.loc10_18, %.loc10_23) [template = constants.%.9] +// CHECK:STDOUT: %.loc10_27.1: f64 = value_of_initializer %float.div.loc10 [template = constants.%.9] +// CHECK:STDOUT: %.loc10_27.2: f64 = converted %float.div.loc10, %.loc10_27.1 [template = constants.%.9] +// CHECK:STDOUT: %c: f64 = bind_name c, %.loc10_27.2 // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/float/negate.carbon b/toolchain/check/testdata/builtins/float/negate.carbon index ba60d316e9b2..8a206581cd77 100644 --- a/toolchain/check/testdata/builtins/float/negate.carbon +++ b/toolchain/check/testdata/builtins/float/negate.carbon @@ -91,6 +91,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Negate = %Negate.decl // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl +// CHECK:STDOUT: .a = @__global_init.%a // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Float.type = import_ref ir3, inst+31, loaded [template = constants.%Float] @@ -135,12 +136,6 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %float.make_type.loc8: init type = call constants.%Float(%.loc8_8.1) [template = f64] // CHECK:STDOUT: %.loc8_8.2: type = value_of_initializer %float.make_type.loc8 [template = f64] // CHECK:STDOUT: %.loc8_8.3: type = converted %float.make_type.loc8, %.loc8_8.2 [template = f64] -// CHECK:STDOUT: %Negate.ref: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] -// CHECK:STDOUT: %.loc8_21: f64 = float_literal 1.5 [template = constants.%.3] -// CHECK:STDOUT: %float.negate: init f64 = call %Negate.ref(%.loc8_21) [template = constants.%.4] -// CHECK:STDOUT: %.loc8_25.1: f64 = value_of_initializer %float.negate [template = constants.%.4] -// CHECK:STDOUT: %.loc8_25.2: f64 = converted %float.negate, %.loc8_25.1 [template = constants.%.4] -// CHECK:STDOUT: %a.loc8: f64 = bind_name a, %.loc8_25.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Float(%size: i32) -> type = "float.make_type"; @@ -157,6 +152,17 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: return %.loc5_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %.loc8_21: f64 = float_literal 1.5 [template = constants.%.3] +// CHECK:STDOUT: %float.negate: init f64 = call %Negate.ref(%.loc8_21) [template = constants.%.4] +// CHECK:STDOUT: %.loc8_25.1: f64 = value_of_initializer %float.negate [template = constants.%.4] +// CHECK:STDOUT: %.loc8_25.2: f64 = converted %float.negate, %.loc8_25.1 [template = constants.%.4] +// CHECK:STDOUT: %a: f64 = bind_name a, %.loc8_25.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_bad_decl.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { diff --git a/toolchain/check/testdata/builtins/int/and.carbon b/toolchain/check/testdata/builtins/int/and.carbon index bdbe2dc124a4..aab933a84492 100644 --- a/toolchain/check/testdata/builtins/int/and.carbon +++ b/toolchain/check/testdata/builtins/int/and.carbon @@ -41,6 +41,7 @@ fn RuntimeCall(a: i32, b: i32) -> i32 { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .And = %And.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -81,9 +82,6 @@ fn RuntimeCall(a: i32, b: i32) -> i32 { // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -120,3 +118,11 @@ fn RuntimeCall(a: i32, b: i32) -> i32 { // CHECK:STDOUT: return %.loc8_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/complement.carbon b/toolchain/check/testdata/builtins/int/complement.carbon index 296422246244..727b5474f73c 100644 --- a/toolchain/check/testdata/builtins/int/complement.carbon +++ b/toolchain/check/testdata/builtins/int/complement.carbon @@ -46,6 +46,7 @@ fn RuntimeCall(a: i32) -> i32 { // CHECK:STDOUT: .Complement = %Complement.decl // CHECK:STDOUT: .And = %And.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -103,9 +104,6 @@ fn RuntimeCall(a: i32) -> i32 { // CHECK:STDOUT: %.loc6_13.2: type = converted %int.make_type_32.loc6, %.loc6_13.1 [template = i32] // CHECK:STDOUT: %.loc6_26: type = array_type %.loc6_18, i32 [template = constants.%.6] // CHECK:STDOUT: %.loc6_27: type = ptr_type %.6 [template = constants.%.7] -// CHECK:STDOUT: %arr.ref: ref %.6 = name_ref arr, %arr -// CHECK:STDOUT: %.loc6_31: %.7 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.7 = bind_name arr_p, %.loc6_31 // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.9: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] { @@ -137,3 +135,11 @@ fn RuntimeCall(a: i32) -> i32 { // CHECK:STDOUT: return %.loc9_23.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.6 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc6: %.7 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.7 = bind_name arr_p, %.loc6 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/left_shift.carbon b/toolchain/check/testdata/builtins/int/left_shift.carbon index 1effcee956c9..2f3f2d44150e 100644 --- a/toolchain/check/testdata/builtins/int/left_shift.carbon +++ b/toolchain/check/testdata/builtins/int/left_shift.carbon @@ -85,6 +85,7 @@ let negative: i32 = LeftShift(1, Negate(1)); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .LeftShift = %LeftShift.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -125,9 +126,6 @@ let negative: i32 = LeftShift(1, Negate(1)); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_20: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_21: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_25: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_25 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -164,6 +162,14 @@ let negative: i32 = LeftShift(1, Negate(1)); // CHECK:STDOUT: return %.loc8_25.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_bad_shift.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -189,6 +195,14 @@ let negative: i32 = LeftShift(1, Negate(1)); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .LeftShift = %LeftShift.decl // CHECK:STDOUT: .Negate = %Negate.decl +// CHECK:STDOUT: .size_1 = @__global_init.%size_1 +// CHECK:STDOUT: .size_2 = @__global_init.%size_2 +// CHECK:STDOUT: .size_3 = @__global_init.%size_3 +// CHECK:STDOUT: .overflow_1 = @__global_init.%overflow_1 +// CHECK:STDOUT: .overflow_2 = @__global_init.%overflow_2 +// CHECK:STDOUT: .no_overflow_1 = @__global_init.%no_overflow_1 +// CHECK:STDOUT: .no_overflow_2 = @__global_init.%no_overflow_2 +// CHECK:STDOUT: .negative = @__global_init.%negative // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -227,94 +241,34 @@ let negative: i32 = LeftShift(1, Negate(1)); // CHECK:STDOUT: %int.make_type_32.loc8: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc8_13.1: type = value_of_initializer %int.make_type_32.loc8 [template = i32] // CHECK:STDOUT: %.loc8_13.2: type = converted %int.make_type_32.loc8, %.loc8_13.1 [template = i32] -// CHECK:STDOUT: %LeftShift.ref.loc8: %LeftShift.type = name_ref LeftShift, %LeftShift.decl [template = constants.%LeftShift] -// CHECK:STDOUT: %.loc8_29: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc8_32: i32 = int_literal 31 [template = constants.%.3] -// CHECK:STDOUT: %int.left_shift.loc8: init i32 = call %LeftShift.ref.loc8(%.loc8_29, %.loc8_32) [template = constants.%.4] -// CHECK:STDOUT: %.loc8_35.1: i32 = value_of_initializer %int.left_shift.loc8 [template = constants.%.4] -// CHECK:STDOUT: %.loc8_35.2: i32 = converted %int.left_shift.loc8, %.loc8_35.1 [template = constants.%.4] -// CHECK:STDOUT: %size_1: i32 = bind_name size_1, %.loc8_35.2 // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc13: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc13_13.1: type = value_of_initializer %int.make_type_32.loc13 [template = i32] // CHECK:STDOUT: %.loc13_13.2: type = converted %int.make_type_32.loc13, %.loc13_13.1 [template = i32] -// CHECK:STDOUT: %LeftShift.ref.loc13: %LeftShift.type = name_ref LeftShift, %LeftShift.decl [template = constants.%LeftShift] -// CHECK:STDOUT: %.loc13_29: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc13_32: i32 = int_literal 32 [template = constants.%.5] -// CHECK:STDOUT: %int.left_shift.loc13: init i32 = call %LeftShift.ref.loc13(%.loc13_29, %.loc13_32) [template = ] -// CHECK:STDOUT: %.loc13_35.1: i32 = value_of_initializer %int.left_shift.loc13 [template = ] -// CHECK:STDOUT: %.loc13_35.2: i32 = converted %int.left_shift.loc13, %.loc13_35.1 [template = ] -// CHECK:STDOUT: %size_2: i32 = bind_name size_2, %.loc13_35.2 // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc18: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc18_13.1: type = value_of_initializer %int.make_type_32.loc18 [template = i32] // CHECK:STDOUT: %.loc18_13.2: type = converted %int.make_type_32.loc18, %.loc18_13.1 [template = i32] -// CHECK:STDOUT: %LeftShift.ref.loc18: %LeftShift.type = name_ref LeftShift, %LeftShift.decl [template = constants.%LeftShift] -// CHECK:STDOUT: %.loc18_29: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc18_32: i32 = int_literal 33 [template = constants.%.6] -// CHECK:STDOUT: %int.left_shift.loc18: init i32 = call %LeftShift.ref.loc18(%.loc18_29, %.loc18_32) [template = ] -// CHECK:STDOUT: %.loc18_35.1: i32 = value_of_initializer %int.left_shift.loc18 [template = ] -// CHECK:STDOUT: %.loc18_35.2: i32 = converted %int.left_shift.loc18, %.loc18_35.1 [template = ] -// CHECK:STDOUT: %size_3: i32 = bind_name size_3, %.loc18_35.2 // CHECK:STDOUT: %import_ref.9: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc21: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc21_17.1: type = value_of_initializer %int.make_type_32.loc21 [template = i32] // CHECK:STDOUT: %.loc21_17.2: type = converted %int.make_type_32.loc21, %.loc21_17.1 [template = i32] -// CHECK:STDOUT: %LeftShift.ref.loc21: %LeftShift.type = name_ref LeftShift, %LeftShift.decl [template = constants.%LeftShift] -// CHECK:STDOUT: %.loc21_33: i32 = int_literal 1000 [template = constants.%.7] -// CHECK:STDOUT: %.loc21_39: i32 = int_literal 31 [template = constants.%.3] -// CHECK:STDOUT: %int.left_shift.loc21: init i32 = call %LeftShift.ref.loc21(%.loc21_33, %.loc21_39) [template = constants.%.8] -// CHECK:STDOUT: %.loc21_42.1: i32 = value_of_initializer %int.left_shift.loc21 [template = constants.%.8] -// CHECK:STDOUT: %.loc21_42.2: i32 = converted %int.left_shift.loc21, %.loc21_42.1 [template = constants.%.8] -// CHECK:STDOUT: %overflow_1: i32 = bind_name overflow_1, %.loc21_42.2 // CHECK:STDOUT: %import_ref.10: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc26: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc26_17.1: type = value_of_initializer %int.make_type_32.loc26 [template = i32] // CHECK:STDOUT: %.loc26_17.2: type = converted %int.make_type_32.loc26, %.loc26_17.1 [template = i32] -// CHECK:STDOUT: %LeftShift.ref.loc26: %LeftShift.type = name_ref LeftShift, %LeftShift.decl [template = constants.%LeftShift] -// CHECK:STDOUT: %.loc26_33: i32 = int_literal 1000 [template = constants.%.7] -// CHECK:STDOUT: %.loc26_39: i32 = int_literal 32 [template = constants.%.5] -// CHECK:STDOUT: %int.left_shift.loc26: init i32 = call %LeftShift.ref.loc26(%.loc26_33, %.loc26_39) [template = ] -// CHECK:STDOUT: %.loc26_42.1: i32 = value_of_initializer %int.left_shift.loc26 [template = ] -// CHECK:STDOUT: %.loc26_42.2: i32 = converted %int.left_shift.loc26, %.loc26_42.1 [template = ] -// CHECK:STDOUT: %overflow_2: i32 = bind_name overflow_2, %.loc26_42.2 // CHECK:STDOUT: %import_ref.11: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc29: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc29_20.1: type = value_of_initializer %int.make_type_32.loc29 [template = i32] // CHECK:STDOUT: %.loc29_20.2: type = converted %int.make_type_32.loc29, %.loc29_20.1 [template = i32] -// CHECK:STDOUT: %LeftShift.ref.loc29: %LeftShift.type = name_ref LeftShift, %LeftShift.decl [template = constants.%LeftShift] -// CHECK:STDOUT: %.loc29_36: i32 = int_literal 0 [template = constants.%.8] -// CHECK:STDOUT: %.loc29_39: i32 = int_literal 31 [template = constants.%.3] -// CHECK:STDOUT: %int.left_shift.loc29: init i32 = call %LeftShift.ref.loc29(%.loc29_36, %.loc29_39) [template = constants.%.8] -// CHECK:STDOUT: %.loc29_42.1: i32 = value_of_initializer %int.left_shift.loc29 [template = constants.%.8] -// CHECK:STDOUT: %.loc29_42.2: i32 = converted %int.left_shift.loc29, %.loc29_42.1 [template = constants.%.8] -// CHECK:STDOUT: %no_overflow_1: i32 = bind_name no_overflow_1, %.loc29_42.2 // CHECK:STDOUT: %import_ref.12: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc34: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc34_20.1: type = value_of_initializer %int.make_type_32.loc34 [template = i32] // CHECK:STDOUT: %.loc34_20.2: type = converted %int.make_type_32.loc34, %.loc34_20.1 [template = i32] -// CHECK:STDOUT: %LeftShift.ref.loc34: %LeftShift.type = name_ref LeftShift, %LeftShift.decl [template = constants.%LeftShift] -// CHECK:STDOUT: %.loc34_36: i32 = int_literal 0 [template = constants.%.8] -// CHECK:STDOUT: %.loc34_39: i32 = int_literal 32 [template = constants.%.5] -// CHECK:STDOUT: %int.left_shift.loc34: init i32 = call %LeftShift.ref.loc34(%.loc34_36, %.loc34_39) [template = ] -// CHECK:STDOUT: %.loc34_42.1: i32 = value_of_initializer %int.left_shift.loc34 [template = ] -// CHECK:STDOUT: %.loc34_42.2: i32 = converted %int.left_shift.loc34, %.loc34_42.1 [template = ] -// CHECK:STDOUT: %no_overflow_2: i32 = bind_name no_overflow_2, %.loc34_42.2 // CHECK:STDOUT: %import_ref.13: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc40: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc40_15.1: type = value_of_initializer %int.make_type_32.loc40 [template = i32] // CHECK:STDOUT: %.loc40_15.2: type = converted %int.make_type_32.loc40, %.loc40_15.1 [template = i32] -// CHECK:STDOUT: %LeftShift.ref.loc40: %LeftShift.type = name_ref LeftShift, %LeftShift.decl [template = constants.%LeftShift] -// CHECK:STDOUT: %.loc40_31: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %Negate.ref: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] -// CHECK:STDOUT: %.loc40_41: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %int.snegate: init i32 = call %Negate.ref(%.loc40_41) [template = constants.%.9] -// CHECK:STDOUT: %.loc40_30.1: i32 = value_of_initializer %int.snegate [template = constants.%.9] -// CHECK:STDOUT: %.loc40_30.2: i32 = converted %int.snegate, %.loc40_30.1 [template = constants.%.9] -// CHECK:STDOUT: %int.left_shift.loc40: init i32 = call %LeftShift.ref.loc40(%.loc40_31, %.loc40_30.2) [template = ] -// CHECK:STDOUT: %.loc40_44.1: i32 = value_of_initializer %int.left_shift.loc40 [template = ] -// CHECK:STDOUT: %.loc40_44.2: i32 = converted %int.left_shift.loc40, %.loc40_44.1 [template = ] -// CHECK:STDOUT: %negative: i32 = bind_name negative, %.loc40_44.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; @@ -323,3 +277,68 @@ let negative: i32 = LeftShift(1, Negate(1)); // CHECK:STDOUT: // CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.snegate"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %LeftShift.ref.loc8: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift] +// CHECK:STDOUT: %.loc8_29: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc8_32: i32 = int_literal 31 [template = constants.%.3] +// CHECK:STDOUT: %int.left_shift.loc8: init i32 = call %LeftShift.ref.loc8(%.loc8_29, %.loc8_32) [template = constants.%.4] +// CHECK:STDOUT: %.loc8_35.1: i32 = value_of_initializer %int.left_shift.loc8 [template = constants.%.4] +// CHECK:STDOUT: %.loc8_35.2: i32 = converted %int.left_shift.loc8, %.loc8_35.1 [template = constants.%.4] +// CHECK:STDOUT: %size_1: i32 = bind_name size_1, %.loc8_35.2 +// CHECK:STDOUT: %LeftShift.ref.loc13: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift] +// CHECK:STDOUT: %.loc13_29: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc13_32: i32 = int_literal 32 [template = constants.%.5] +// CHECK:STDOUT: %int.left_shift.loc13: init i32 = call %LeftShift.ref.loc13(%.loc13_29, %.loc13_32) [template = ] +// CHECK:STDOUT: %.loc13_35.1: i32 = value_of_initializer %int.left_shift.loc13 [template = ] +// CHECK:STDOUT: %.loc13_35.2: i32 = converted %int.left_shift.loc13, %.loc13_35.1 [template = ] +// CHECK:STDOUT: %size_2: i32 = bind_name size_2, %.loc13_35.2 +// CHECK:STDOUT: %LeftShift.ref.loc18: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift] +// CHECK:STDOUT: %.loc18_29: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc18_32: i32 = int_literal 33 [template = constants.%.6] +// CHECK:STDOUT: %int.left_shift.loc18: init i32 = call %LeftShift.ref.loc18(%.loc18_29, %.loc18_32) [template = ] +// CHECK:STDOUT: %.loc18_35.1: i32 = value_of_initializer %int.left_shift.loc18 [template = ] +// CHECK:STDOUT: %.loc18_35.2: i32 = converted %int.left_shift.loc18, %.loc18_35.1 [template = ] +// CHECK:STDOUT: %size_3: i32 = bind_name size_3, %.loc18_35.2 +// CHECK:STDOUT: %LeftShift.ref.loc21: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift] +// CHECK:STDOUT: %.loc21_33: i32 = int_literal 1000 [template = constants.%.7] +// CHECK:STDOUT: %.loc21_39: i32 = int_literal 31 [template = constants.%.3] +// CHECK:STDOUT: %int.left_shift.loc21: init i32 = call %LeftShift.ref.loc21(%.loc21_33, %.loc21_39) [template = constants.%.8] +// CHECK:STDOUT: %.loc21_42.1: i32 = value_of_initializer %int.left_shift.loc21 [template = constants.%.8] +// CHECK:STDOUT: %.loc21_42.2: i32 = converted %int.left_shift.loc21, %.loc21_42.1 [template = constants.%.8] +// CHECK:STDOUT: %overflow_1: i32 = bind_name overflow_1, %.loc21_42.2 +// CHECK:STDOUT: %LeftShift.ref.loc26: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift] +// CHECK:STDOUT: %.loc26_33: i32 = int_literal 1000 [template = constants.%.7] +// CHECK:STDOUT: %.loc26_39: i32 = int_literal 32 [template = constants.%.5] +// CHECK:STDOUT: %int.left_shift.loc26: init i32 = call %LeftShift.ref.loc26(%.loc26_33, %.loc26_39) [template = ] +// CHECK:STDOUT: %.loc26_42.1: i32 = value_of_initializer %int.left_shift.loc26 [template = ] +// CHECK:STDOUT: %.loc26_42.2: i32 = converted %int.left_shift.loc26, %.loc26_42.1 [template = ] +// CHECK:STDOUT: %overflow_2: i32 = bind_name overflow_2, %.loc26_42.2 +// CHECK:STDOUT: %LeftShift.ref.loc29: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift] +// CHECK:STDOUT: %.loc29_36: i32 = int_literal 0 [template = constants.%.8] +// CHECK:STDOUT: %.loc29_39: i32 = int_literal 31 [template = constants.%.3] +// CHECK:STDOUT: %int.left_shift.loc29: init i32 = call %LeftShift.ref.loc29(%.loc29_36, %.loc29_39) [template = constants.%.8] +// CHECK:STDOUT: %.loc29_42.1: i32 = value_of_initializer %int.left_shift.loc29 [template = constants.%.8] +// CHECK:STDOUT: %.loc29_42.2: i32 = converted %int.left_shift.loc29, %.loc29_42.1 [template = constants.%.8] +// CHECK:STDOUT: %no_overflow_1: i32 = bind_name no_overflow_1, %.loc29_42.2 +// CHECK:STDOUT: %LeftShift.ref.loc34: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift] +// CHECK:STDOUT: %.loc34_36: i32 = int_literal 0 [template = constants.%.8] +// CHECK:STDOUT: %.loc34_39: i32 = int_literal 32 [template = constants.%.5] +// CHECK:STDOUT: %int.left_shift.loc34: init i32 = call %LeftShift.ref.loc34(%.loc34_36, %.loc34_39) [template = ] +// CHECK:STDOUT: %.loc34_42.1: i32 = value_of_initializer %int.left_shift.loc34 [template = ] +// CHECK:STDOUT: %.loc34_42.2: i32 = converted %int.left_shift.loc34, %.loc34_42.1 [template = ] +// CHECK:STDOUT: %no_overflow_2: i32 = bind_name no_overflow_2, %.loc34_42.2 +// CHECK:STDOUT: %LeftShift.ref.loc40: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift] +// CHECK:STDOUT: %.loc40_31: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %.loc40_41: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %int.snegate: init i32 = call %Negate.ref(%.loc40_41) [template = constants.%.9] +// CHECK:STDOUT: %.loc40_30.1: i32 = value_of_initializer %int.snegate [template = constants.%.9] +// CHECK:STDOUT: %.loc40_30.2: i32 = converted %int.snegate, %.loc40_30.1 [template = constants.%.9] +// CHECK:STDOUT: %int.left_shift.loc40: init i32 = call %LeftShift.ref.loc40(%.loc40_31, %.loc40_30.2) [template = ] +// CHECK:STDOUT: %.loc40_44.1: i32 = value_of_initializer %int.left_shift.loc40 [template = ] +// CHECK:STDOUT: %.loc40_44.2: i32 = converted %int.left_shift.loc40, %.loc40_44.1 [template = ] +// CHECK:STDOUT: %negative: i32 = bind_name negative, %.loc40_44.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/or.carbon b/toolchain/check/testdata/builtins/int/or.carbon index a2b0d5f58ea7..b8cfc1efa511 100644 --- a/toolchain/check/testdata/builtins/int/or.carbon +++ b/toolchain/check/testdata/builtins/int/or.carbon @@ -41,6 +41,7 @@ fn RuntimeCall(a: i32, b: i32) -> i32 { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Or = %Or.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -81,9 +82,6 @@ fn RuntimeCall(a: i32, b: i32) -> i32 { // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_20: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_21: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_25: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_25 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -120,3 +118,11 @@ fn RuntimeCall(a: i32, b: i32) -> i32 { // CHECK:STDOUT: return %.loc8_18.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/right_shift.carbon b/toolchain/check/testdata/builtins/int/right_shift.carbon index 6f50ffae4f9e..aa7bf5236c10 100644 --- a/toolchain/check/testdata/builtins/int/right_shift.carbon +++ b/toolchain/check/testdata/builtins/int/right_shift.carbon @@ -86,6 +86,7 @@ let negative: i32 = RightShift(1, Negate(1)); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .RightShift = %RightShift.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -126,9 +127,6 @@ let negative: i32 = RightShift(1, Negate(1)); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -165,6 +163,14 @@ let negative: i32 = RightShift(1, Negate(1)); // CHECK:STDOUT: return %.loc8_26.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- arith_shift.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -194,7 +200,9 @@ let negative: i32 = RightShift(1, Negate(1)); // CHECK:STDOUT: .RightShift = %RightShift.decl // CHECK:STDOUT: .Negate = %Negate.decl // CHECK:STDOUT: .arr1 = %arr1 +// CHECK:STDOUT: .arr1_p = @__global_init.%arr1_p // CHECK:STDOUT: .arr2 = %arr2 +// CHECK:STDOUT: .arr2_p = @__global_init.%arr2_p // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -255,9 +263,6 @@ let negative: i32 = RightShift(1, Negate(1)); // CHECK:STDOUT: %.loc11_14.2: type = converted %int.make_type_32.loc11, %.loc11_14.1 [template = i32] // CHECK:STDOUT: %.loc11_20: type = array_type %.loc11_19, i32 [template = constants.%.4] // CHECK:STDOUT: %.loc11_21: type = ptr_type %.4 [template = constants.%.5] -// CHECK:STDOUT: %arr1.ref: ref %.4 = name_ref arr1, %arr1 -// CHECK:STDOUT: %.loc11_25: %.5 = addr_of %arr1.ref -// CHECK:STDOUT: %arr1_p: %.5 = bind_name arr1_p, %.loc11_25 // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc14: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %Negate.ref.loc14_17: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] @@ -284,9 +289,6 @@ let negative: i32 = RightShift(1, Negate(1)); // CHECK:STDOUT: %.loc15_14.2: type = converted %int.make_type_32.loc15, %.loc15_14.1 [template = i32] // CHECK:STDOUT: %.loc15_20: type = array_type %.loc15_19, i32 [template = constants.%.11] // CHECK:STDOUT: %.loc15_21: type = ptr_type %.11 [template = constants.%.12] -// CHECK:STDOUT: %arr2.ref: ref %.11 = name_ref arr2, %arr2 -// CHECK:STDOUT: %.loc15_25: %.12 = addr_of %arr2.ref -// CHECK:STDOUT: %arr2_p: %.12 = bind_name arr2_p, %.loc15_25 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; @@ -295,6 +297,17 @@ let negative: i32 = RightShift(1, Negate(1)); // CHECK:STDOUT: // CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.snegate"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr1.ref: ref %.4 = name_ref arr1, file.%arr1 +// CHECK:STDOUT: %.loc11: %.5 = addr_of %arr1.ref +// CHECK:STDOUT: %arr1_p: %.5 = bind_name arr1_p, %.loc11 +// CHECK:STDOUT: %arr2.ref: ref %.11 = name_ref arr2, file.%arr2 +// CHECK:STDOUT: %.loc15: %.12 = addr_of %arr2.ref +// CHECK:STDOUT: %arr2_p: %.12 = bind_name arr2_p, %.loc15 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_bad_shift.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -318,6 +331,10 @@ let negative: i32 = RightShift(1, Negate(1)); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .RightShift = %RightShift.decl // CHECK:STDOUT: .Negate = %Negate.decl +// CHECK:STDOUT: .size_1 = @__global_init.%size_1 +// CHECK:STDOUT: .size_2 = @__global_init.%size_2 +// CHECK:STDOUT: .size_3 = @__global_init.%size_3 +// CHECK:STDOUT: .negative = @__global_init.%negative // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -356,50 +373,18 @@ let negative: i32 = RightShift(1, Negate(1)); // CHECK:STDOUT: %int.make_type_32.loc8: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc8_13.1: type = value_of_initializer %int.make_type_32.loc8 [template = i32] // CHECK:STDOUT: %.loc8_13.2: type = converted %int.make_type_32.loc8, %.loc8_13.1 [template = i32] -// CHECK:STDOUT: %RightShift.ref.loc8: %RightShift.type = name_ref RightShift, %RightShift.decl [template = constants.%RightShift] -// CHECK:STDOUT: %.loc8_30: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc8_33: i32 = int_literal 31 [template = constants.%.3] -// CHECK:STDOUT: %int.right_shift.loc8: init i32 = call %RightShift.ref.loc8(%.loc8_30, %.loc8_33) [template = constants.%.4] -// CHECK:STDOUT: %.loc8_36.1: i32 = value_of_initializer %int.right_shift.loc8 [template = constants.%.4] -// CHECK:STDOUT: %.loc8_36.2: i32 = converted %int.right_shift.loc8, %.loc8_36.1 [template = constants.%.4] -// CHECK:STDOUT: %size_1: i32 = bind_name size_1, %.loc8_36.2 // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc13: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc13_13.1: type = value_of_initializer %int.make_type_32.loc13 [template = i32] // CHECK:STDOUT: %.loc13_13.2: type = converted %int.make_type_32.loc13, %.loc13_13.1 [template = i32] -// CHECK:STDOUT: %RightShift.ref.loc13: %RightShift.type = name_ref RightShift, %RightShift.decl [template = constants.%RightShift] -// CHECK:STDOUT: %.loc13_30: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc13_33: i32 = int_literal 32 [template = constants.%.5] -// CHECK:STDOUT: %int.right_shift.loc13: init i32 = call %RightShift.ref.loc13(%.loc13_30, %.loc13_33) [template = ] -// CHECK:STDOUT: %.loc13_36.1: i32 = value_of_initializer %int.right_shift.loc13 [template = ] -// CHECK:STDOUT: %.loc13_36.2: i32 = converted %int.right_shift.loc13, %.loc13_36.1 [template = ] -// CHECK:STDOUT: %size_2: i32 = bind_name size_2, %.loc13_36.2 // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc18: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc18_13.1: type = value_of_initializer %int.make_type_32.loc18 [template = i32] // CHECK:STDOUT: %.loc18_13.2: type = converted %int.make_type_32.loc18, %.loc18_13.1 [template = i32] -// CHECK:STDOUT: %RightShift.ref.loc18: %RightShift.type = name_ref RightShift, %RightShift.decl [template = constants.%RightShift] -// CHECK:STDOUT: %.loc18_30: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc18_33: i32 = int_literal 33 [template = constants.%.6] -// CHECK:STDOUT: %int.right_shift.loc18: init i32 = call %RightShift.ref.loc18(%.loc18_30, %.loc18_33) [template = ] -// CHECK:STDOUT: %.loc18_36.1: i32 = value_of_initializer %int.right_shift.loc18 [template = ] -// CHECK:STDOUT: %.loc18_36.2: i32 = converted %int.right_shift.loc18, %.loc18_36.1 [template = ] -// CHECK:STDOUT: %size_3: i32 = bind_name size_3, %.loc18_36.2 // CHECK:STDOUT: %import_ref.9: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc24: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc24_15.1: type = value_of_initializer %int.make_type_32.loc24 [template = i32] // CHECK:STDOUT: %.loc24_15.2: type = converted %int.make_type_32.loc24, %.loc24_15.1 [template = i32] -// CHECK:STDOUT: %RightShift.ref.loc24: %RightShift.type = name_ref RightShift, %RightShift.decl [template = constants.%RightShift] -// CHECK:STDOUT: %.loc24_32: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %Negate.ref: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] -// CHECK:STDOUT: %.loc24_42: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %int.snegate: init i32 = call %Negate.ref(%.loc24_42) [template = constants.%.7] -// CHECK:STDOUT: %.loc24_31.1: i32 = value_of_initializer %int.snegate [template = constants.%.7] -// CHECK:STDOUT: %.loc24_31.2: i32 = converted %int.snegate, %.loc24_31.1 [template = constants.%.7] -// CHECK:STDOUT: %int.right_shift.loc24: init i32 = call %RightShift.ref.loc24(%.loc24_32, %.loc24_31.2) [template = ] -// CHECK:STDOUT: %.loc24_45.1: i32 = value_of_initializer %int.right_shift.loc24 [template = ] -// CHECK:STDOUT: %.loc24_45.2: i32 = converted %int.right_shift.loc24, %.loc24_45.1 [template = ] -// CHECK:STDOUT: %negative: i32 = bind_name negative, %.loc24_45.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; @@ -408,3 +393,40 @@ let negative: i32 = RightShift(1, Negate(1)); // CHECK:STDOUT: // CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.snegate"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %RightShift.ref.loc8: %RightShift.type = name_ref RightShift, file.%RightShift.decl [template = constants.%RightShift] +// CHECK:STDOUT: %.loc8_30: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc8_33: i32 = int_literal 31 [template = constants.%.3] +// CHECK:STDOUT: %int.right_shift.loc8: init i32 = call %RightShift.ref.loc8(%.loc8_30, %.loc8_33) [template = constants.%.4] +// CHECK:STDOUT: %.loc8_36.1: i32 = value_of_initializer %int.right_shift.loc8 [template = constants.%.4] +// CHECK:STDOUT: %.loc8_36.2: i32 = converted %int.right_shift.loc8, %.loc8_36.1 [template = constants.%.4] +// CHECK:STDOUT: %size_1: i32 = bind_name size_1, %.loc8_36.2 +// CHECK:STDOUT: %RightShift.ref.loc13: %RightShift.type = name_ref RightShift, file.%RightShift.decl [template = constants.%RightShift] +// CHECK:STDOUT: %.loc13_30: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc13_33: i32 = int_literal 32 [template = constants.%.5] +// CHECK:STDOUT: %int.right_shift.loc13: init i32 = call %RightShift.ref.loc13(%.loc13_30, %.loc13_33) [template = ] +// CHECK:STDOUT: %.loc13_36.1: i32 = value_of_initializer %int.right_shift.loc13 [template = ] +// CHECK:STDOUT: %.loc13_36.2: i32 = converted %int.right_shift.loc13, %.loc13_36.1 [template = ] +// CHECK:STDOUT: %size_2: i32 = bind_name size_2, %.loc13_36.2 +// CHECK:STDOUT: %RightShift.ref.loc18: %RightShift.type = name_ref RightShift, file.%RightShift.decl [template = constants.%RightShift] +// CHECK:STDOUT: %.loc18_30: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc18_33: i32 = int_literal 33 [template = constants.%.6] +// CHECK:STDOUT: %int.right_shift.loc18: init i32 = call %RightShift.ref.loc18(%.loc18_30, %.loc18_33) [template = ] +// CHECK:STDOUT: %.loc18_36.1: i32 = value_of_initializer %int.right_shift.loc18 [template = ] +// CHECK:STDOUT: %.loc18_36.2: i32 = converted %int.right_shift.loc18, %.loc18_36.1 [template = ] +// CHECK:STDOUT: %size_3: i32 = bind_name size_3, %.loc18_36.2 +// CHECK:STDOUT: %RightShift.ref.loc24: %RightShift.type = name_ref RightShift, file.%RightShift.decl [template = constants.%RightShift] +// CHECK:STDOUT: %.loc24_32: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %.loc24_42: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %int.snegate: init i32 = call %Negate.ref(%.loc24_42) [template = constants.%.7] +// CHECK:STDOUT: %.loc24_31.1: i32 = value_of_initializer %int.snegate [template = constants.%.7] +// CHECK:STDOUT: %.loc24_31.2: i32 = converted %int.snegate, %.loc24_31.1 [template = constants.%.7] +// CHECK:STDOUT: %int.right_shift.loc24: init i32 = call %RightShift.ref.loc24(%.loc24_32, %.loc24_31.2) [template = ] +// CHECK:STDOUT: %.loc24_45.1: i32 = value_of_initializer %int.right_shift.loc24 [template = ] +// CHECK:STDOUT: %.loc24_45.2: i32 = converted %int.right_shift.loc24, %.loc24_45.1 [template = ] +// CHECK:STDOUT: %negative: i32 = bind_name negative, %.loc24_45.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/sadd.carbon b/toolchain/check/testdata/builtins/int/sadd.carbon index 115fe80b921c..8b939f197465 100644 --- a/toolchain/check/testdata/builtins/int/sadd.carbon +++ b/toolchain/check/testdata/builtins/int/sadd.carbon @@ -111,6 +111,7 @@ let b: i32 = Add(0x7FFFFFFF, 1); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Add = %Add.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -151,9 +152,6 @@ let b: i32 = Add(0x7FFFFFFF, 1); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -190,6 +188,14 @@ let b: i32 = Add(0x7FFFFFFF, 1); // CHECK:STDOUT: return %.loc8_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_bad_decl.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -467,6 +473,8 @@ let b: i32 = Add(0x7FFFFFFF, 1); // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Add = %Add.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -492,27 +500,32 @@ let b: i32 = Add(0x7FFFFFFF, 1); // CHECK:STDOUT: %int.make_type_32.loc6: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc6_8.1: type = value_of_initializer %int.make_type_32.loc6 [template = i32] // CHECK:STDOUT: %.loc6_8.2: type = converted %int.make_type_32.loc6, %.loc6_8.1 [template = i32] -// CHECK:STDOUT: %Add.ref.loc6: %Add.type = name_ref Add, %Add.decl [template = constants.%Add] -// CHECK:STDOUT: %.loc6_18: i32 = int_literal 2147483647 [template = constants.%.2] -// CHECK:STDOUT: %.loc6_30: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %int.sadd.loc6: init i32 = call %Add.ref.loc6(%.loc6_18, %.loc6_30) [template = constants.%.2] -// CHECK:STDOUT: %.loc6_32.1: i32 = value_of_initializer %int.sadd.loc6 [template = constants.%.2] -// CHECK:STDOUT: %.loc6_32.2: i32 = converted %int.sadd.loc6, %.loc6_32.1 [template = constants.%.2] -// CHECK:STDOUT: %a.loc6: i32 = bind_name a, %.loc6_32.2 // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc10: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc10_8.1: type = value_of_initializer %int.make_type_32.loc10 [template = i32] // CHECK:STDOUT: %.loc10_8.2: type = converted %int.make_type_32.loc10, %.loc10_8.1 [template = i32] -// CHECK:STDOUT: %Add.ref.loc10: %Add.type = name_ref Add, %Add.decl [template = constants.%Add] -// CHECK:STDOUT: %.loc10_18: i32 = int_literal 2147483647 [template = constants.%.2] -// CHECK:STDOUT: %.loc10_30: i32 = int_literal 1 [template = constants.%.4] -// CHECK:STDOUT: %int.sadd.loc10: init i32 = call %Add.ref.loc10(%.loc10_18, %.loc10_30) [template = constants.%.5] -// CHECK:STDOUT: %.loc10_32.1: i32 = value_of_initializer %int.sadd.loc10 [template = constants.%.5] -// CHECK:STDOUT: %.loc10_32.2: i32 = converted %int.sadd.loc10, %.loc10_32.1 [template = constants.%.5] -// CHECK:STDOUT: %b.loc10: i32 = bind_name b, %.loc10_32.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: // CHECK:STDOUT: fn @Add(%a: i32, %b: i32) -> i32 = "int.sadd"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Add.ref.loc6: %Add.type = name_ref Add, file.%Add.decl [template = constants.%Add] +// CHECK:STDOUT: %.loc6_18: i32 = int_literal 2147483647 [template = constants.%.2] +// CHECK:STDOUT: %.loc6_30: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %int.sadd.loc6: init i32 = call %Add.ref.loc6(%.loc6_18, %.loc6_30) [template = constants.%.2] +// CHECK:STDOUT: %.loc6_32.1: i32 = value_of_initializer %int.sadd.loc6 [template = constants.%.2] +// CHECK:STDOUT: %.loc6_32.2: i32 = converted %int.sadd.loc6, %.loc6_32.1 [template = constants.%.2] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc6_32.2 +// CHECK:STDOUT: %Add.ref.loc10: %Add.type = name_ref Add, file.%Add.decl [template = constants.%Add] +// CHECK:STDOUT: %.loc10_18: i32 = int_literal 2147483647 [template = constants.%.2] +// CHECK:STDOUT: %.loc10_30: i32 = int_literal 1 [template = constants.%.4] +// CHECK:STDOUT: %int.sadd.loc10: init i32 = call %Add.ref.loc10(%.loc10_18, %.loc10_30) [template = constants.%.5] +// CHECK:STDOUT: %.loc10_32.1: i32 = value_of_initializer %int.sadd.loc10 [template = constants.%.5] +// CHECK:STDOUT: %.loc10_32.2: i32 = converted %int.sadd.loc10, %.loc10_32.1 [template = constants.%.5] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc10_32.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/sdiv.carbon b/toolchain/check/testdata/builtins/int/sdiv.carbon index 4ab40b2ecaba..91208b197370 100644 --- a/toolchain/check/testdata/builtins/int/sdiv.carbon +++ b/toolchain/check/testdata/builtins/int/sdiv.carbon @@ -79,6 +79,7 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Div = %Div.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -119,9 +120,6 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -158,6 +156,14 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: return %.loc8_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_overflow.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -183,6 +189,9 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: .Div = %Div.decl // CHECK:STDOUT: .Sub = %Sub.decl // CHECK:STDOUT: .Negate = %Negate.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: .c = @__global_init.%c // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -240,11 +249,31 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %int.make_type_32.loc9: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc9_8.1: type = value_of_initializer %int.make_type_32.loc9 [template = i32] // CHECK:STDOUT: %.loc9_8.2: type = converted %int.make_type_32.loc9, %.loc9_8.1 [template = i32] -// CHECK:STDOUT: %Div.ref.loc9: %Div.type = name_ref Div, %Div.decl [template = constants.%Div] -// CHECK:STDOUT: %Negate.ref.loc9_18: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %import_ref.10: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc12: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc12_8.1: type = value_of_initializer %int.make_type_32.loc12 [template = i32] +// CHECK:STDOUT: %.loc12_8.2: type = converted %int.make_type_32.loc12, %.loc12_8.1 [template = i32] +// CHECK:STDOUT: %import_ref.11: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc19: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc19_8.1: type = value_of_initializer %int.make_type_32.loc19 [template = i32] +// CHECK:STDOUT: %.loc19_8.2: type = converted %int.make_type_32.loc19, %.loc19_8.1 [template = i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Div(%a: i32, %b: i32) -> i32 = "int.sdiv"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.ssub"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.snegate"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Div.ref.loc9: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %Negate.ref.loc9_18: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc9_25: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.snegate.loc9_24: init i32 = call %Negate.ref.loc9_18(%.loc9_25) [template = constants.%.3] -// CHECK:STDOUT: %Negate.ref.loc9_39: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %Negate.ref.loc9_39: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc9_46: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %int.snegate.loc9_45: init i32 = call %Negate.ref.loc9_39(%.loc9_46) [template = constants.%.5] // CHECK:STDOUT: %.loc9_17.1: i32 = value_of_initializer %int.snegate.loc9_24 [template = constants.%.3] @@ -254,14 +283,10 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %int.sdiv.loc9: init i32 = call %Div.ref.loc9(%.loc9_17.2, %.loc9_17.4) [template = constants.%.2] // CHECK:STDOUT: %.loc9_49.1: i32 = value_of_initializer %int.sdiv.loc9 [template = constants.%.2] // CHECK:STDOUT: %.loc9_49.2: i32 = converted %int.sdiv.loc9, %.loc9_49.1 [template = constants.%.2] -// CHECK:STDOUT: %a.loc9: i32 = bind_name a, %.loc9_49.2 -// CHECK:STDOUT: %import_ref.10: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc12: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc12_8.1: type = value_of_initializer %int.make_type_32.loc12 [template = i32] -// CHECK:STDOUT: %.loc12_8.2: type = converted %int.make_type_32.loc12, %.loc12_8.1 [template = i32] -// CHECK:STDOUT: %Div.ref.loc12: %Div.type = name_ref Div, %Div.decl [template = constants.%Div] -// CHECK:STDOUT: %Sub.ref.loc12: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Negate.ref.loc12: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc9_49.2 +// CHECK:STDOUT: %Div.ref.loc12: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %Sub.ref.loc12: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Negate.ref.loc12: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc12_29: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.snegate.loc12: init i32 = call %Negate.ref.loc12(%.loc12_29) [template = constants.%.3] // CHECK:STDOUT: %.loc12_43: i32 = int_literal 1 [template = constants.%.4] @@ -274,21 +299,17 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %int.sdiv.loc12: init i32 = call %Div.ref.loc12(%.loc12_17.2, %.loc12_47) [template = constants.%.6] // CHECK:STDOUT: %.loc12_49.1: i32 = value_of_initializer %int.sdiv.loc12 [template = constants.%.6] // CHECK:STDOUT: %.loc12_49.2: i32 = converted %int.sdiv.loc12, %.loc12_49.1 [template = constants.%.6] -// CHECK:STDOUT: %b.loc12: i32 = bind_name b, %.loc12_49.2 -// CHECK:STDOUT: %import_ref.11: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc19: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc19_8.1: type = value_of_initializer %int.make_type_32.loc19 [template = i32] -// CHECK:STDOUT: %.loc19_8.2: type = converted %int.make_type_32.loc19, %.loc19_8.1 [template = i32] -// CHECK:STDOUT: %Div.ref.loc19: %Div.type = name_ref Div, %Div.decl [template = constants.%Div] -// CHECK:STDOUT: %Sub.ref.loc19: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Negate.ref.loc19_22: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc12_49.2 +// CHECK:STDOUT: %Div.ref.loc19: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %Sub.ref.loc19: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Negate.ref.loc19_22: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc19_29: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.snegate.loc19_28: init i32 = call %Negate.ref.loc19_22(%.loc19_29) [template = constants.%.3] // CHECK:STDOUT: %.loc19_43: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %.loc19_21.1: i32 = value_of_initializer %int.snegate.loc19_28 [template = constants.%.3] // CHECK:STDOUT: %.loc19_21.2: i32 = converted %int.snegate.loc19_28, %.loc19_21.1 [template = constants.%.3] // CHECK:STDOUT: %int.ssub.loc19: init i32 = call %Sub.ref.loc19(%.loc19_21.2, %.loc19_43) [template = constants.%.6] -// CHECK:STDOUT: %Negate.ref.loc19_47: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %Negate.ref.loc19_47: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc19_54: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %int.snegate.loc19_53: init i32 = call %Negate.ref.loc19_47(%.loc19_54) [template = constants.%.5] // CHECK:STDOUT: %.loc19_17.1: i32 = value_of_initializer %int.ssub.loc19 [template = constants.%.6] @@ -299,16 +320,9 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %.loc19_57.1: i32 = value_of_initializer %int.sdiv.loc19 [template = constants.%.6] // CHECK:STDOUT: %.loc19_57.2: i32 = converted %int.sdiv.loc19, %.loc19_57.1 [template = constants.%.6] // CHECK:STDOUT: %c: i32 = bind_name c, %.loc19_57.2 +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Div(%a: i32, %b: i32) -> i32 = "int.sdiv"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.ssub"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.snegate"; -// CHECK:STDOUT: // CHECK:STDOUT: --- fail_div_by_zero.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -325,6 +339,8 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Div = %Div.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -350,27 +366,32 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %int.make_type_32.loc10: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc10_8.1: type = value_of_initializer %int.make_type_32.loc10 [template = i32] // CHECK:STDOUT: %.loc10_8.2: type = converted %int.make_type_32.loc10, %.loc10_8.1 [template = i32] -// CHECK:STDOUT: %Div.ref.loc10: %Div.type = name_ref Div, %Div.decl [template = constants.%Div] -// CHECK:STDOUT: %.loc10_18: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc10_21: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %int.sdiv.loc10: init i32 = call %Div.ref.loc10(%.loc10_18, %.loc10_21) [template = ] -// CHECK:STDOUT: %.loc10_23.1: i32 = value_of_initializer %int.sdiv.loc10 [template = ] -// CHECK:STDOUT: %.loc10_23.2: i32 = converted %int.sdiv.loc10, %.loc10_23.1 [template = ] -// CHECK:STDOUT: %a.loc10: i32 = bind_name a, %.loc10_23.2 // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc15: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc15_8.1: type = value_of_initializer %int.make_type_32.loc15 [template = i32] // CHECK:STDOUT: %.loc15_8.2: type = converted %int.make_type_32.loc15, %.loc15_8.1 [template = i32] -// CHECK:STDOUT: %Div.ref.loc15: %Div.type = name_ref Div, %Div.decl [template = constants.%Div] -// CHECK:STDOUT: %.loc15_18: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %.loc15_21: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %int.sdiv.loc15: init i32 = call %Div.ref.loc15(%.loc15_18, %.loc15_21) [template = ] -// CHECK:STDOUT: %.loc15_23.1: i32 = value_of_initializer %int.sdiv.loc15 [template = ] -// CHECK:STDOUT: %.loc15_23.2: i32 = converted %int.sdiv.loc15, %.loc15_23.1 [template = ] -// CHECK:STDOUT: %b.loc15: i32 = bind_name b, %.loc15_23.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: // CHECK:STDOUT: fn @Div(%a: i32, %b: i32) -> i32 = "int.sdiv"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Div.ref.loc10: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %.loc10_18: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc10_21: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %int.sdiv.loc10: init i32 = call %Div.ref.loc10(%.loc10_18, %.loc10_21) [template = ] +// CHECK:STDOUT: %.loc10_23.1: i32 = value_of_initializer %int.sdiv.loc10 [template = ] +// CHECK:STDOUT: %.loc10_23.2: i32 = converted %int.sdiv.loc10, %.loc10_23.1 [template = ] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc10_23.2 +// CHECK:STDOUT: %Div.ref.loc15: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %.loc15_18: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %.loc15_21: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %int.sdiv.loc15: init i32 = call %Div.ref.loc15(%.loc15_18, %.loc15_21) [template = ] +// CHECK:STDOUT: %.loc15_23.1: i32 = value_of_initializer %int.sdiv.loc15 [template = ] +// CHECK:STDOUT: %.loc15_23.2: i32 = converted %int.sdiv.loc15, %.loc15_23.1 [template = ] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc15_23.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/smod.carbon b/toolchain/check/testdata/builtins/int/smod.carbon index e1a85305f9d3..bea0dd5f131f 100644 --- a/toolchain/check/testdata/builtins/int/smod.carbon +++ b/toolchain/check/testdata/builtins/int/smod.carbon @@ -82,6 +82,7 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Mod = %Mod.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -122,9 +123,6 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -161,6 +159,14 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: return %.loc8_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_overflow.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -187,6 +193,9 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: .Mod = %Mod.decl // CHECK:STDOUT: .Sub = %Sub.decl // CHECK:STDOUT: .Negate = %Negate.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: .c = @__global_init.%c // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -244,11 +253,31 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %int.make_type_32.loc9: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc9_8.1: type = value_of_initializer %int.make_type_32.loc9 [template = i32] // CHECK:STDOUT: %.loc9_8.2: type = converted %int.make_type_32.loc9, %.loc9_8.1 [template = i32] -// CHECK:STDOUT: %Mod.ref.loc9: %Mod.type = name_ref Mod, %Mod.decl [template = constants.%Mod] -// CHECK:STDOUT: %Negate.ref.loc9_18: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %import_ref.10: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc12: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc12_8.1: type = value_of_initializer %int.make_type_32.loc12 [template = i32] +// CHECK:STDOUT: %.loc12_8.2: type = converted %int.make_type_32.loc12, %.loc12_8.1 [template = i32] +// CHECK:STDOUT: %import_ref.11: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc20: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc20_8.1: type = value_of_initializer %int.make_type_32.loc20 [template = i32] +// CHECK:STDOUT: %.loc20_8.2: type = converted %int.make_type_32.loc20, %.loc20_8.1 [template = i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Mod(%a: i32, %b: i32) -> i32 = "int.smod"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.ssub"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.snegate"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Mod.ref.loc9: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod] +// CHECK:STDOUT: %Negate.ref.loc9_18: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc9_25: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.snegate.loc9_24: init i32 = call %Negate.ref.loc9_18(%.loc9_25) [template = constants.%.3] -// CHECK:STDOUT: %Negate.ref.loc9_39: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %Negate.ref.loc9_39: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc9_46: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %int.snegate.loc9_45: init i32 = call %Negate.ref.loc9_39(%.loc9_46) [template = constants.%.5] // CHECK:STDOUT: %.loc9_17.1: i32 = value_of_initializer %int.snegate.loc9_24 [template = constants.%.3] @@ -258,14 +287,10 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %int.smod.loc9: init i32 = call %Mod.ref.loc9(%.loc9_17.2, %.loc9_17.4) [template = constants.%.6] // CHECK:STDOUT: %.loc9_49.1: i32 = value_of_initializer %int.smod.loc9 [template = constants.%.6] // CHECK:STDOUT: %.loc9_49.2: i32 = converted %int.smod.loc9, %.loc9_49.1 [template = constants.%.6] -// CHECK:STDOUT: %a.loc9: i32 = bind_name a, %.loc9_49.2 -// CHECK:STDOUT: %import_ref.10: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc12: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc12_8.1: type = value_of_initializer %int.make_type_32.loc12 [template = i32] -// CHECK:STDOUT: %.loc12_8.2: type = converted %int.make_type_32.loc12, %.loc12_8.1 [template = i32] -// CHECK:STDOUT: %Mod.ref.loc12: %Mod.type = name_ref Mod, %Mod.decl [template = constants.%Mod] -// CHECK:STDOUT: %Sub.ref.loc12: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Negate.ref.loc12: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc9_49.2 +// CHECK:STDOUT: %Mod.ref.loc12: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod] +// CHECK:STDOUT: %Sub.ref.loc12: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Negate.ref.loc12: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc12_29: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.snegate.loc12: init i32 = call %Negate.ref.loc12(%.loc12_29) [template = constants.%.3] // CHECK:STDOUT: %.loc12_43: i32 = int_literal 1 [template = constants.%.4] @@ -278,21 +303,17 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %int.smod.loc12: init i32 = call %Mod.ref.loc12(%.loc12_17.2, %.loc12_47) [template = constants.%.6] // CHECK:STDOUT: %.loc12_49.1: i32 = value_of_initializer %int.smod.loc12 [template = constants.%.6] // CHECK:STDOUT: %.loc12_49.2: i32 = converted %int.smod.loc12, %.loc12_49.1 [template = constants.%.6] -// CHECK:STDOUT: %b.loc12: i32 = bind_name b, %.loc12_49.2 -// CHECK:STDOUT: %import_ref.11: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc20: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc20_8.1: type = value_of_initializer %int.make_type_32.loc20 [template = i32] -// CHECK:STDOUT: %.loc20_8.2: type = converted %int.make_type_32.loc20, %.loc20_8.1 [template = i32] -// CHECK:STDOUT: %Mod.ref.loc20: %Mod.type = name_ref Mod, %Mod.decl [template = constants.%Mod] -// CHECK:STDOUT: %Sub.ref.loc20: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Negate.ref.loc20_22: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc12_49.2 +// CHECK:STDOUT: %Mod.ref.loc20: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod] +// CHECK:STDOUT: %Sub.ref.loc20: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Negate.ref.loc20_22: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc20_29: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.snegate.loc20_28: init i32 = call %Negate.ref.loc20_22(%.loc20_29) [template = constants.%.3] // CHECK:STDOUT: %.loc20_43: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %.loc20_21.1: i32 = value_of_initializer %int.snegate.loc20_28 [template = constants.%.3] // CHECK:STDOUT: %.loc20_21.2: i32 = converted %int.snegate.loc20_28, %.loc20_21.1 [template = constants.%.3] // CHECK:STDOUT: %int.ssub.loc20: init i32 = call %Sub.ref.loc20(%.loc20_21.2, %.loc20_43) [template = constants.%.7] -// CHECK:STDOUT: %Negate.ref.loc20_47: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %Negate.ref.loc20_47: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc20_54: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %int.snegate.loc20_53: init i32 = call %Negate.ref.loc20_47(%.loc20_54) [template = constants.%.5] // CHECK:STDOUT: %.loc20_17.1: i32 = value_of_initializer %int.ssub.loc20 [template = constants.%.7] @@ -303,16 +324,9 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %.loc20_57.1: i32 = value_of_initializer %int.smod.loc20 [template = constants.%.6] // CHECK:STDOUT: %.loc20_57.2: i32 = converted %int.smod.loc20, %.loc20_57.1 [template = constants.%.6] // CHECK:STDOUT: %c: i32 = bind_name c, %.loc20_57.2 +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Mod(%a: i32, %b: i32) -> i32 = "int.smod"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.ssub"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.snegate"; -// CHECK:STDOUT: // CHECK:STDOUT: --- fail_div_by_zero.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -329,6 +343,8 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Mod = %Mod.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -354,27 +370,32 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %int.make_type_32.loc12: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc12_8.1: type = value_of_initializer %int.make_type_32.loc12 [template = i32] // CHECK:STDOUT: %.loc12_8.2: type = converted %int.make_type_32.loc12, %.loc12_8.1 [template = i32] -// CHECK:STDOUT: %Mod.ref.loc12: %Mod.type = name_ref Mod, %Mod.decl [template = constants.%Mod] -// CHECK:STDOUT: %.loc12_18: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc12_21: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %int.smod.loc12: init i32 = call %Mod.ref.loc12(%.loc12_18, %.loc12_21) [template = ] -// CHECK:STDOUT: %.loc12_23.1: i32 = value_of_initializer %int.smod.loc12 [template = ] -// CHECK:STDOUT: %.loc12_23.2: i32 = converted %int.smod.loc12, %.loc12_23.1 [template = ] -// CHECK:STDOUT: %a.loc12: i32 = bind_name a, %.loc12_23.2 // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc17: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc17_8.1: type = value_of_initializer %int.make_type_32.loc17 [template = i32] // CHECK:STDOUT: %.loc17_8.2: type = converted %int.make_type_32.loc17, %.loc17_8.1 [template = i32] -// CHECK:STDOUT: %Mod.ref.loc17: %Mod.type = name_ref Mod, %Mod.decl [template = constants.%Mod] -// CHECK:STDOUT: %.loc17_18: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %.loc17_21: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %int.smod.loc17: init i32 = call %Mod.ref.loc17(%.loc17_18, %.loc17_21) [template = ] -// CHECK:STDOUT: %.loc17_23.1: i32 = value_of_initializer %int.smod.loc17 [template = ] -// CHECK:STDOUT: %.loc17_23.2: i32 = converted %int.smod.loc17, %.loc17_23.1 [template = ] -// CHECK:STDOUT: %b.loc17: i32 = bind_name b, %.loc17_23.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: // CHECK:STDOUT: fn @Mod(%a: i32, %b: i32) -> i32 = "int.smod"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Mod.ref.loc12: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod] +// CHECK:STDOUT: %.loc12_18: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc12_21: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %int.smod.loc12: init i32 = call %Mod.ref.loc12(%.loc12_18, %.loc12_21) [template = ] +// CHECK:STDOUT: %.loc12_23.1: i32 = value_of_initializer %int.smod.loc12 [template = ] +// CHECK:STDOUT: %.loc12_23.2: i32 = converted %int.smod.loc12, %.loc12_23.1 [template = ] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc12_23.2 +// CHECK:STDOUT: %Mod.ref.loc17: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod] +// CHECK:STDOUT: %.loc17_18: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %.loc17_21: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %int.smod.loc17: init i32 = call %Mod.ref.loc17(%.loc17_18, %.loc17_21) [template = ] +// CHECK:STDOUT: %.loc17_23.1: i32 = value_of_initializer %int.smod.loc17 [template = ] +// CHECK:STDOUT: %.loc17_23.2: i32 = converted %int.smod.loc17, %.loc17_23.1 [template = ] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc17_23.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/smul.carbon b/toolchain/check/testdata/builtins/int/smul.carbon index 47e61f628d4c..2df5bcb90d71 100644 --- a/toolchain/check/testdata/builtins/int/smul.carbon +++ b/toolchain/check/testdata/builtins/int/smul.carbon @@ -53,6 +53,7 @@ let b: i32 = Mul(0x8000, 0x10000); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Mul = %Mul.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -93,9 +94,6 @@ let b: i32 = Mul(0x8000, 0x10000); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -132,6 +130,14 @@ let b: i32 = Mul(0x8000, 0x10000); // CHECK:STDOUT: return %.loc8_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_overflow.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -151,6 +157,8 @@ let b: i32 = Mul(0x8000, 0x10000); // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Mul = %Mul.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -176,27 +184,32 @@ let b: i32 = Mul(0x8000, 0x10000); // CHECK:STDOUT: %int.make_type_32.loc6: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc6_8.1: type = value_of_initializer %int.make_type_32.loc6 [template = i32] // CHECK:STDOUT: %.loc6_8.2: type = converted %int.make_type_32.loc6, %.loc6_8.1 [template = i32] -// CHECK:STDOUT: %Mul.ref.loc6: %Mul.type = name_ref Mul, %Mul.decl [template = constants.%Mul] -// CHECK:STDOUT: %.loc6_18: i32 = int_literal 32767 [template = constants.%.2] -// CHECK:STDOUT: %.loc6_26: i32 = int_literal 65536 [template = constants.%.3] -// CHECK:STDOUT: %int.smul.loc6: init i32 = call %Mul.ref.loc6(%.loc6_18, %.loc6_26) [template = constants.%.4] -// CHECK:STDOUT: %.loc6_34.1: i32 = value_of_initializer %int.smul.loc6 [template = constants.%.4] -// CHECK:STDOUT: %.loc6_34.2: i32 = converted %int.smul.loc6, %.loc6_34.1 [template = constants.%.4] -// CHECK:STDOUT: %a.loc6: i32 = bind_name a, %.loc6_34.2 // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc10: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc10_8.1: type = value_of_initializer %int.make_type_32.loc10 [template = i32] // CHECK:STDOUT: %.loc10_8.2: type = converted %int.make_type_32.loc10, %.loc10_8.1 [template = i32] -// CHECK:STDOUT: %Mul.ref.loc10: %Mul.type = name_ref Mul, %Mul.decl [template = constants.%Mul] -// CHECK:STDOUT: %.loc10_18: i32 = int_literal 32768 [template = constants.%.5] -// CHECK:STDOUT: %.loc10_26: i32 = int_literal 65536 [template = constants.%.3] -// CHECK:STDOUT: %int.smul.loc10: init i32 = call %Mul.ref.loc10(%.loc10_18, %.loc10_26) [template = constants.%.6] -// CHECK:STDOUT: %.loc10_34.1: i32 = value_of_initializer %int.smul.loc10 [template = constants.%.6] -// CHECK:STDOUT: %.loc10_34.2: i32 = converted %int.smul.loc10, %.loc10_34.1 [template = constants.%.6] -// CHECK:STDOUT: %b.loc10: i32 = bind_name b, %.loc10_34.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: // CHECK:STDOUT: fn @Mul(%a: i32, %b: i32) -> i32 = "int.smul"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Mul.ref.loc6: %Mul.type = name_ref Mul, file.%Mul.decl [template = constants.%Mul] +// CHECK:STDOUT: %.loc6_18: i32 = int_literal 32767 [template = constants.%.2] +// CHECK:STDOUT: %.loc6_26: i32 = int_literal 65536 [template = constants.%.3] +// CHECK:STDOUT: %int.smul.loc6: init i32 = call %Mul.ref.loc6(%.loc6_18, %.loc6_26) [template = constants.%.4] +// CHECK:STDOUT: %.loc6_34.1: i32 = value_of_initializer %int.smul.loc6 [template = constants.%.4] +// CHECK:STDOUT: %.loc6_34.2: i32 = converted %int.smul.loc6, %.loc6_34.1 [template = constants.%.4] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc6_34.2 +// CHECK:STDOUT: %Mul.ref.loc10: %Mul.type = name_ref Mul, file.%Mul.decl [template = constants.%Mul] +// CHECK:STDOUT: %.loc10_18: i32 = int_literal 32768 [template = constants.%.5] +// CHECK:STDOUT: %.loc10_26: i32 = int_literal 65536 [template = constants.%.3] +// CHECK:STDOUT: %int.smul.loc10: init i32 = call %Mul.ref.loc10(%.loc10_18, %.loc10_26) [template = constants.%.6] +// CHECK:STDOUT: %.loc10_34.1: i32 = value_of_initializer %int.smul.loc10 [template = constants.%.6] +// CHECK:STDOUT: %.loc10_34.2: i32 = converted %int.smul.loc10, %.loc10_34.1 [template = constants.%.6] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc10_34.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/snegate.carbon b/toolchain/check/testdata/builtins/int/snegate.carbon index 11e00ff3af7d..83d4d6a65023 100644 --- a/toolchain/check/testdata/builtins/int/snegate.carbon +++ b/toolchain/check/testdata/builtins/int/snegate.carbon @@ -139,6 +139,8 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Negate = %Negate.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p +// CHECK:STDOUT: .n = @__global_init.%n // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -176,19 +178,10 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_21: type = array_type %.loc5_18, i32 [template = constants.%.4] // CHECK:STDOUT: %.loc5_22: type = ptr_type %.4 [template = constants.%.5] -// CHECK:STDOUT: %arr.ref: ref %.4 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_26: %.5 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.5 = bind_name arr_p, %.loc5_26 // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc7: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc7_8.1: type = value_of_initializer %int.make_type_32.loc7 [template = i32] // CHECK:STDOUT: %.loc7_8.2: type = converted %int.make_type_32.loc7, %.loc7_8.1 [template = i32] -// CHECK:STDOUT: %Negate.ref.loc7: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] -// CHECK:STDOUT: %.loc7_21: i32 = int_literal 1 [template = constants.%.6] -// CHECK:STDOUT: %int.snegate.loc7: init i32 = call %Negate.ref.loc7(%.loc7_21) [template = constants.%.7] -// CHECK:STDOUT: %.loc7_23.1: i32 = value_of_initializer %int.snegate.loc7 [template = constants.%.7] -// CHECK:STDOUT: %.loc7_23.2: i32 = converted %int.snegate.loc7, %.loc7_23.1 [template = constants.%.7] -// CHECK:STDOUT: %n: i32 = bind_name n, %.loc7_23.2 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -224,6 +217,20 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: return %.loc10_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.4 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.5 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.5 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %.loc7_21: i32 = int_literal 1 [template = constants.%.6] +// CHECK:STDOUT: %int.snegate: init i32 = call %Negate.ref(%.loc7_21) [template = constants.%.7] +// CHECK:STDOUT: %.loc7_23.1: i32 = value_of_initializer %int.snegate [template = constants.%.7] +// CHECK:STDOUT: %.loc7_23.2: i32 = converted %int.snegate, %.loc7_23.1 [template = constants.%.7] +// CHECK:STDOUT: %n: i32 = bind_name n, %.loc7_23.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_bad_decl.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -475,6 +482,8 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Negate = %Negate.decl // CHECK:STDOUT: .Sub = %Sub.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -513,8 +522,22 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: %int.make_type_32.loc8: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc8_8.1: type = value_of_initializer %int.make_type_32.loc8 [template = i32] // CHECK:STDOUT: %.loc8_8.2: type = converted %int.make_type_32.loc8, %.loc8_8.1 [template = i32] -// CHECK:STDOUT: %Negate.ref.loc8_14: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] -// CHECK:STDOUT: %Negate.ref.loc8_21: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc14: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc14_8.1: type = value_of_initializer %int.make_type_32.loc14 [template = i32] +// CHECK:STDOUT: %.loc14_8.2: type = converted %int.make_type_32.loc14, %.loc14_8.1 [template = i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.snegate"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.ssub"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Negate.ref.loc8_14: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %Negate.ref.loc8_21: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc8_28: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.snegate.loc8_27: init i32 = call %Negate.ref.loc8_21(%.loc8_28) [template = constants.%.3] // CHECK:STDOUT: %.loc8_20.1: i32 = value_of_initializer %int.snegate.loc8_27 [template = constants.%.3] @@ -522,14 +545,10 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: %int.snegate.loc8_20: init i32 = call %Negate.ref.loc8_14(%.loc8_20.2) [template = constants.%.2] // CHECK:STDOUT: %.loc8_40.1: i32 = value_of_initializer %int.snegate.loc8_20 [template = constants.%.2] // CHECK:STDOUT: %.loc8_40.2: i32 = converted %int.snegate.loc8_20, %.loc8_40.1 [template = constants.%.2] -// CHECK:STDOUT: %a.loc8: i32 = bind_name a, %.loc8_40.2 -// CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc14: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc14_8.1: type = value_of_initializer %int.make_type_32.loc14 [template = i32] -// CHECK:STDOUT: %.loc14_8.2: type = converted %int.make_type_32.loc14, %.loc14_8.1 [template = i32] -// CHECK:STDOUT: %Negate.ref.loc14_14: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] -// CHECK:STDOUT: %Sub.ref: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Negate.ref.loc14_25: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc8_40.2 +// CHECK:STDOUT: %Negate.ref.loc14_14: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %Sub.ref: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Negate.ref.loc14_25: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc14_32: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.snegate.loc14_31: init i32 = call %Negate.ref.loc14_25(%.loc14_32) [template = constants.%.3] // CHECK:STDOUT: %.loc14_45: i32 = int_literal 1 [template = constants.%.4] @@ -541,12 +560,7 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: %int.snegate.loc14_20: init i32 = call %Negate.ref.loc14_14(%.loc14_20.2) [template = constants.%.5] // CHECK:STDOUT: %.loc14_48.1: i32 = value_of_initializer %int.snegate.loc14_20 [template = constants.%.5] // CHECK:STDOUT: %.loc14_48.2: i32 = converted %int.snegate.loc14_20, %.loc14_48.1 [template = constants.%.5] -// CHECK:STDOUT: %b.loc14: i32 = bind_name b, %.loc14_48.2 +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc14_48.2 +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.snegate"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.ssub"; -// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/ssub.carbon b/toolchain/check/testdata/builtins/int/ssub.carbon index 8c8b0a17dc4d..387f80211571 100644 --- a/toolchain/check/testdata/builtins/int/ssub.carbon +++ b/toolchain/check/testdata/builtins/int/ssub.carbon @@ -54,6 +54,7 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Sub = %Sub.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -94,9 +95,6 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -133,6 +131,14 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: return %.loc8_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_overflow.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -153,6 +159,9 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Sub = %Sub.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: .c = @__global_init.%c // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -178,19 +187,31 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: %int.make_type_32.loc6: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc6_8.1: type = value_of_initializer %int.make_type_32.loc6 [template = i32] // CHECK:STDOUT: %.loc6_8.2: type = converted %int.make_type_32.loc6, %.loc6_8.1 [template = i32] -// CHECK:STDOUT: %Sub.ref.loc6: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc7: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc7_8.1: type = value_of_initializer %int.make_type_32.loc7 [template = i32] +// CHECK:STDOUT: %.loc7_8.2: type = converted %int.make_type_32.loc7, %.loc7_8.1 [template = i32] +// CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc11: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc11_8.1: type = value_of_initializer %int.make_type_32.loc11 [template = i32] +// CHECK:STDOUT: %.loc11_8.2: type = converted %int.make_type_32.loc11, %.loc11_8.1 [template = i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.ssub"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Sub.ref.loc6: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] // CHECK:STDOUT: %.loc6_18: i32 = int_literal 0 [template = constants.%.2] // CHECK:STDOUT: %.loc6_21: i32 = int_literal 2147483647 [template = constants.%.3] // CHECK:STDOUT: %int.ssub.loc6: init i32 = call %Sub.ref.loc6(%.loc6_18, %.loc6_21) [template = constants.%.4] // CHECK:STDOUT: %.loc6_32.1: i32 = value_of_initializer %int.ssub.loc6 [template = constants.%.4] // CHECK:STDOUT: %.loc6_32.2: i32 = converted %int.ssub.loc6, %.loc6_32.1 [template = constants.%.4] -// CHECK:STDOUT: %a.loc6: i32 = bind_name a, %.loc6_32.2 -// CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc7: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc7_8.1: type = value_of_initializer %int.make_type_32.loc7 [template = i32] -// CHECK:STDOUT: %.loc7_8.2: type = converted %int.make_type_32.loc7, %.loc7_8.1 [template = i32] -// CHECK:STDOUT: %Sub.ref.loc7_14: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Sub.ref.loc7_18: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc6_32.2 +// CHECK:STDOUT: %Sub.ref.loc7_14: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Sub.ref.loc7_18: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] // CHECK:STDOUT: %.loc7_22: i32 = int_literal 0 [template = constants.%.2] // CHECK:STDOUT: %.loc7_25: i32 = int_literal 2147483647 [template = constants.%.3] // CHECK:STDOUT: %int.ssub.loc7_21: init i32 = call %Sub.ref.loc7_18(%.loc7_22, %.loc7_25) [template = constants.%.4] @@ -200,13 +221,9 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: %int.ssub.loc7_17: init i32 = call %Sub.ref.loc7_14(%.loc7_17.2, %.loc7_38) [template = constants.%.6] // CHECK:STDOUT: %.loc7_40.1: i32 = value_of_initializer %int.ssub.loc7_17 [template = constants.%.6] // CHECK:STDOUT: %.loc7_40.2: i32 = converted %int.ssub.loc7_17, %.loc7_40.1 [template = constants.%.6] -// CHECK:STDOUT: %b.loc7: i32 = bind_name b, %.loc7_40.2 -// CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc11: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc11_8.1: type = value_of_initializer %int.make_type_32.loc11 [template = i32] -// CHECK:STDOUT: %.loc11_8.2: type = converted %int.make_type_32.loc11, %.loc11_8.1 [template = i32] -// CHECK:STDOUT: %Sub.ref.loc11_14: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Sub.ref.loc11_18: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc7_40.2 +// CHECK:STDOUT: %Sub.ref.loc11_14: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Sub.ref.loc11_18: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] // CHECK:STDOUT: %.loc11_22: i32 = int_literal 0 [template = constants.%.2] // CHECK:STDOUT: %.loc11_25: i32 = int_literal 2147483647 [template = constants.%.3] // CHECK:STDOUT: %int.ssub.loc11_21: init i32 = call %Sub.ref.loc11_18(%.loc11_22, %.loc11_25) [template = constants.%.4] @@ -217,9 +234,6 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: %.loc11_40.1: i32 = value_of_initializer %int.ssub.loc11_17 [template = constants.%.3] // CHECK:STDOUT: %.loc11_40.2: i32 = converted %int.ssub.loc11_17, %.loc11_40.1 [template = constants.%.3] // CHECK:STDOUT: %c: i32 = bind_name c, %.loc11_40.2 +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.ssub"; -// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/uadd.carbon b/toolchain/check/testdata/builtins/int/uadd.carbon index 3165007cd096..17e560f621a7 100644 --- a/toolchain/check/testdata/builtins/int/uadd.carbon +++ b/toolchain/check/testdata/builtins/int/uadd.carbon @@ -108,6 +108,7 @@ let b: i32 = Add(0x7FFFFFFF, 1); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Add = %Add.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -148,9 +149,6 @@ let b: i32 = Add(0x7FFFFFFF, 1); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -187,6 +185,14 @@ let b: i32 = Add(0x7FFFFFFF, 1); // CHECK:STDOUT: return %.loc8_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_bad_decl.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -464,6 +470,8 @@ let b: i32 = Add(0x7FFFFFFF, 1); // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Add = %Add.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -489,27 +497,32 @@ let b: i32 = Add(0x7FFFFFFF, 1); // CHECK:STDOUT: %int.make_type_32.loc7: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc7_8.1: type = value_of_initializer %int.make_type_32.loc7 [template = i32] // CHECK:STDOUT: %.loc7_8.2: type = converted %int.make_type_32.loc7, %.loc7_8.1 [template = i32] -// CHECK:STDOUT: %Add.ref.loc7: %Add.type = name_ref Add, %Add.decl [template = constants.%Add] -// CHECK:STDOUT: %.loc7_18: i32 = int_literal 2147483647 [template = constants.%.2] -// CHECK:STDOUT: %.loc7_30: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %int.uadd.loc7: init i32 = call %Add.ref.loc7(%.loc7_18, %.loc7_30) [template = constants.%.2] -// CHECK:STDOUT: %.loc7_32.1: i32 = value_of_initializer %int.uadd.loc7 [template = constants.%.2] -// CHECK:STDOUT: %.loc7_32.2: i32 = converted %int.uadd.loc7, %.loc7_32.1 [template = constants.%.2] -// CHECK:STDOUT: %a.loc7: i32 = bind_name a, %.loc7_32.2 // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc8: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc8_8.1: type = value_of_initializer %int.make_type_32.loc8 [template = i32] // CHECK:STDOUT: %.loc8_8.2: type = converted %int.make_type_32.loc8, %.loc8_8.1 [template = i32] -// CHECK:STDOUT: %Add.ref.loc8: %Add.type = name_ref Add, %Add.decl [template = constants.%Add] -// CHECK:STDOUT: %.loc8_18: i32 = int_literal 2147483647 [template = constants.%.2] -// CHECK:STDOUT: %.loc8_30: i32 = int_literal 1 [template = constants.%.4] -// CHECK:STDOUT: %int.uadd.loc8: init i32 = call %Add.ref.loc8(%.loc8_18, %.loc8_30) [template = constants.%.5] -// CHECK:STDOUT: %.loc8_32.1: i32 = value_of_initializer %int.uadd.loc8 [template = constants.%.5] -// CHECK:STDOUT: %.loc8_32.2: i32 = converted %int.uadd.loc8, %.loc8_32.1 [template = constants.%.5] -// CHECK:STDOUT: %b.loc8: i32 = bind_name b, %.loc8_32.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: // CHECK:STDOUT: fn @Add(%a: i32, %b: i32) -> i32 = "int.uadd"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Add.ref.loc7: %Add.type = name_ref Add, file.%Add.decl [template = constants.%Add] +// CHECK:STDOUT: %.loc7_18: i32 = int_literal 2147483647 [template = constants.%.2] +// CHECK:STDOUT: %.loc7_30: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %int.uadd.loc7: init i32 = call %Add.ref.loc7(%.loc7_18, %.loc7_30) [template = constants.%.2] +// CHECK:STDOUT: %.loc7_32.1: i32 = value_of_initializer %int.uadd.loc7 [template = constants.%.2] +// CHECK:STDOUT: %.loc7_32.2: i32 = converted %int.uadd.loc7, %.loc7_32.1 [template = constants.%.2] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc7_32.2 +// CHECK:STDOUT: %Add.ref.loc8: %Add.type = name_ref Add, file.%Add.decl [template = constants.%Add] +// CHECK:STDOUT: %.loc8_18: i32 = int_literal 2147483647 [template = constants.%.2] +// CHECK:STDOUT: %.loc8_30: i32 = int_literal 1 [template = constants.%.4] +// CHECK:STDOUT: %int.uadd.loc8: init i32 = call %Add.ref.loc8(%.loc8_18, %.loc8_30) [template = constants.%.5] +// CHECK:STDOUT: %.loc8_32.1: i32 = value_of_initializer %int.uadd.loc8 [template = constants.%.5] +// CHECK:STDOUT: %.loc8_32.2: i32 = converted %int.uadd.loc8, %.loc8_32.1 [template = constants.%.5] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc8_32.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/udiv.carbon b/toolchain/check/testdata/builtins/int/udiv.carbon index 8225ac40e124..392e70e02089 100644 --- a/toolchain/check/testdata/builtins/int/udiv.carbon +++ b/toolchain/check/testdata/builtins/int/udiv.carbon @@ -75,6 +75,7 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Div = %Div.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -115,9 +116,6 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -154,6 +152,14 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: return %.loc8_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- overflow.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -180,6 +186,9 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: .Div = %Div.decl // CHECK:STDOUT: .Sub = %Sub.decl // CHECK:STDOUT: .Negate = %Negate.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: .c = @__global_init.%c // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -237,11 +246,31 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %int.make_type_32.loc9: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc9_8.1: type = value_of_initializer %int.make_type_32.loc9 [template = i32] // CHECK:STDOUT: %.loc9_8.2: type = converted %int.make_type_32.loc9, %.loc9_8.1 [template = i32] -// CHECK:STDOUT: %Div.ref.loc9: %Div.type = name_ref Div, %Div.decl [template = constants.%Div] -// CHECK:STDOUT: %Negate.ref.loc9_18: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %import_ref.10: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc12: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc12_8.1: type = value_of_initializer %int.make_type_32.loc12 [template = i32] +// CHECK:STDOUT: %.loc12_8.2: type = converted %int.make_type_32.loc12, %.loc12_8.1 [template = i32] +// CHECK:STDOUT: %import_ref.11: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc15: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc15_8.1: type = value_of_initializer %int.make_type_32.loc15 [template = i32] +// CHECK:STDOUT: %.loc15_8.2: type = converted %int.make_type_32.loc15, %.loc15_8.1 [template = i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Div(%a: i32, %b: i32) -> i32 = "int.udiv"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.usub"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.unegate"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Div.ref.loc9: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %Negate.ref.loc9_18: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc9_25: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.unegate.loc9_24: init i32 = call %Negate.ref.loc9_18(%.loc9_25) [template = constants.%.3] -// CHECK:STDOUT: %Negate.ref.loc9_39: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %Negate.ref.loc9_39: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc9_46: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %int.unegate.loc9_45: init i32 = call %Negate.ref.loc9_39(%.loc9_46) [template = constants.%.5] // CHECK:STDOUT: %.loc9_17.1: i32 = value_of_initializer %int.unegate.loc9_24 [template = constants.%.3] @@ -251,14 +280,10 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %int.udiv.loc9: init i32 = call %Div.ref.loc9(%.loc9_17.2, %.loc9_17.4) [template = constants.%.6] // CHECK:STDOUT: %.loc9_49.1: i32 = value_of_initializer %int.udiv.loc9 [template = constants.%.6] // CHECK:STDOUT: %.loc9_49.2: i32 = converted %int.udiv.loc9, %.loc9_49.1 [template = constants.%.6] -// CHECK:STDOUT: %a.loc9: i32 = bind_name a, %.loc9_49.2 -// CHECK:STDOUT: %import_ref.10: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc12: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc12_8.1: type = value_of_initializer %int.make_type_32.loc12 [template = i32] -// CHECK:STDOUT: %.loc12_8.2: type = converted %int.make_type_32.loc12, %.loc12_8.1 [template = i32] -// CHECK:STDOUT: %Div.ref.loc12: %Div.type = name_ref Div, %Div.decl [template = constants.%Div] -// CHECK:STDOUT: %Sub.ref.loc12: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Negate.ref.loc12: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc9_49.2 +// CHECK:STDOUT: %Div.ref.loc12: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %Sub.ref.loc12: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Negate.ref.loc12: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc12_29: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.unegate.loc12: init i32 = call %Negate.ref.loc12(%.loc12_29) [template = constants.%.3] // CHECK:STDOUT: %.loc12_43: i32 = int_literal 1 [template = constants.%.4] @@ -271,21 +296,17 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %int.udiv.loc12: init i32 = call %Div.ref.loc12(%.loc12_17.2, %.loc12_47) [template = constants.%.7] // CHECK:STDOUT: %.loc12_49.1: i32 = value_of_initializer %int.udiv.loc12 [template = constants.%.7] // CHECK:STDOUT: %.loc12_49.2: i32 = converted %int.udiv.loc12, %.loc12_49.1 [template = constants.%.7] -// CHECK:STDOUT: %b.loc12: i32 = bind_name b, %.loc12_49.2 -// CHECK:STDOUT: %import_ref.11: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc15: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc15_8.1: type = value_of_initializer %int.make_type_32.loc15 [template = i32] -// CHECK:STDOUT: %.loc15_8.2: type = converted %int.make_type_32.loc15, %.loc15_8.1 [template = i32] -// CHECK:STDOUT: %Div.ref.loc15: %Div.type = name_ref Div, %Div.decl [template = constants.%Div] -// CHECK:STDOUT: %Sub.ref.loc15: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Negate.ref.loc15_22: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc12_49.2 +// CHECK:STDOUT: %Div.ref.loc15: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %Sub.ref.loc15: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Negate.ref.loc15_22: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc15_29: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.unegate.loc15_28: init i32 = call %Negate.ref.loc15_22(%.loc15_29) [template = constants.%.3] // CHECK:STDOUT: %.loc15_43: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %.loc15_21.1: i32 = value_of_initializer %int.unegate.loc15_28 [template = constants.%.3] // CHECK:STDOUT: %.loc15_21.2: i32 = converted %int.unegate.loc15_28, %.loc15_21.1 [template = constants.%.3] // CHECK:STDOUT: %int.usub.loc15: init i32 = call %Sub.ref.loc15(%.loc15_21.2, %.loc15_43) [template = constants.%.7] -// CHECK:STDOUT: %Negate.ref.loc15_47: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %Negate.ref.loc15_47: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc15_54: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %int.unegate.loc15_53: init i32 = call %Negate.ref.loc15_47(%.loc15_54) [template = constants.%.5] // CHECK:STDOUT: %.loc15_17.1: i32 = value_of_initializer %int.usub.loc15 [template = constants.%.7] @@ -296,16 +317,9 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %.loc15_57.1: i32 = value_of_initializer %int.udiv.loc15 [template = constants.%.6] // CHECK:STDOUT: %.loc15_57.2: i32 = converted %int.udiv.loc15, %.loc15_57.1 [template = constants.%.6] // CHECK:STDOUT: %c: i32 = bind_name c, %.loc15_57.2 +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Div(%a: i32, %b: i32) -> i32 = "int.udiv"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.usub"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.unegate"; -// CHECK:STDOUT: // CHECK:STDOUT: --- fail_div_by_zero.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -322,6 +336,8 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Div = %Div.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -347,27 +363,32 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %int.make_type_32.loc10: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc10_8.1: type = value_of_initializer %int.make_type_32.loc10 [template = i32] // CHECK:STDOUT: %.loc10_8.2: type = converted %int.make_type_32.loc10, %.loc10_8.1 [template = i32] -// CHECK:STDOUT: %Div.ref.loc10: %Div.type = name_ref Div, %Div.decl [template = constants.%Div] -// CHECK:STDOUT: %.loc10_18: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc10_21: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %int.udiv.loc10: init i32 = call %Div.ref.loc10(%.loc10_18, %.loc10_21) [template = ] -// CHECK:STDOUT: %.loc10_23.1: i32 = value_of_initializer %int.udiv.loc10 [template = ] -// CHECK:STDOUT: %.loc10_23.2: i32 = converted %int.udiv.loc10, %.loc10_23.1 [template = ] -// CHECK:STDOUT: %a.loc10: i32 = bind_name a, %.loc10_23.2 // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc15: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc15_8.1: type = value_of_initializer %int.make_type_32.loc15 [template = i32] // CHECK:STDOUT: %.loc15_8.2: type = converted %int.make_type_32.loc15, %.loc15_8.1 [template = i32] -// CHECK:STDOUT: %Div.ref.loc15: %Div.type = name_ref Div, %Div.decl [template = constants.%Div] -// CHECK:STDOUT: %.loc15_18: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %.loc15_21: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %int.udiv.loc15: init i32 = call %Div.ref.loc15(%.loc15_18, %.loc15_21) [template = ] -// CHECK:STDOUT: %.loc15_23.1: i32 = value_of_initializer %int.udiv.loc15 [template = ] -// CHECK:STDOUT: %.loc15_23.2: i32 = converted %int.udiv.loc15, %.loc15_23.1 [template = ] -// CHECK:STDOUT: %b.loc15: i32 = bind_name b, %.loc15_23.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: // CHECK:STDOUT: fn @Div(%a: i32, %b: i32) -> i32 = "int.udiv"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Div.ref.loc10: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %.loc10_18: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc10_21: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %int.udiv.loc10: init i32 = call %Div.ref.loc10(%.loc10_18, %.loc10_21) [template = ] +// CHECK:STDOUT: %.loc10_23.1: i32 = value_of_initializer %int.udiv.loc10 [template = ] +// CHECK:STDOUT: %.loc10_23.2: i32 = converted %int.udiv.loc10, %.loc10_23.1 [template = ] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc10_23.2 +// CHECK:STDOUT: %Div.ref.loc15: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] +// CHECK:STDOUT: %.loc15_18: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %.loc15_21: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %int.udiv.loc15: init i32 = call %Div.ref.loc15(%.loc15_18, %.loc15_21) [template = ] +// CHECK:STDOUT: %.loc15_23.1: i32 = value_of_initializer %int.udiv.loc15 [template = ] +// CHECK:STDOUT: %.loc15_23.2: i32 = converted %int.udiv.loc15, %.loc15_23.1 [template = ] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc15_23.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/umod.carbon b/toolchain/check/testdata/builtins/int/umod.carbon index 005f30311073..d77e4a4ff657 100644 --- a/toolchain/check/testdata/builtins/int/umod.carbon +++ b/toolchain/check/testdata/builtins/int/umod.carbon @@ -77,6 +77,7 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Mod = %Mod.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -117,9 +118,6 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -156,6 +154,14 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: return %.loc8_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- overflow.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -182,6 +188,9 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: .Mod = %Mod.decl // CHECK:STDOUT: .Sub = %Sub.decl // CHECK:STDOUT: .Negate = %Negate.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: .c = @__global_init.%c // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -239,11 +248,31 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %int.make_type_32.loc9: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc9_8.1: type = value_of_initializer %int.make_type_32.loc9 [template = i32] // CHECK:STDOUT: %.loc9_8.2: type = converted %int.make_type_32.loc9, %.loc9_8.1 [template = i32] -// CHECK:STDOUT: %Mod.ref.loc9: %Mod.type = name_ref Mod, %Mod.decl [template = constants.%Mod] -// CHECK:STDOUT: %Negate.ref.loc9_18: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %import_ref.10: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc12: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc12_8.1: type = value_of_initializer %int.make_type_32.loc12 [template = i32] +// CHECK:STDOUT: %.loc12_8.2: type = converted %int.make_type_32.loc12, %.loc12_8.1 [template = i32] +// CHECK:STDOUT: %import_ref.11: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc15: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc15_8.1: type = value_of_initializer %int.make_type_32.loc15 [template = i32] +// CHECK:STDOUT: %.loc15_8.2: type = converted %int.make_type_32.loc15, %.loc15_8.1 [template = i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Mod(%a: i32, %b: i32) -> i32 = "int.umod"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.usub"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.unegate"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Mod.ref.loc9: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod] +// CHECK:STDOUT: %Negate.ref.loc9_18: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc9_25: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.unegate.loc9_24: init i32 = call %Negate.ref.loc9_18(%.loc9_25) [template = constants.%.3] -// CHECK:STDOUT: %Negate.ref.loc9_39: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %Negate.ref.loc9_39: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc9_46: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %int.unegate.loc9_45: init i32 = call %Negate.ref.loc9_39(%.loc9_46) [template = constants.%.5] // CHECK:STDOUT: %.loc9_17.1: i32 = value_of_initializer %int.unegate.loc9_24 [template = constants.%.3] @@ -253,14 +282,10 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %int.umod.loc9: init i32 = call %Mod.ref.loc9(%.loc9_17.2, %.loc9_17.4) [template = constants.%.3] // CHECK:STDOUT: %.loc9_49.1: i32 = value_of_initializer %int.umod.loc9 [template = constants.%.3] // CHECK:STDOUT: %.loc9_49.2: i32 = converted %int.umod.loc9, %.loc9_49.1 [template = constants.%.3] -// CHECK:STDOUT: %a.loc9: i32 = bind_name a, %.loc9_49.2 -// CHECK:STDOUT: %import_ref.10: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc12: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc12_8.1: type = value_of_initializer %int.make_type_32.loc12 [template = i32] -// CHECK:STDOUT: %.loc12_8.2: type = converted %int.make_type_32.loc12, %.loc12_8.1 [template = i32] -// CHECK:STDOUT: %Mod.ref.loc12: %Mod.type = name_ref Mod, %Mod.decl [template = constants.%Mod] -// CHECK:STDOUT: %Sub.ref.loc12: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Negate.ref.loc12: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc9_49.2 +// CHECK:STDOUT: %Mod.ref.loc12: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod] +// CHECK:STDOUT: %Sub.ref.loc12: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Negate.ref.loc12: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc12_29: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.unegate.loc12: init i32 = call %Negate.ref.loc12(%.loc12_29) [template = constants.%.3] // CHECK:STDOUT: %.loc12_43: i32 = int_literal 1 [template = constants.%.4] @@ -273,21 +298,17 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %int.umod.loc12: init i32 = call %Mod.ref.loc12(%.loc12_17.2, %.loc12_47) [template = constants.%.7] // CHECK:STDOUT: %.loc12_49.1: i32 = value_of_initializer %int.umod.loc12 [template = constants.%.7] // CHECK:STDOUT: %.loc12_49.2: i32 = converted %int.umod.loc12, %.loc12_49.1 [template = constants.%.7] -// CHECK:STDOUT: %b.loc12: i32 = bind_name b, %.loc12_49.2 -// CHECK:STDOUT: %import_ref.11: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc15: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc15_8.1: type = value_of_initializer %int.make_type_32.loc15 [template = i32] -// CHECK:STDOUT: %.loc15_8.2: type = converted %int.make_type_32.loc15, %.loc15_8.1 [template = i32] -// CHECK:STDOUT: %Mod.ref.loc15: %Mod.type = name_ref Mod, %Mod.decl [template = constants.%Mod] -// CHECK:STDOUT: %Sub.ref.loc15: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Negate.ref.loc15_22: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc12_49.2 +// CHECK:STDOUT: %Mod.ref.loc15: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod] +// CHECK:STDOUT: %Sub.ref.loc15: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Negate.ref.loc15_22: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc15_29: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.unegate.loc15_28: init i32 = call %Negate.ref.loc15_22(%.loc15_29) [template = constants.%.3] // CHECK:STDOUT: %.loc15_43: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %.loc15_21.1: i32 = value_of_initializer %int.unegate.loc15_28 [template = constants.%.3] // CHECK:STDOUT: %.loc15_21.2: i32 = converted %int.unegate.loc15_28, %.loc15_21.1 [template = constants.%.3] // CHECK:STDOUT: %int.usub.loc15: init i32 = call %Sub.ref.loc15(%.loc15_21.2, %.loc15_43) [template = constants.%.6] -// CHECK:STDOUT: %Negate.ref.loc15_47: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %Negate.ref.loc15_47: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc15_54: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %int.unegate.loc15_53: init i32 = call %Negate.ref.loc15_47(%.loc15_54) [template = constants.%.5] // CHECK:STDOUT: %.loc15_17.1: i32 = value_of_initializer %int.usub.loc15 [template = constants.%.6] @@ -298,16 +319,9 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %.loc15_57.1: i32 = value_of_initializer %int.umod.loc15 [template = constants.%.6] // CHECK:STDOUT: %.loc15_57.2: i32 = converted %int.umod.loc15, %.loc15_57.1 [template = constants.%.6] // CHECK:STDOUT: %c: i32 = bind_name c, %.loc15_57.2 +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Mod(%a: i32, %b: i32) -> i32 = "int.umod"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.usub"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.unegate"; -// CHECK:STDOUT: // CHECK:STDOUT: --- fail_div_by_zero.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -324,6 +338,8 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Mod = %Mod.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -349,27 +365,32 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %int.make_type_32.loc12: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc12_8.1: type = value_of_initializer %int.make_type_32.loc12 [template = i32] // CHECK:STDOUT: %.loc12_8.2: type = converted %int.make_type_32.loc12, %.loc12_8.1 [template = i32] -// CHECK:STDOUT: %Mod.ref.loc12: %Mod.type = name_ref Mod, %Mod.decl [template = constants.%Mod] -// CHECK:STDOUT: %.loc12_18: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc12_21: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %int.umod.loc12: init i32 = call %Mod.ref.loc12(%.loc12_18, %.loc12_21) [template = ] -// CHECK:STDOUT: %.loc12_23.1: i32 = value_of_initializer %int.umod.loc12 [template = ] -// CHECK:STDOUT: %.loc12_23.2: i32 = converted %int.umod.loc12, %.loc12_23.1 [template = ] -// CHECK:STDOUT: %a.loc12: i32 = bind_name a, %.loc12_23.2 // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc17: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc17_8.1: type = value_of_initializer %int.make_type_32.loc17 [template = i32] // CHECK:STDOUT: %.loc17_8.2: type = converted %int.make_type_32.loc17, %.loc17_8.1 [template = i32] -// CHECK:STDOUT: %Mod.ref.loc17: %Mod.type = name_ref Mod, %Mod.decl [template = constants.%Mod] -// CHECK:STDOUT: %.loc17_18: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %.loc17_21: i32 = int_literal 0 [template = constants.%.3] -// CHECK:STDOUT: %int.umod.loc17: init i32 = call %Mod.ref.loc17(%.loc17_18, %.loc17_21) [template = ] -// CHECK:STDOUT: %.loc17_23.1: i32 = value_of_initializer %int.umod.loc17 [template = ] -// CHECK:STDOUT: %.loc17_23.2: i32 = converted %int.umod.loc17, %.loc17_23.1 [template = ] -// CHECK:STDOUT: %b.loc17: i32 = bind_name b, %.loc17_23.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: // CHECK:STDOUT: fn @Mod(%a: i32, %b: i32) -> i32 = "int.umod"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Mod.ref.loc12: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod] +// CHECK:STDOUT: %.loc12_18: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc12_21: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %int.umod.loc12: init i32 = call %Mod.ref.loc12(%.loc12_18, %.loc12_21) [template = ] +// CHECK:STDOUT: %.loc12_23.1: i32 = value_of_initializer %int.umod.loc12 [template = ] +// CHECK:STDOUT: %.loc12_23.2: i32 = converted %int.umod.loc12, %.loc12_23.1 [template = ] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc12_23.2 +// CHECK:STDOUT: %Mod.ref.loc17: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod] +// CHECK:STDOUT: %.loc17_18: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %.loc17_21: i32 = int_literal 0 [template = constants.%.3] +// CHECK:STDOUT: %int.umod.loc17: init i32 = call %Mod.ref.loc17(%.loc17_18, %.loc17_21) [template = ] +// CHECK:STDOUT: %.loc17_23.1: i32 = value_of_initializer %int.umod.loc17 [template = ] +// CHECK:STDOUT: %.loc17_23.2: i32 = converted %int.umod.loc17, %.loc17_23.1 [template = ] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc17_23.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/umul.carbon b/toolchain/check/testdata/builtins/int/umul.carbon index 646ca71663e7..1d9c5536e246 100644 --- a/toolchain/check/testdata/builtins/int/umul.carbon +++ b/toolchain/check/testdata/builtins/int/umul.carbon @@ -50,6 +50,7 @@ let b: i32 = Mul(0x8000, 0x10000); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Mul = %Mul.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -90,9 +91,6 @@ let b: i32 = Mul(0x8000, 0x10000); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -129,6 +127,14 @@ let b: i32 = Mul(0x8000, 0x10000); // CHECK:STDOUT: return %.loc8_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- overflow.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -148,6 +154,8 @@ let b: i32 = Mul(0x8000, 0x10000); // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Mul = %Mul.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -173,27 +181,32 @@ let b: i32 = Mul(0x8000, 0x10000); // CHECK:STDOUT: %int.make_type_32.loc6: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc6_8.1: type = value_of_initializer %int.make_type_32.loc6 [template = i32] // CHECK:STDOUT: %.loc6_8.2: type = converted %int.make_type_32.loc6, %.loc6_8.1 [template = i32] -// CHECK:STDOUT: %Mul.ref.loc6: %Mul.type = name_ref Mul, %Mul.decl [template = constants.%Mul] -// CHECK:STDOUT: %.loc6_18: i32 = int_literal 32767 [template = constants.%.2] -// CHECK:STDOUT: %.loc6_26: i32 = int_literal 65536 [template = constants.%.3] -// CHECK:STDOUT: %int.umul.loc6: init i32 = call %Mul.ref.loc6(%.loc6_18, %.loc6_26) [template = constants.%.4] -// CHECK:STDOUT: %.loc6_34.1: i32 = value_of_initializer %int.umul.loc6 [template = constants.%.4] -// CHECK:STDOUT: %.loc6_34.2: i32 = converted %int.umul.loc6, %.loc6_34.1 [template = constants.%.4] -// CHECK:STDOUT: %a.loc6: i32 = bind_name a, %.loc6_34.2 // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc7: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc7_8.1: type = value_of_initializer %int.make_type_32.loc7 [template = i32] // CHECK:STDOUT: %.loc7_8.2: type = converted %int.make_type_32.loc7, %.loc7_8.1 [template = i32] -// CHECK:STDOUT: %Mul.ref.loc7: %Mul.type = name_ref Mul, %Mul.decl [template = constants.%Mul] -// CHECK:STDOUT: %.loc7_18: i32 = int_literal 32768 [template = constants.%.5] -// CHECK:STDOUT: %.loc7_26: i32 = int_literal 65536 [template = constants.%.3] -// CHECK:STDOUT: %int.umul.loc7: init i32 = call %Mul.ref.loc7(%.loc7_18, %.loc7_26) [template = constants.%.6] -// CHECK:STDOUT: %.loc7_34.1: i32 = value_of_initializer %int.umul.loc7 [template = constants.%.6] -// CHECK:STDOUT: %.loc7_34.2: i32 = converted %int.umul.loc7, %.loc7_34.1 [template = constants.%.6] -// CHECK:STDOUT: %b.loc7: i32 = bind_name b, %.loc7_34.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: // CHECK:STDOUT: fn @Mul(%a: i32, %b: i32) -> i32 = "int.umul"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Mul.ref.loc6: %Mul.type = name_ref Mul, file.%Mul.decl [template = constants.%Mul] +// CHECK:STDOUT: %.loc6_18: i32 = int_literal 32767 [template = constants.%.2] +// CHECK:STDOUT: %.loc6_26: i32 = int_literal 65536 [template = constants.%.3] +// CHECK:STDOUT: %int.umul.loc6: init i32 = call %Mul.ref.loc6(%.loc6_18, %.loc6_26) [template = constants.%.4] +// CHECK:STDOUT: %.loc6_34.1: i32 = value_of_initializer %int.umul.loc6 [template = constants.%.4] +// CHECK:STDOUT: %.loc6_34.2: i32 = converted %int.umul.loc6, %.loc6_34.1 [template = constants.%.4] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc6_34.2 +// CHECK:STDOUT: %Mul.ref.loc7: %Mul.type = name_ref Mul, file.%Mul.decl [template = constants.%Mul] +// CHECK:STDOUT: %.loc7_18: i32 = int_literal 32768 [template = constants.%.5] +// CHECK:STDOUT: %.loc7_26: i32 = int_literal 65536 [template = constants.%.3] +// CHECK:STDOUT: %int.umul.loc7: init i32 = call %Mul.ref.loc7(%.loc7_18, %.loc7_26) [template = constants.%.6] +// CHECK:STDOUT: %.loc7_34.1: i32 = value_of_initializer %int.umul.loc7 [template = constants.%.6] +// CHECK:STDOUT: %.loc7_34.2: i32 = converted %int.umul.loc7, %.loc7_34.1 [template = constants.%.6] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc7_34.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/unegate.carbon b/toolchain/check/testdata/builtins/int/unegate.carbon index 7b974938c611..4111e6f4686d 100644 --- a/toolchain/check/testdata/builtins/int/unegate.carbon +++ b/toolchain/check/testdata/builtins/int/unegate.carbon @@ -135,6 +135,8 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Negate = %Negate.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p +// CHECK:STDOUT: .n = @__global_init.%n // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -172,19 +174,10 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_21: type = array_type %.loc5_18, i32 [template = constants.%.4] // CHECK:STDOUT: %.loc5_22: type = ptr_type %.4 [template = constants.%.5] -// CHECK:STDOUT: %arr.ref: ref %.4 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_26: %.5 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.5 = bind_name arr_p, %.loc5_26 // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc7: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc7_8.1: type = value_of_initializer %int.make_type_32.loc7 [template = i32] // CHECK:STDOUT: %.loc7_8.2: type = converted %int.make_type_32.loc7, %.loc7_8.1 [template = i32] -// CHECK:STDOUT: %Negate.ref.loc7: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] -// CHECK:STDOUT: %.loc7_21: i32 = int_literal 1 [template = constants.%.6] -// CHECK:STDOUT: %int.unegate.loc7: init i32 = call %Negate.ref.loc7(%.loc7_21) [template = constants.%.7] -// CHECK:STDOUT: %.loc7_23.1: i32 = value_of_initializer %int.unegate.loc7 [template = constants.%.7] -// CHECK:STDOUT: %.loc7_23.2: i32 = converted %int.unegate.loc7, %.loc7_23.1 [template = constants.%.7] -// CHECK:STDOUT: %n: i32 = bind_name n, %.loc7_23.2 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -220,6 +213,20 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: return %.loc10_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.4 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.5 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.5 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %.loc7_21: i32 = int_literal 1 [template = constants.%.6] +// CHECK:STDOUT: %int.unegate: init i32 = call %Negate.ref(%.loc7_21) [template = constants.%.7] +// CHECK:STDOUT: %.loc7_23.1: i32 = value_of_initializer %int.unegate [template = constants.%.7] +// CHECK:STDOUT: %.loc7_23.2: i32 = converted %int.unegate, %.loc7_23.1 [template = constants.%.7] +// CHECK:STDOUT: %n: i32 = bind_name n, %.loc7_23.2 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_bad_decl.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -471,6 +478,8 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Negate = %Negate.decl // CHECK:STDOUT: .Sub = %Sub.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -509,8 +518,22 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: %int.make_type_32.loc8: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc8_8.1: type = value_of_initializer %int.make_type_32.loc8 [template = i32] // CHECK:STDOUT: %.loc8_8.2: type = converted %int.make_type_32.loc8, %.loc8_8.1 [template = i32] -// CHECK:STDOUT: %Negate.ref.loc8_14: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] -// CHECK:STDOUT: %Negate.ref.loc8_21: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc11: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc11_8.1: type = value_of_initializer %int.make_type_32.loc11 [template = i32] +// CHECK:STDOUT: %.loc11_8.2: type = converted %int.make_type_32.loc11, %.loc11_8.1 [template = i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.unegate"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.usub"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Negate.ref.loc8_14: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %Negate.ref.loc8_21: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc8_28: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.unegate.loc8_27: init i32 = call %Negate.ref.loc8_21(%.loc8_28) [template = constants.%.3] // CHECK:STDOUT: %.loc8_20.1: i32 = value_of_initializer %int.unegate.loc8_27 [template = constants.%.3] @@ -518,14 +541,10 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: %int.unegate.loc8_20: init i32 = call %Negate.ref.loc8_14(%.loc8_20.2) [template = constants.%.2] // CHECK:STDOUT: %.loc8_40.1: i32 = value_of_initializer %int.unegate.loc8_20 [template = constants.%.2] // CHECK:STDOUT: %.loc8_40.2: i32 = converted %int.unegate.loc8_20, %.loc8_40.1 [template = constants.%.2] -// CHECK:STDOUT: %a.loc8: i32 = bind_name a, %.loc8_40.2 -// CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc11: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc11_8.1: type = value_of_initializer %int.make_type_32.loc11 [template = i32] -// CHECK:STDOUT: %.loc11_8.2: type = converted %int.make_type_32.loc11, %.loc11_8.1 [template = i32] -// CHECK:STDOUT: %Negate.ref.loc11_14: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] -// CHECK:STDOUT: %Sub.ref: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Negate.ref.loc11_25: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc8_40.2 +// CHECK:STDOUT: %Negate.ref.loc11_14: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] +// CHECK:STDOUT: %Sub.ref: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Negate.ref.loc11_25: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %.loc11_32: i32 = int_literal 2147483647 [template = constants.%.2] // CHECK:STDOUT: %int.unegate.loc11_31: init i32 = call %Negate.ref.loc11_25(%.loc11_32) [template = constants.%.3] // CHECK:STDOUT: %.loc11_45: i32 = int_literal 1 [template = constants.%.4] @@ -537,12 +556,7 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1)); // CHECK:STDOUT: %int.unegate.loc11_20: init i32 = call %Negate.ref.loc11_14(%.loc11_20.2) [template = constants.%.5] // CHECK:STDOUT: %.loc11_48.1: i32 = value_of_initializer %int.unegate.loc11_20 [template = constants.%.5] // CHECK:STDOUT: %.loc11_48.2: i32 = converted %int.unegate.loc11_20, %.loc11_48.1 [template = constants.%.5] -// CHECK:STDOUT: %b.loc11: i32 = bind_name b, %.loc11_48.2 +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc11_48.2 +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Negate(%a: i32) -> i32 = "int.unegate"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.usub"; -// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/usub.carbon b/toolchain/check/testdata/builtins/int/usub.carbon index d237a99dbd2c..499df61c7937 100644 --- a/toolchain/check/testdata/builtins/int/usub.carbon +++ b/toolchain/check/testdata/builtins/int/usub.carbon @@ -51,6 +51,7 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Sub = %Sub.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -91,9 +92,6 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -130,6 +128,14 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: return %.loc8_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- overflow.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -150,6 +156,9 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Sub = %Sub.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: .c = @__global_init.%c // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -175,19 +184,31 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: %int.make_type_32.loc6: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc6_8.1: type = value_of_initializer %int.make_type_32.loc6 [template = i32] // CHECK:STDOUT: %.loc6_8.2: type = converted %int.make_type_32.loc6, %.loc6_8.1 [template = i32] -// CHECK:STDOUT: %Sub.ref.loc6: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc7: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc7_8.1: type = value_of_initializer %int.make_type_32.loc7 [template = i32] +// CHECK:STDOUT: %.loc7_8.2: type = converted %int.make_type_32.loc7, %.loc7_8.1 [template = i32] +// CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %int.make_type_32.loc8: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc8_8.1: type = value_of_initializer %int.make_type_32.loc8 [template = i32] +// CHECK:STDOUT: %.loc8_8.2: type = converted %int.make_type_32.loc8, %.loc8_8.1 [template = i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.usub"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Sub.ref.loc6: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] // CHECK:STDOUT: %.loc6_18: i32 = int_literal 0 [template = constants.%.2] // CHECK:STDOUT: %.loc6_21: i32 = int_literal 2147483647 [template = constants.%.3] // CHECK:STDOUT: %int.usub.loc6: init i32 = call %Sub.ref.loc6(%.loc6_18, %.loc6_21) [template = constants.%.4] // CHECK:STDOUT: %.loc6_32.1: i32 = value_of_initializer %int.usub.loc6 [template = constants.%.4] // CHECK:STDOUT: %.loc6_32.2: i32 = converted %int.usub.loc6, %.loc6_32.1 [template = constants.%.4] -// CHECK:STDOUT: %a.loc6: i32 = bind_name a, %.loc6_32.2 -// CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc7: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc7_8.1: type = value_of_initializer %int.make_type_32.loc7 [template = i32] -// CHECK:STDOUT: %.loc7_8.2: type = converted %int.make_type_32.loc7, %.loc7_8.1 [template = i32] -// CHECK:STDOUT: %Sub.ref.loc7_14: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Sub.ref.loc7_18: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %a: i32 = bind_name a, %.loc6_32.2 +// CHECK:STDOUT: %Sub.ref.loc7_14: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Sub.ref.loc7_18: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] // CHECK:STDOUT: %.loc7_22: i32 = int_literal 0 [template = constants.%.2] // CHECK:STDOUT: %.loc7_25: i32 = int_literal 2147483647 [template = constants.%.3] // CHECK:STDOUT: %int.usub.loc7_21: init i32 = call %Sub.ref.loc7_18(%.loc7_22, %.loc7_25) [template = constants.%.4] @@ -197,13 +218,9 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: %int.usub.loc7_17: init i32 = call %Sub.ref.loc7_14(%.loc7_17.2, %.loc7_38) [template = constants.%.6] // CHECK:STDOUT: %.loc7_40.1: i32 = value_of_initializer %int.usub.loc7_17 [template = constants.%.6] // CHECK:STDOUT: %.loc7_40.2: i32 = converted %int.usub.loc7_17, %.loc7_40.1 [template = constants.%.6] -// CHECK:STDOUT: %b.loc7: i32 = bind_name b, %.loc7_40.2 -// CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %int.make_type_32.loc8: init type = call constants.%Int32() [template = i32] -// CHECK:STDOUT: %.loc8_8.1: type = value_of_initializer %int.make_type_32.loc8 [template = i32] -// CHECK:STDOUT: %.loc8_8.2: type = converted %int.make_type_32.loc8, %.loc8_8.1 [template = i32] -// CHECK:STDOUT: %Sub.ref.loc8_14: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] -// CHECK:STDOUT: %Sub.ref.loc8_18: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc7_40.2 +// CHECK:STDOUT: %Sub.ref.loc8_14: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] +// CHECK:STDOUT: %Sub.ref.loc8_18: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] // CHECK:STDOUT: %.loc8_22: i32 = int_literal 0 [template = constants.%.2] // CHECK:STDOUT: %.loc8_25: i32 = int_literal 2147483647 [template = constants.%.3] // CHECK:STDOUT: %int.usub.loc8_21: init i32 = call %Sub.ref.loc8_18(%.loc8_22, %.loc8_25) [template = constants.%.4] @@ -214,9 +231,6 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: %.loc8_40.1: i32 = value_of_initializer %int.usub.loc8_17 [template = constants.%.3] // CHECK:STDOUT: %.loc8_40.2: i32 = converted %int.usub.loc8_17, %.loc8_40.1 [template = constants.%.3] // CHECK:STDOUT: %c: i32 = bind_name c, %.loc8_40.2 +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Sub(%a: i32, %b: i32) -> i32 = "int.usub"; -// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/xor.carbon b/toolchain/check/testdata/builtins/int/xor.carbon index 49aed6dd4ebe..ce21b64d23f6 100644 --- a/toolchain/check/testdata/builtins/int/xor.carbon +++ b/toolchain/check/testdata/builtins/int/xor.carbon @@ -41,6 +41,7 @@ fn RuntimeCall(a: i32, b: i32) -> i32 { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Xor = %Xor.decl // CHECK:STDOUT: .arr = %arr +// CHECK:STDOUT: .arr_p = @__global_init.%arr_p // CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -81,9 +82,6 @@ fn RuntimeCall(a: i32, b: i32) -> i32 { // CHECK:STDOUT: %.loc5_13.2: type = converted %int.make_type_32.loc5, %.loc5_13.1 [template = i32] // CHECK:STDOUT: %.loc5_19: type = array_type %.loc5_18, i32 [template = constants.%.5] // CHECK:STDOUT: %.loc5_20: type = ptr_type %.5 [template = constants.%.6] -// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, %arr -// CHECK:STDOUT: %.loc5_24: %.6 = addr_of %arr.ref -// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5_24 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -120,3 +118,11 @@ fn RuntimeCall(a: i32, b: i32) -> i32 { // CHECK:STDOUT: return %.loc8_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.ref: ref %.5 = name_ref arr, file.%arr +// CHECK:STDOUT: %.loc5: %.6 = addr_of %arr.ref +// CHECK:STDOUT: %arr_p: %.6 = bind_name arr_p, %.loc5 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/fail_base_unbound.carbon b/toolchain/check/testdata/class/fail_base_unbound.carbon index 7135bbef8032..3071488d15dd 100644 --- a/toolchain/check/testdata/class/fail_base_unbound.carbon +++ b/toolchain/check/testdata/class/fail_base_unbound.carbon @@ -36,14 +36,12 @@ let b: B = C.base; // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .B = %B.decl // CHECK:STDOUT: .C = %C.decl +// CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %B.decl: type = class_decl @B [template = constants.%B] {} // CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} // CHECK:STDOUT: %B.ref: type = name_ref B, %B.decl [template = constants.%B] -// CHECK:STDOUT: %C.ref: type = name_ref C, %C.decl [template = constants.%C] -// CHECK:STDOUT: %base.ref: %.4 = name_ref base, @C.%.loc14 [template = @C.%.loc14] -// CHECK:STDOUT: %b: %B = bind_name b, // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @B { @@ -61,3 +59,11 @@ let b: B = C.base; // CHECK:STDOUT: extend name_scope2 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C] +// CHECK:STDOUT: %base.ref: %.4 = name_ref base, @C.%.loc14 [template = @C.%.loc14] +// CHECK:STDOUT: %b: %B = bind_name b, +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/fail_field_modifiers.carbon b/toolchain/check/testdata/class/fail_field_modifiers.carbon index a69d86dd2294..6cef49ac7794 100644 --- a/toolchain/check/testdata/class/fail_field_modifiers.carbon +++ b/toolchain/check/testdata/class/fail_field_modifiers.carbon @@ -84,6 +84,8 @@ class Class { // CHECK:STDOUT: .Self = constants.%Class // CHECK:STDOUT: .j = %.loc17_16 // CHECK:STDOUT: .k = %.loc23_14 +// CHECK:STDOUT: .l = %l +// CHECK:STDOUT: .m = %m // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; diff --git a/toolchain/check/testdata/class/fail_member_of_let.carbon b/toolchain/check/testdata/class/fail_member_of_let.carbon index ba40ad4a6c93..c474fecabc49 100644 --- a/toolchain/check/testdata/class/fail_member_of_let.carbon +++ b/toolchain/check/testdata/class/fail_member_of_let.carbon @@ -17,9 +17,12 @@ let T: type = Class; // The class name is required to be written in the same way as in the class // declaration. An expression that evaluates to the class name is not accepted. -// CHECK:STDERR: fail_member_of_let.carbon:[[@LINE+3]]:4: ERROR: Name `T` not found. +// CHECK:STDERR: fail_member_of_let.carbon:[[@LINE+6]]:4: ERROR: Name qualifiers are only allowed for entities that provide a scope. // CHECK:STDERR: fn T.F() {} // CHECK:STDERR: ^ +// CHECK:STDERR: fail_member_of_let.carbon:[[@LINE-7]]:5: Referenced non-scope entity declared here. +// CHECK:STDERR: let T: type = Class; +// CHECK:STDERR: ^ fn T.F() {} // CHECK:STDOUT: --- fail_member_of_let.carbon @@ -40,12 +43,11 @@ fn T.F() {} // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Class = %Class.decl +// CHECK:STDOUT: .T = @__global_init.%T // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %Class.decl: type = class_decl @Class [template = constants.%Class] {} // CHECK:STDOUT: %import_ref: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %Class.ref: type = name_ref Class, %Class.decl [template = constants.%Class] -// CHECK:STDOUT: %T: type = bind_name T, %Class.ref // CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.3] {} // CHECK:STDOUT: } // CHECK:STDOUT: @@ -71,3 +73,10 @@ fn T.F() {} // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Class.ref: type = name_ref Class, file.%Class.decl [template = constants.%Class] +// CHECK:STDOUT: %T: type = bind_name T, %Class.ref +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/init_adapt.carbon b/toolchain/check/testdata/class/init_adapt.carbon index 6e6c8c433080..fef22ece6a95 100644 --- a/toolchain/check/testdata/class/init_adapt.carbon +++ b/toolchain/check/testdata/class/init_adapt.carbon @@ -104,6 +104,9 @@ var e: C = MakeAdaptC(); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .C = %C.decl // CHECK:STDOUT: .AdaptC = %AdaptC.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: .c = @__global_init.%c // CHECK:STDOUT: .MakeC = %MakeC.decl // CHECK:STDOUT: .MakeAdaptC = %MakeAdaptC.decl // CHECK:STDOUT: .d = %d @@ -115,31 +118,8 @@ var e: C = MakeAdaptC(); // CHECK:STDOUT: %import_ref.2: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %AdaptC.decl: type = class_decl @AdaptC [template = constants.%AdaptC] {} // CHECK:STDOUT: %C.ref.loc13: type = name_ref C, %C.decl [template = constants.%C] -// CHECK:STDOUT: %.loc13_18: i32 = int_literal 1 [template = constants.%.5] -// CHECK:STDOUT: %.loc13_26: i32 = int_literal 2 [template = constants.%.6] -// CHECK:STDOUT: %.loc13_27.1: %.3 = struct_literal (%.loc13_18, %.loc13_26) -// CHECK:STDOUT: %.loc13_27.2: ref %C = temporary_storage -// CHECK:STDOUT: %.loc13_27.3: ref i32 = class_element_access %.loc13_27.2, element0 -// CHECK:STDOUT: %.loc13_27.4: init i32 = initialize_from %.loc13_18 to %.loc13_27.3 [template = constants.%.5] -// CHECK:STDOUT: %.loc13_27.5: ref i32 = class_element_access %.loc13_27.2, element1 -// CHECK:STDOUT: %.loc13_27.6: init i32 = initialize_from %.loc13_26 to %.loc13_27.5 [template = constants.%.6] -// CHECK:STDOUT: %.loc13_27.7: init %C = class_init (%.loc13_27.4, %.loc13_27.6), %.loc13_27.2 [template = constants.%struct] -// CHECK:STDOUT: %.loc13_27.8: ref %C = temporary %.loc13_27.2, %.loc13_27.7 -// CHECK:STDOUT: %.loc13_28.1: ref %C = converted %.loc13_27.1, %.loc13_27.8 -// CHECK:STDOUT: %.loc13_28.2: %C = bind_value %.loc13_28.1 -// CHECK:STDOUT: %a: %C = bind_name a, %.loc13_28.2 -// CHECK:STDOUT: %AdaptC.ref.loc15_8: type = name_ref AdaptC, %AdaptC.decl [template = constants.%AdaptC] -// CHECK:STDOUT: %a.ref: %C = name_ref a, %a -// CHECK:STDOUT: %AdaptC.ref.loc15_22: type = name_ref AdaptC, %AdaptC.decl [template = constants.%AdaptC] -// CHECK:STDOUT: %.loc15_19.1: %AdaptC = as_compatible %a.ref -// CHECK:STDOUT: %.loc15_19.2: %AdaptC = converted %a.ref, %.loc15_19.1 -// CHECK:STDOUT: %b: %AdaptC = bind_name b, %.loc15_19.2 -// CHECK:STDOUT: %C.ref.loc17_8: type = name_ref C, %C.decl [template = constants.%C] -// CHECK:STDOUT: %b.ref: %AdaptC = name_ref b, %b -// CHECK:STDOUT: %C.ref.loc17_17: type = name_ref C, %C.decl [template = constants.%C] -// CHECK:STDOUT: %.loc17_14.1: %C = as_compatible %b.ref -// CHECK:STDOUT: %.loc17_14.2: %C = converted %b.ref, %.loc17_14.1 -// CHECK:STDOUT: %c: %C = bind_name c, %.loc17_14.2 +// CHECK:STDOUT: %AdaptC.ref.loc15: type = name_ref AdaptC, %AdaptC.decl [template = constants.%AdaptC] +// CHECK:STDOUT: %C.ref.loc17: type = name_ref C, %C.decl [template = constants.%C] // CHECK:STDOUT: %MakeC.decl: %MakeC.type = fn_decl @MakeC [template = constants.%MakeC] { // CHECK:STDOUT: %C.ref.loc19: type = name_ref C, %C.decl [template = constants.%C] // CHECK:STDOUT: @MakeC.%return: ref %C = var @@ -188,17 +168,40 @@ var e: C = MakeAdaptC(); // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { // CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc13_18: i32 = int_literal 1 [template = constants.%.5] +// CHECK:STDOUT: %.loc13_26: i32 = int_literal 2 [template = constants.%.6] +// CHECK:STDOUT: %.loc13_27.1: %.3 = struct_literal (%.loc13_18, %.loc13_26) +// CHECK:STDOUT: %.loc13_27.2: ref %C = temporary_storage +// CHECK:STDOUT: %.loc13_27.3: ref i32 = class_element_access %.loc13_27.2, element0 +// CHECK:STDOUT: %.loc13_27.4: init i32 = initialize_from %.loc13_18 to %.loc13_27.3 [template = constants.%.5] +// CHECK:STDOUT: %.loc13_27.5: ref i32 = class_element_access %.loc13_27.2, element1 +// CHECK:STDOUT: %.loc13_27.6: init i32 = initialize_from %.loc13_26 to %.loc13_27.5 [template = constants.%.6] +// CHECK:STDOUT: %.loc13_27.7: init %C = class_init (%.loc13_27.4, %.loc13_27.6), %.loc13_27.2 [template = constants.%struct] +// CHECK:STDOUT: %.loc13_27.8: ref %C = temporary %.loc13_27.2, %.loc13_27.7 +// CHECK:STDOUT: %.loc13_28.1: ref %C = converted %.loc13_27.1, %.loc13_27.8 +// CHECK:STDOUT: %.loc13_28.2: %C = bind_value %.loc13_28.1 +// CHECK:STDOUT: %a: %C = bind_name a, %.loc13_28.2 +// CHECK:STDOUT: %a.ref: %C = name_ref a, %a +// CHECK:STDOUT: %AdaptC.ref.loc15: type = name_ref AdaptC, file.%AdaptC.decl [template = constants.%AdaptC] +// CHECK:STDOUT: %.loc15_19.1: %AdaptC = as_compatible %a.ref +// CHECK:STDOUT: %.loc15_19.2: %AdaptC = converted %a.ref, %.loc15_19.1 +// CHECK:STDOUT: %b: %AdaptC = bind_name b, %.loc15_19.2 +// CHECK:STDOUT: %b.ref: %AdaptC = name_ref b, %b +// CHECK:STDOUT: %C.ref.loc17: type = name_ref C, file.%C.decl [template = constants.%C] +// CHECK:STDOUT: %.loc17_14.1: %C = as_compatible %b.ref +// CHECK:STDOUT: %.loc17_14.2: %C = converted %b.ref, %.loc17_14.1 +// CHECK:STDOUT: %c: %C = bind_name c, %.loc17_14.2 // CHECK:STDOUT: %MakeC.ref: %MakeC.type = name_ref MakeC, file.%MakeC.decl [template = constants.%MakeC] // CHECK:STDOUT: %.loc23_5: ref %AdaptC = splice_block file.%d.var {} // CHECK:STDOUT: %MakeC.call: init %C = call %MakeC.ref() to %.loc23_5 -// CHECK:STDOUT: %AdaptC.ref: type = name_ref AdaptC, file.%AdaptC.decl [template = constants.%AdaptC] +// CHECK:STDOUT: %AdaptC.ref.loc23: type = name_ref AdaptC, file.%AdaptC.decl [template = constants.%AdaptC] // CHECK:STDOUT: %.loc23_25.1: init %AdaptC = as_compatible %MakeC.call // CHECK:STDOUT: %.loc23_25.2: init %AdaptC = converted %MakeC.call, %.loc23_25.1 // CHECK:STDOUT: assign file.%d.var, %.loc23_25.2 // CHECK:STDOUT: %MakeAdaptC.ref: %MakeAdaptC.type = name_ref MakeAdaptC, file.%MakeAdaptC.decl [template = constants.%MakeAdaptC] // CHECK:STDOUT: %.loc25_5: ref %C = splice_block file.%e.var {} // CHECK:STDOUT: %MakeAdaptC.call: init %AdaptC = call %MakeAdaptC.ref() to %.loc25_5 -// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C] +// CHECK:STDOUT: %C.ref.loc25: type = name_ref C, file.%C.decl [template = constants.%C] // CHECK:STDOUT: %.loc25_25.1: init %C = as_compatible %MakeAdaptC.call // CHECK:STDOUT: %.loc25_25.2: init %C = converted %MakeAdaptC.call, %.loc25_25.1 // CHECK:STDOUT: assign file.%e.var, %.loc25_25.2 @@ -230,6 +233,9 @@ var e: C = MakeAdaptC(); // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .C = %C.decl // CHECK:STDOUT: .AdaptC = %AdaptC.decl +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: .c = @__global_init.%c // CHECK:STDOUT: .MakeC = %MakeC.decl // CHECK:STDOUT: .MakeAdaptC = %MakeAdaptC.decl // CHECK:STDOUT: .d = %d @@ -241,25 +247,8 @@ var e: C = MakeAdaptC(); // CHECK:STDOUT: %import_ref.2: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %AdaptC.decl: type = class_decl @AdaptC [template = constants.%AdaptC] {} // CHECK:STDOUT: %C.ref.loc13: type = name_ref C, %C.decl [template = constants.%C] -// CHECK:STDOUT: %.loc13_18: i32 = int_literal 1 [template = constants.%.5] -// CHECK:STDOUT: %.loc13_26: i32 = int_literal 2 [template = constants.%.6] -// CHECK:STDOUT: %.loc13_27.1: %.3 = struct_literal (%.loc13_18, %.loc13_26) -// CHECK:STDOUT: %.loc13_27.2: ref %C = temporary_storage -// CHECK:STDOUT: %.loc13_27.3: ref i32 = class_element_access %.loc13_27.2, element0 -// CHECK:STDOUT: %.loc13_27.4: init i32 = initialize_from %.loc13_18 to %.loc13_27.3 [template = constants.%.5] -// CHECK:STDOUT: %.loc13_27.5: ref i32 = class_element_access %.loc13_27.2, element1 -// CHECK:STDOUT: %.loc13_27.6: init i32 = initialize_from %.loc13_26 to %.loc13_27.5 [template = constants.%.6] -// CHECK:STDOUT: %.loc13_27.7: init %C = class_init (%.loc13_27.4, %.loc13_27.6), %.loc13_27.2 [template = constants.%struct] -// CHECK:STDOUT: %.loc13_27.8: ref %C = temporary %.loc13_27.2, %.loc13_27.7 -// CHECK:STDOUT: %.loc13_28.1: ref %C = converted %.loc13_27.1, %.loc13_27.8 -// CHECK:STDOUT: %.loc13_28.2: %C = bind_value %.loc13_28.1 -// CHECK:STDOUT: %a: %C = bind_name a, %.loc13_28.2 // CHECK:STDOUT: %AdaptC.ref.loc21: type = name_ref AdaptC, %AdaptC.decl [template = constants.%AdaptC] -// CHECK:STDOUT: %a.ref: %C = name_ref a, %a -// CHECK:STDOUT: %b: %AdaptC = bind_name b, // CHECK:STDOUT: %C.ref.loc27: type = name_ref C, %C.decl [template = constants.%C] -// CHECK:STDOUT: %b.ref: %AdaptC = name_ref b, %b -// CHECK:STDOUT: %c: %C = bind_name c, // CHECK:STDOUT: %MakeC.decl: %MakeC.type = fn_decl @MakeC [template = constants.%MakeC] { // CHECK:STDOUT: %C.ref.loc29: type = name_ref C, %C.decl [template = constants.%C] // CHECK:STDOUT: @MakeC.%return: ref %C = var @@ -308,6 +297,23 @@ var e: C = MakeAdaptC(); // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { // CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc13_18: i32 = int_literal 1 [template = constants.%.5] +// CHECK:STDOUT: %.loc13_26: i32 = int_literal 2 [template = constants.%.6] +// CHECK:STDOUT: %.loc13_27.1: %.3 = struct_literal (%.loc13_18, %.loc13_26) +// CHECK:STDOUT: %.loc13_27.2: ref %C = temporary_storage +// CHECK:STDOUT: %.loc13_27.3: ref i32 = class_element_access %.loc13_27.2, element0 +// CHECK:STDOUT: %.loc13_27.4: init i32 = initialize_from %.loc13_18 to %.loc13_27.3 [template = constants.%.5] +// CHECK:STDOUT: %.loc13_27.5: ref i32 = class_element_access %.loc13_27.2, element1 +// CHECK:STDOUT: %.loc13_27.6: init i32 = initialize_from %.loc13_26 to %.loc13_27.5 [template = constants.%.6] +// CHECK:STDOUT: %.loc13_27.7: init %C = class_init (%.loc13_27.4, %.loc13_27.6), %.loc13_27.2 [template = constants.%struct] +// CHECK:STDOUT: %.loc13_27.8: ref %C = temporary %.loc13_27.2, %.loc13_27.7 +// CHECK:STDOUT: %.loc13_28.1: ref %C = converted %.loc13_27.1, %.loc13_27.8 +// CHECK:STDOUT: %.loc13_28.2: %C = bind_value %.loc13_28.1 +// CHECK:STDOUT: %a: %C = bind_name a, %.loc13_28.2 +// CHECK:STDOUT: %a.ref: %C = name_ref a, %a +// CHECK:STDOUT: %b: %AdaptC = bind_name b, +// CHECK:STDOUT: %b.ref: %AdaptC = name_ref b, %b +// CHECK:STDOUT: %c: %C = bind_name c, // CHECK:STDOUT: %MakeC.ref: %MakeC.type = name_ref MakeC, file.%MakeC.decl [template = constants.%MakeC] // CHECK:STDOUT: %.loc37: ref %C = temporary_storage // CHECK:STDOUT: %MakeC.call: init %C = call %MakeC.ref() to %.loc37 diff --git a/toolchain/check/testdata/if_expr/fail_not_in_function.carbon b/toolchain/check/testdata/if_expr/fail_not_in_function.carbon index 9c1abddb013a..b116544d04c2 100644 --- a/toolchain/check/testdata/if_expr/fail_not_in_function.carbon +++ b/toolchain/check/testdata/if_expr/fail_not_in_function.carbon @@ -55,11 +55,19 @@ class C { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { -// CHECK:STDOUT: %.loc23: i32 = block_arg [template = constants.%.3] -// CHECK:STDOUT: %x: i32 = bind_name x, %.loc23 -// CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .x = +// CHECK:STDOUT: .C = %C.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] -// CHECK:STDOUT: %import_ref.2: %Float.type = import_ref ir3, inst+31, loaded [template = constants.%Float] +// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc23_8.1: type = value_of_initializer %int.make_type_32 [template = i32] +// CHECK:STDOUT: %.loc23_8.2: type = converted %int.make_type_32, %.loc23_8.1 [template = i32] +// CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} +// CHECK:STDOUT: %import_ref.2: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: %import_ref.3: %Float.type = import_ref ir3, inst+31, loaded [template = constants.%Float] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { @@ -75,3 +83,9 @@ class C { // CHECK:STDOUT: // CHECK:STDOUT: fn @Float(%size: i32) -> type = "float.make_type"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc23: bool = bool_literal true [template = constants.%.2] +// CHECK:STDOUT: if %.loc23 br !if.expr.then else br !if.expr.else +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/interface/no_prelude/fail_assoc_const_not_binding.carbon b/toolchain/check/testdata/interface/no_prelude/fail_assoc_const_not_binding.carbon index dcc299f13c0f..7da0a1ced255 100644 --- a/toolchain/check/testdata/interface/no_prelude/fail_assoc_const_not_binding.carbon +++ b/toolchain/check/testdata/interface/no_prelude/fail_assoc_const_not_binding.carbon @@ -9,7 +9,7 @@ // TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/interface/no_prelude/fail_assoc_const_not_binding.carbon interface I { - // CHECK:STDERR: fail_assoc_const_not_binding.carbon:[[@LINE+3]]:3: ERROR: Semantics TODO: `tuple pattern in let`. + // CHECK:STDERR: fail_assoc_const_not_binding.carbon:[[@LINE+3]]:3: ERROR: Semantics TODO: `tuple pattern in let/var`. // CHECK:STDERR: let (T:! type, U:! type); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~ let (T:! type, U:! type); diff --git a/toolchain/check/testdata/let/fail_generic_import.carbon b/toolchain/check/testdata/let/fail_generic_import.carbon index 7b8e821daf13..e9eb0871e699 100644 --- a/toolchain/check/testdata/let/fail_generic_import.carbon +++ b/toolchain/check/testdata/let/fail_generic_import.carbon @@ -36,17 +36,23 @@ let a: T = 0; // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .T = @__global_init.%T // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: // CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc4_19.1: type = value_of_initializer %int.make_type_32 [template = i32] // CHECK:STDOUT: %.loc4_19.2: type = converted %int.make_type_32, %.loc4_19.1 [template = i32] // CHECK:STDOUT: %T: type = bind_symbolic_name T 0, %.loc4_19.2 [symbolic = constants.%T] +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; -// CHECK:STDOUT: // CHECK:STDOUT: --- fail_implicit.impl.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -58,11 +64,17 @@ let a: T = 0; // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .T = %import_ref // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .a = @__global_init.%a // CHECK:STDOUT: } // CHECK:STDOUT: %import_ref: type = import_ref ir0, inst+2, loaded [symbolic = constants.%T] // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %T.ref: type = name_ref T, %import_ref [symbolic = constants.%T] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc8: i32 = int_literal 0 [template = constants.%.1] // CHECK:STDOUT: %a: %T = bind_name a, +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/let/fail_missing_value.carbon b/toolchain/check/testdata/let/fail_missing_value.carbon index d136195f1ac1..8ff08e60f138 100644 --- a/toolchain/check/testdata/let/fail_missing_value.carbon +++ b/toolchain/check/testdata/let/fail_missing_value.carbon @@ -34,6 +34,7 @@ fn F() { // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .n = %n // CHECK:STDOUT: .F = %F.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} diff --git a/toolchain/check/testdata/let/fail_modifiers.carbon b/toolchain/check/testdata/let/fail_modifiers.carbon index f647949afce6..75924525585f 100644 --- a/toolchain/check/testdata/let/fail_modifiers.carbon +++ b/toolchain/check/testdata/let/fail_modifiers.carbon @@ -95,57 +95,70 @@ protected protected let i: i32 = 1; // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: .c = @__global_init.%c +// CHECK:STDOUT: .d = @__global_init.%d +// CHECK:STDOUT: .e = @__global_init.%e +// CHECK:STDOUT: .f = @__global_init.%f +// CHECK:STDOUT: .g = @__global_init.%g +// CHECK:STDOUT: .h = @__global_init.%h +// CHECK:STDOUT: .i = @__global_init.%i // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc15: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc15_18.1: type = value_of_initializer %int.make_type_32.loc15 [template = i32] // CHECK:STDOUT: %.loc15_18.2: type = converted %int.make_type_32.loc15, %.loc15_18.1 [template = i32] -// CHECK:STDOUT: %.loc15_24: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %b: i32 = bind_name b, %.loc15_24 // CHECK:STDOUT: %import_ref.2: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc21: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc21_16.1: type = value_of_initializer %int.make_type_32.loc21 [template = i32] // CHECK:STDOUT: %.loc21_16.2: type = converted %int.make_type_32.loc21, %.loc21_16.1 [template = i32] -// CHECK:STDOUT: %.loc21_22: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %c: i32 = bind_name c, %.loc21_22 // CHECK:STDOUT: %import_ref.3: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc27: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc27_14.1: type = value_of_initializer %int.make_type_32.loc27 [template = i32] // CHECK:STDOUT: %.loc27_14.2: type = converted %int.make_type_32.loc27, %.loc27_14.1 [template = i32] -// CHECK:STDOUT: %.loc27_20: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %d: i32 = bind_name d, %.loc27_20 // CHECK:STDOUT: %import_ref.4: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc33: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc33_16.1: type = value_of_initializer %int.make_type_32.loc33 [template = i32] // CHECK:STDOUT: %.loc33_16.2: type = converted %int.make_type_32.loc33, %.loc33_16.1 [template = i32] -// CHECK:STDOUT: %.loc33_22: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %e: i32 = bind_name e, %.loc33_22 // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc46: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc46_22.1: type = value_of_initializer %int.make_type_32.loc46 [template = i32] // CHECK:STDOUT: %.loc46_22.2: type = converted %int.make_type_32.loc46, %.loc46_22.1 [template = i32] -// CHECK:STDOUT: %.loc46_28: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %f: i32 = bind_name f, %.loc46_28 // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc59: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc59_24.1: type = value_of_initializer %int.make_type_32.loc59 [template = i32] // CHECK:STDOUT: %.loc59_24.2: type = converted %int.make_type_32.loc59, %.loc59_24.1 [template = i32] -// CHECK:STDOUT: %.loc59_30: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %g: i32 = bind_name g, %.loc59_30 // CHECK:STDOUT: %import_ref.7: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc72: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc72_26.1: type = value_of_initializer %int.make_type_32.loc72 [template = i32] // CHECK:STDOUT: %.loc72_26.2: type = converted %int.make_type_32.loc72, %.loc72_26.1 [template = i32] -// CHECK:STDOUT: %.loc72_32: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %h: i32 = bind_name h, %.loc72_32 // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc84: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc84_28.1: type = value_of_initializer %int.make_type_32.loc84 [template = i32] // CHECK:STDOUT: %.loc84_28.2: type = converted %int.make_type_32.loc84, %.loc84_28.1 [template = i32] -// CHECK:STDOUT: %.loc84_34: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %i: i32 = bind_name i, %.loc84_34 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc15: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %b: i32 = bind_name b, %.loc15 +// CHECK:STDOUT: %.loc21: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %c: i32 = bind_name c, %.loc21 +// CHECK:STDOUT: %.loc27: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %d: i32 = bind_name d, %.loc27 +// CHECK:STDOUT: %.loc33: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %e: i32 = bind_name e, %.loc33 +// CHECK:STDOUT: %.loc46: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %f: i32 = bind_name f, %.loc46 +// CHECK:STDOUT: %.loc59: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %g: i32 = bind_name g, %.loc59 +// CHECK:STDOUT: %.loc72: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %h: i32 = bind_name h, %.loc72 +// CHECK:STDOUT: %.loc84: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %i: i32 = bind_name i, %.loc84 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/let/generic_import.carbon b/toolchain/check/testdata/let/generic_import.carbon index 6e878db38d20..947c99a1320b 100644 --- a/toolchain/check/testdata/let/generic_import.carbon +++ b/toolchain/check/testdata/let/generic_import.carbon @@ -33,17 +33,23 @@ var b: T = *a; // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .T = @__global_init.%T // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: // CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc4_19.1: type = value_of_initializer %int.make_type_32 [template = i32] // CHECK:STDOUT: %.loc4_19.2: type = converted %int.make_type_32, %.loc4_19.1 [template = i32] // CHECK:STDOUT: %T: type = bind_symbolic_name T 0, %.loc4_19.2 [symbolic = constants.%T] +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; -// CHECK:STDOUT: // CHECK:STDOUT: --- implicit.impl.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { diff --git a/toolchain/check/testdata/let/global.carbon b/toolchain/check/testdata/let/global.carbon index f9c225900571..ef42164b79ec 100644 --- a/toolchain/check/testdata/let/global.carbon +++ b/toolchain/check/testdata/let/global.carbon @@ -26,6 +26,7 @@ fn F() -> i32 { return n; } // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .n = @__global_init.%n // CHECK:STDOUT: .F = %F.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -33,8 +34,6 @@ fn F() -> i32 { return n; } // CHECK:STDOUT: %int.make_type_32.loc11: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc11_8.1: type = value_of_initializer %int.make_type_32.loc11 [template = i32] // CHECK:STDOUT: %.loc11_8.2: type = converted %int.make_type_32.loc11, %.loc11_8.1 [template = i32] -// CHECK:STDOUT: %.loc11_14: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %n: i32 = bind_name n, %.loc11_14 // CHECK:STDOUT: %import_ref.2: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { // CHECK:STDOUT: %int.make_type_32.loc13: init type = call constants.%Int32() [template = i32] @@ -48,7 +47,14 @@ fn F() -> i32 { return n; } // CHECK:STDOUT: // CHECK:STDOUT: fn @F() -> i32 { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %n.ref: i32 = name_ref n, file.%n +// CHECK:STDOUT: %n.ref: i32 = name_ref n, @__global_init.%n // CHECK:STDOUT: return %n.ref // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc11: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %n: i32 = bind_name n, %.loc11 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/let/import.carbon b/toolchain/check/testdata/let/import.carbon deleted file mode 100644 index c99df1b18869..000000000000 --- a/toolchain/check/testdata/let/import.carbon +++ /dev/null @@ -1,74 +0,0 @@ -// 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 -// -// AUTOUPDATE -// TIP: To test this file alone, run: -// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/let/import.carbon -// TIP: To dump output, run: -// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/let/import.carbon - -// --- implicit.carbon - -package Implicit; - -let a:! bool = true; - -// --- implicit.impl.carbon - -impl package Implicit; - -let b:! bool = a; - -// CHECK:STDOUT: --- implicit.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %Bool.type: type = fn_type @Bool [template] -// CHECK:STDOUT: %.1: type = tuple_type () [template] -// CHECK:STDOUT: %Bool: %Bool.type = struct_value () [template] -// CHECK:STDOUT: %.2: bool = bool_literal true [template] -// CHECK:STDOUT: %a: bool = bind_symbolic_name a 0 [symbolic] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [template] { -// CHECK:STDOUT: .Core = %Core -// CHECK:STDOUT: } -// CHECK:STDOUT: %Core: = namespace [template] {} -// CHECK:STDOUT: %import_ref: %Bool.type = import_ref ir7, inst+2, loaded [template = constants.%Bool] -// CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc4_9.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc4_9.2: type = converted %bool.make_type, %.loc4_9.1 [template = bool] -// CHECK:STDOUT: %.loc4_16: bool = bool_literal true [template = constants.%.2] -// CHECK:STDOUT: %a: bool = bind_symbolic_name a 0, %.loc4_16 [symbolic = constants.%a] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Bool() -> type = "bool.make_type"; -// CHECK:STDOUT: -// CHECK:STDOUT: --- implicit.impl.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %Bool.type: type = fn_type @Bool [template] -// CHECK:STDOUT: %.1: type = tuple_type () [template] -// CHECK:STDOUT: %Bool: %Bool.type = struct_value () [template] -// CHECK:STDOUT: %a: bool = bind_symbolic_name a 0 [symbolic] -// CHECK:STDOUT: %b: bool = bind_symbolic_name b 0 [symbolic] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [template] { -// CHECK:STDOUT: .a = %import_ref.1 -// CHECK:STDOUT: .Core = %Core -// CHECK:STDOUT: } -// CHECK:STDOUT: %import_ref.1: bool = import_ref ir0, inst+11, loaded [symbolic = constants.%a] -// CHECK:STDOUT: %Core: = namespace [template] {} -// CHECK:STDOUT: %import_ref.2: %Bool.type = import_ref ir7, inst+2, loaded [template = constants.%Bool] -// CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc4_9.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc4_9.2: type = converted %bool.make_type, %.loc4_9.1 [template = bool] -// CHECK:STDOUT: %a.ref: bool = name_ref a, %import_ref.1 [symbolic = constants.%a] -// CHECK:STDOUT: %b: bool = bind_symbolic_name b 0, %a.ref [symbolic = constants.%b] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @Bool() -> type = "bool.make_type"; -// CHECK:STDOUT: diff --git a/toolchain/check/testdata/let/no_prelude/import.carbon b/toolchain/check/testdata/let/no_prelude/import.carbon new file mode 100644 index 000000000000..4b1eddde15a4 --- /dev/null +++ b/toolchain/check/testdata/let/no_prelude/import.carbon @@ -0,0 +1,136 @@ +// 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 +// +// AUTOUPDATE +// TIP: To test this file alone, run: +// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/let/no_prelude/import.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/let/no_prelude/import.carbon + +// --- implicit.carbon + +package Implicit; + +let a:! () = (); + +// --- implicit.impl.carbon + +impl package Implicit; + +let b:! () = a; + +// --- other.carbon + +package Other; + +let a:! () = (); + +// --- import_other.carbon + +import Other; + +let b:! () = Other.a; + +// CHECK:STDOUT: --- implicit.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %.1: type = tuple_type () [template] +// CHECK:STDOUT: %tuple: %.1 = tuple_value () [template] +// CHECK:STDOUT: %a: %.1 = bind_symbolic_name a 0 [symbolic] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc4_10.1: %.1 = tuple_literal () +// CHECK:STDOUT: %.loc4_10.2: type = converted %.loc4_10.1, constants.%.1 [template = constants.%.1] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc4_15: %.1 = tuple_literal () +// CHECK:STDOUT: %tuple: %.1 = tuple_value () [template = constants.%tuple] +// CHECK:STDOUT: %.loc4_16: %.1 = converted %.loc4_15, %tuple [template = constants.%tuple] +// CHECK:STDOUT: %a: %.1 = bind_symbolic_name a 0, %.loc4_16 [symbolic = constants.%a] +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- implicit.impl.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %.1: type = tuple_type () [template] +// CHECK:STDOUT: %a: %.1 = bind_symbolic_name a 0 [symbolic] +// CHECK:STDOUT: %b: %.1 = bind_symbolic_name b 0 [symbolic] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .a = %import_ref +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: } +// CHECK:STDOUT: %import_ref: %.1 = import_ref ir0, inst+4, loaded [symbolic = constants.%a] +// CHECK:STDOUT: %.loc4_10.1: %.1 = tuple_literal () +// CHECK:STDOUT: %.loc4_10.2: type = converted %.loc4_10.1, constants.%.1 [template = constants.%.1] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %a.ref: %.1 = name_ref a, file.%import_ref [symbolic = constants.%a] +// CHECK:STDOUT: %b: %.1 = bind_symbolic_name b 0, %a.ref [symbolic = constants.%b] +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- other.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %.1: type = tuple_type () [template] +// CHECK:STDOUT: %tuple: %.1 = tuple_value () [template] +// CHECK:STDOUT: %a: %.1 = bind_symbolic_name a 0 [symbolic] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .a = @__global_init.%a +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc4_10.1: %.1 = tuple_literal () +// CHECK:STDOUT: %.loc4_10.2: type = converted %.loc4_10.1, constants.%.1 [template = constants.%.1] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc4_15: %.1 = tuple_literal () +// CHECK:STDOUT: %tuple: %.1 = tuple_value () [template = constants.%tuple] +// CHECK:STDOUT: %.loc4_16: %.1 = converted %.loc4_15, %tuple [template = constants.%tuple] +// CHECK:STDOUT: %a: %.1 = bind_symbolic_name a 0, %.loc4_16 [symbolic = constants.%a] +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- import_other.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %.1: type = tuple_type () [template] +// CHECK:STDOUT: %a: %.1 = bind_symbolic_name a 0 [symbolic] +// CHECK:STDOUT: %b: %.1 = bind_symbolic_name b 0 [symbolic] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Other = %Other +// CHECK:STDOUT: .b = @__global_init.%b +// CHECK:STDOUT: } +// CHECK:STDOUT: %Other: = namespace [template] {} +// CHECK:STDOUT: %.loc4_10.1: %.1 = tuple_literal () +// CHECK:STDOUT: %.loc4_10.2: type = converted %.loc4_10.1, constants.%.1 [template = constants.%.1] +// CHECK:STDOUT: %import_ref: %.1 = import_ref ir1, inst+4, loaded [symbolic = constants.%a] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Other.ref: = name_ref Other, file.%Other [template = file.%Other] +// CHECK:STDOUT: %a.ref: %.1 = name_ref a, file.%import_ref [symbolic = constants.%a] +// CHECK:STDOUT: %b: %.1 = bind_symbolic_name b 0, %a.ref [symbolic = constants.%b] +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/let/no_prelude/import_access.carbon b/toolchain/check/testdata/let/no_prelude/import_access.carbon index 5737d877a720..3463f3588ffb 100644 --- a/toolchain/check/testdata/let/no_prelude/import_access.carbon +++ b/toolchain/check/testdata/let/no_prelude/import_access.carbon @@ -63,13 +63,20 @@ let v2: () = Test.v; // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [template] {} +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .v [private] = @__global_init.%v +// CHECK:STDOUT: } // CHECK:STDOUT: %.loc4_17.1: %.1 = tuple_literal () // CHECK:STDOUT: %.loc4_17.2: type = converted %.loc4_17.1, constants.%.1 [template = constants.%.1] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc4_22: %.1 = tuple_literal () // CHECK:STDOUT: %tuple: %.1 = tuple_value () [template = constants.%tuple] // CHECK:STDOUT: %.loc4_23: %.1 = converted %.loc4_22, %tuple [template = constants.%tuple] // CHECK:STDOUT: %v: %.1 = bind_name v, %.loc4_23 +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_todo_def.impl.carbon @@ -79,11 +86,18 @@ let v2: () = Test.v; // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [template] {} +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .v2 = @__global_init.%v2 +// CHECK:STDOUT: } // CHECK:STDOUT: %.loc8_10.1: %.1 = tuple_literal () // CHECK:STDOUT: %.loc8_10.2: type = converted %.loc8_10.1, constants.%.1 [template = constants.%.1] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: // CHECK:STDOUT: %v.ref: = name_ref v, [template = ] // CHECK:STDOUT: %v2: %.1 = bind_name v2, +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_local_def.carbon @@ -93,11 +107,18 @@ let v2: () = Test.v; // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [template] {} +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .v2 = @__global_init.%v2 +// CHECK:STDOUT: } // CHECK:STDOUT: %.loc10_10.1: %.1 = tuple_literal () // CHECK:STDOUT: %.loc10_10.2: type = converted %.loc10_10.1, constants.%.1 [template = constants.%.1] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: // CHECK:STDOUT: %v.ref: = name_ref v, [template = ] // CHECK:STDOUT: %v2: %.1 = bind_name v2, +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_other_def.carbon @@ -109,12 +130,18 @@ let v2: () = Test.v; // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Test = %Test +// CHECK:STDOUT: .v2 = @__global_init.%v2 // CHECK:STDOUT: } // CHECK:STDOUT: %Test: = namespace [template] {} // CHECK:STDOUT: %.loc9_10.1: %.1 = tuple_literal () // CHECK:STDOUT: %.loc9_10.2: type = converted %.loc9_10.1, constants.%.1 [template = constants.%.1] -// CHECK:STDOUT: %Test.ref: = name_ref Test, %Test [template = %Test] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Test.ref: = name_ref Test, file.%Test [template = file.%Test] // CHECK:STDOUT: %v.ref: = name_ref v, [template = ] // CHECK:STDOUT: %v2: %.1 = bind_name v2, +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/operators/builtin/unary_op.carbon b/toolchain/check/testdata/operators/builtin/unary_op.carbon index 7b489902ed93..4bfee58817ef 100644 --- a/toolchain/check/testdata/operators/builtin/unary_op.carbon +++ b/toolchain/check/testdata/operators/builtin/unary_op.carbon @@ -39,6 +39,8 @@ fn Constant() { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .Not = %Not.decl +// CHECK:STDOUT: .not_true = @__global_init.%not_true +// CHECK:STDOUT: .not_false = @__global_init.%not_false // CHECK:STDOUT: .Constant = %Constant.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} @@ -59,16 +61,10 @@ fn Constant() { // CHECK:STDOUT: %bool.make_type.loc15: init type = call constants.%Bool() [template = bool] // CHECK:STDOUT: %.loc15_15.1: type = value_of_initializer %bool.make_type.loc15 [template = bool] // CHECK:STDOUT: %.loc15_15.2: type = converted %bool.make_type.loc15, %.loc15_15.1 [template = bool] -// CHECK:STDOUT: %.loc15_26: bool = bool_literal true [template = constants.%.2] -// CHECK:STDOUT: %.loc15_22: bool = not %.loc15_26 [template = constants.%.3] -// CHECK:STDOUT: %not_true: bool = bind_name not_true, %.loc15_22 // CHECK:STDOUT: %import_ref.4: %Bool.type = import_ref ir7, inst+2, loaded [template = constants.%Bool] // CHECK:STDOUT: %bool.make_type.loc16: init type = call constants.%Bool() [template = bool] // CHECK:STDOUT: %.loc16_16.1: type = value_of_initializer %bool.make_type.loc16 [template = bool] // CHECK:STDOUT: %.loc16_16.2: type = converted %bool.make_type.loc16, %.loc16_16.1 [template = bool] -// CHECK:STDOUT: %.loc16_27: bool = bool_literal false [template = constants.%.3] -// CHECK:STDOUT: %.loc16_23: bool = not %.loc16_27 [template = constants.%.2] -// CHECK:STDOUT: %not_false: bool = bind_name not_false, %.loc16_23 // CHECK:STDOUT: %Constant.decl: %Constant.type = fn_decl @Constant [template = constants.%Constant] {} // CHECK:STDOUT: %import_ref.5: %Bool.type = import_ref ir7, inst+2, loaded [template = constants.%Bool] // CHECK:STDOUT: %import_ref.6: %Bool.type = import_ref ir7, inst+2, loaded [template = constants.%Bool] @@ -132,3 +128,14 @@ fn Constant() { // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc15_26: bool = bool_literal true [template = constants.%.2] +// CHECK:STDOUT: %.loc15_22: bool = not %.loc15_26 [template = constants.%.3] +// CHECK:STDOUT: %not_true: bool = bind_name not_true, %.loc15_22 +// CHECK:STDOUT: %.loc16_27: bool = bool_literal false [template = constants.%.3] +// CHECK:STDOUT: %.loc16_23: bool = not %.loc16_27 [template = constants.%.2] +// CHECK:STDOUT: %not_false: bool = bind_name not_false, %.loc16_23 +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/pointer/fail_deref_error.carbon b/toolchain/check/testdata/pointer/fail_deref_error.carbon index 0e103a80f00e..f18bb432ba6c 100644 --- a/toolchain/check/testdata/pointer/fail_deref_error.carbon +++ b/toolchain/check/testdata/pointer/fail_deref_error.carbon @@ -29,23 +29,30 @@ let n2: i32 = undeclared->foo; // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .n = @__global_init.%n +// CHECK:STDOUT: .n2 = @__global_init.%n2 // CHECK:STDOUT: } // CHECK:STDOUT: %Core: = namespace [template] {} // CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc15: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc15_8.1: type = value_of_initializer %int.make_type_32.loc15 [template = i32] // CHECK:STDOUT: %.loc15_8.2: type = converted %int.make_type_32.loc15, %.loc15_8.1 [template = i32] -// CHECK:STDOUT: %undeclared.ref.loc15: = name_ref undeclared, [template = ] -// CHECK:STDOUT: %.loc15_14: ref = deref -// CHECK:STDOUT: %n: i32 = bind_name n, // CHECK:STDOUT: %import_ref.2: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc19: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc19_9.1: type = value_of_initializer %int.make_type_32.loc19 [template = i32] // CHECK:STDOUT: %.loc19_9.2: type = converted %int.make_type_32.loc19, %.loc19_9.1 [template = i32] -// CHECK:STDOUT: %undeclared.ref.loc19: = name_ref undeclared, [template = ] -// CHECK:STDOUT: %.loc19_25: ref = deref -// CHECK:STDOUT: %n2: i32 = bind_name n2, // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; // CHECK:STDOUT: +// CHECK:STDOUT: fn @__global_init() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %undeclared.ref.loc15: = name_ref undeclared, [template = ] +// CHECK:STDOUT: %.loc15: ref = deref +// CHECK:STDOUT: %n: i32 = bind_name n, +// CHECK:STDOUT: %undeclared.ref.loc19: = name_ref undeclared, [template = ] +// CHECK:STDOUT: %.loc19: ref = deref +// CHECK:STDOUT: %n2: i32 = bind_name n2, +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/struct/fail_duplicate_name.carbon b/toolchain/check/testdata/struct/fail_duplicate_name.carbon index bff1790e4320..a3c35ff6ee4e 100644 --- a/toolchain/check/testdata/struct/fail_duplicate_name.carbon +++ b/toolchain/check/testdata/struct/fail_duplicate_name.carbon @@ -73,6 +73,8 @@ var y: {.b: i32, .c: i32} = {.b = 3, .b = 4}; // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core // CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: .v = @__global_init.%v +// CHECK:STDOUT: .w = @__global_init.%w // CHECK:STDOUT: .x = %x // CHECK:STDOUT: .y = %y // CHECK:STDOUT: } @@ -108,16 +110,10 @@ var y: {.b: i32, .c: i32} = {.b = 3, .b = 4}; // CHECK:STDOUT: %int.make_type_32.loc27_22: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc27_22.1: type = value_of_initializer %int.make_type_32.loc27_22 [template = i32] // CHECK:STDOUT: %.loc27_22.2: type = converted %int.make_type_32.loc27_22, %.loc27_22.1 [template = i32] -// CHECK:STDOUT: %.loc27_35: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc27_36: %.3 = struct_literal (%.loc27_35) -// CHECK:STDOUT: %v: = bind_name v, // CHECK:STDOUT: %import_ref.8: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc36: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc36_8.1: type = value_of_initializer %int.make_type_32.loc36 [template = i32] // CHECK:STDOUT: %.loc36_8.2: type = converted %int.make_type_32.loc36, %.loc36_8.1 [template = i32] -// CHECK:STDOUT: %.loc36_22: i32 = int_literal 1 [template = constants.%.2] -// CHECK:STDOUT: %.loc36_32: i32 = int_literal 2 [template = constants.%.4] -// CHECK:STDOUT: %w: i32 = bind_name w, // CHECK:STDOUT: %import_ref.9: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc45: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc45_13.1: type = value_of_initializer %int.make_type_32.loc45 [template = i32] @@ -144,6 +140,12 @@ var y: {.b: i32, .c: i32} = {.b = 3, .b = 4}; // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { // CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc27_35: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc27_36: %.3 = struct_literal (%.loc27_35) +// CHECK:STDOUT: %v: = bind_name v, +// CHECK:STDOUT: %.loc36_22: i32 = int_literal 1 [template = constants.%.2] +// CHECK:STDOUT: %.loc36_32: i32 = int_literal 2 [template = constants.%.4] +// CHECK:STDOUT: %w: i32 = bind_name w, // CHECK:STDOUT: %.loc45_26: i32 = int_literal 1 [template = constants.%.2] // CHECK:STDOUT: %.loc45_34: i32 = int_literal 2 [template = constants.%.4] // CHECK:STDOUT: assign file.%x.var, diff --git a/toolchain/check/testdata/struct/two_entries.carbon b/toolchain/check/testdata/struct/two_entries.carbon index 91313db3834a..ed0f99851992 100644 --- a/toolchain/check/testdata/struct/two_entries.carbon +++ b/toolchain/check/testdata/struct/two_entries.carbon @@ -30,6 +30,8 @@ var y: {.a: i32, .b: i32} = x; // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .v = @__global_init.%v +// CHECK:STDOUT: .w = @__global_init.%w // CHECK:STDOUT: .x = %x // CHECK:STDOUT: .y = %y // CHECK:STDOUT: } @@ -43,12 +45,6 @@ var y: {.a: i32, .b: i32} = x; // CHECK:STDOUT: %.loc11_22.1: type = value_of_initializer %int.make_type_32.loc11_22 [template = i32] // CHECK:STDOUT: %.loc11_22.2: type = converted %int.make_type_32.loc11_22, %.loc11_22.1 [template = i32] // CHECK:STDOUT: %.loc11_25: type = struct_type {.a: i32, .b: i32} [template = constants.%.2] -// CHECK:STDOUT: %.loc11_35: i32 = int_literal 1 [template = constants.%.4] -// CHECK:STDOUT: %.loc11_43: i32 = int_literal 2 [template = constants.%.5] -// CHECK:STDOUT: %.loc11_44: %.2 = struct_literal (%.loc11_35, %.loc11_43) -// CHECK:STDOUT: %struct: %.2 = struct_value (%.loc11_35, %.loc11_43) [template = constants.%struct] -// CHECK:STDOUT: %.loc11_45: %.2 = converted %.loc11_44, %struct [template = constants.%struct] -// CHECK:STDOUT: %v: %.2 = bind_name v, %.loc11_45 // CHECK:STDOUT: %import_ref.3: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc12_13: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc12_13.1: type = value_of_initializer %int.make_type_32.loc12_13 [template = i32] @@ -58,8 +54,6 @@ var y: {.a: i32, .b: i32} = x; // CHECK:STDOUT: %.loc12_22.1: type = value_of_initializer %int.make_type_32.loc12_22 [template = i32] // CHECK:STDOUT: %.loc12_22.2: type = converted %int.make_type_32.loc12_22, %.loc12_22.1 [template = i32] // CHECK:STDOUT: %.loc12_25: type = struct_type {.a: i32, .b: i32} [template = constants.%.2] -// CHECK:STDOUT: %v.ref: %.2 = name_ref v, %v -// CHECK:STDOUT: %w: %.2 = bind_name w, %v.ref // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc14_13: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %.loc14_13.1: type = value_of_initializer %int.make_type_32.loc14_13 [template = i32] @@ -88,6 +82,14 @@ var y: {.a: i32, .b: i32} = x; // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { // CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc11_35: i32 = int_literal 1 [template = constants.%.4] +// CHECK:STDOUT: %.loc11_43: i32 = int_literal 2 [template = constants.%.5] +// CHECK:STDOUT: %.loc11_44: %.2 = struct_literal (%.loc11_35, %.loc11_43) +// CHECK:STDOUT: %struct: %.2 = struct_value (%.loc11_35, %.loc11_43) [template = constants.%struct] +// CHECK:STDOUT: %.loc11_45: %.2 = converted %.loc11_44, %struct [template = constants.%struct] +// CHECK:STDOUT: %v: %.2 = bind_name v, %.loc11_45 +// CHECK:STDOUT: %v.ref: %.2 = name_ref v, %v +// CHECK:STDOUT: %w: %.2 = bind_name w, %v.ref // CHECK:STDOUT: %.loc14_35: i32 = int_literal 1 [template = constants.%.4] // CHECK:STDOUT: %.loc14_43: i32 = int_literal 2 [template = constants.%.5] // CHECK:STDOUT: %.loc14_44.1: %.2 = struct_literal (%.loc14_35, %.loc14_43) diff --git a/toolchain/check/testdata/tuples/two_elements.carbon b/toolchain/check/testdata/tuples/two_elements.carbon index dcd18f5c2d41..7cbc66dc3e91 100644 --- a/toolchain/check/testdata/tuples/two_elements.carbon +++ b/toolchain/check/testdata/tuples/two_elements.carbon @@ -31,6 +31,8 @@ var y: (i32, i32) = x; // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = %Core +// CHECK:STDOUT: .v = @__global_init.%v +// CHECK:STDOUT: .w = @__global_init.%w // CHECK:STDOUT: .x = %x // CHECK:STDOUT: .y = %y // CHECK:STDOUT: } @@ -45,12 +47,6 @@ var y: (i32, i32) = x; // CHECK:STDOUT: %.loc11_17.4: type = value_of_initializer %int.make_type_32.loc11_14 [template = i32] // CHECK:STDOUT: %.loc11_17.5: type = converted %int.make_type_32.loc11_14, %.loc11_17.4 [template = i32] // CHECK:STDOUT: %.loc11_17.6: type = converted %.loc11_17.1, constants.%.3 [template = constants.%.3] -// CHECK:STDOUT: %.loc11_22: i32 = int_literal 4 [template = constants.%.5] -// CHECK:STDOUT: %.loc11_25: i32 = int_literal 102 [template = constants.%.6] -// CHECK:STDOUT: %.loc11_28: %.3 = tuple_literal (%.loc11_22, %.loc11_25) -// CHECK:STDOUT: %tuple: %.3 = tuple_value (%.loc11_22, %.loc11_25) [template = constants.%tuple] -// CHECK:STDOUT: %.loc11_29: %.3 = converted %.loc11_28, %tuple [template = constants.%tuple] -// CHECK:STDOUT: %v: %.3 = bind_name v, %.loc11_29 // CHECK:STDOUT: %import_ref.3: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc12_9: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %import_ref.4: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -61,8 +57,6 @@ var y: (i32, i32) = x; // CHECK:STDOUT: %.loc12_17.4: type = value_of_initializer %int.make_type_32.loc12_14 [template = i32] // CHECK:STDOUT: %.loc12_17.5: type = converted %int.make_type_32.loc12_14, %.loc12_17.4 [template = i32] // CHECK:STDOUT: %.loc12_17.6: type = converted %.loc12_17.1, constants.%.3 [template = constants.%.3] -// CHECK:STDOUT: %v.ref: %.3 = name_ref v, %v -// CHECK:STDOUT: %w: %.3 = bind_name w, %v.ref // CHECK:STDOUT: %import_ref.5: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] // CHECK:STDOUT: %int.make_type_32.loc14_9: init type = call constants.%Int32() [template = i32] // CHECK:STDOUT: %import_ref.6: %Int32.type = import_ref ir3, inst+3, loaded [template = constants.%Int32] @@ -93,6 +87,14 @@ var y: (i32, i32) = x; // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { // CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc11_22: i32 = int_literal 4 [template = constants.%.5] +// CHECK:STDOUT: %.loc11_25: i32 = int_literal 102 [template = constants.%.6] +// CHECK:STDOUT: %.loc11_28: %.3 = tuple_literal (%.loc11_22, %.loc11_25) +// CHECK:STDOUT: %tuple: %.3 = tuple_value (%.loc11_22, %.loc11_25) [template = constants.%tuple] +// CHECK:STDOUT: %.loc11_29: %.3 = converted %.loc11_28, %tuple [template = constants.%tuple] +// CHECK:STDOUT: %v: %.3 = bind_name v, %.loc11_29 +// CHECK:STDOUT: %v.ref: %.3 = name_ref v, %v +// CHECK:STDOUT: %w: %.3 = bind_name w, %v.ref // CHECK:STDOUT: %.loc14_22: i32 = int_literal 4 [template = constants.%.5] // CHECK:STDOUT: %.loc14_25: i32 = int_literal 102 [template = constants.%.6] // CHECK:STDOUT: %.loc14_28.1: %.3 = tuple_literal (%.loc14_22, %.loc14_25)