Add GlobalInit to blocks to emit initialization instructions for globals (#3687)

`GlobalInit` block is now static block within a `SemIR` which will be
used to emit initialization instructions for variables in the `Package`
scope.

inst_block_stack now has additional methods to handle `GlobalInit` block
separately, this block can be popped without being finalized allowing to
accumulate between all instances of variables.

At the end of the `check` phase, if this block is not empty , the
function `__global_init` will be added with this block being inserted
into it.

This block is pushed to `inst_block_scope` at the end `BindName`,
allowing instruction to be emitted into it, then popped at the semicolon
(VariableDecl).

This significantly changes the `SemIR` output, that's why this commit
updates a lot of the test cases.

toolchain/check/check.cpp

@@ -262,6 +262,7 @@ static auto CheckParseTree(
   sem_ir.set_top_inst_block_id(context.inst_block_stack().Pop());
   context.scope_stack().Pop();
   context.FinalizeExports();
+  context.FinalizeGlobalInit();
 
   context.VerifyOnFinish();
 

toolchain/check/context.cpp

@@ -502,6 +502,28 @@ auto Context::ParamOrArgEnd(Parse::NodeKind start_kind) -> SemIR::InstBlockId {
   return ParamOrArgPop();
 }
 
+auto Context::FinalizeGlobalInit() -> void {
+  inst_block_stack().PushGlobalInit();
+  if (!inst_block_stack().PeekCurrentBlockContents().empty()) {
+    AddInst({Parse::NodeId::Invalid, SemIR::Return{}});
+    // Pop the GlobalInit block here to finalize it.
+    inst_block_stack().Pop();
+
+    // __global_init is only added if there are initialization instructions.
+    auto name_id = sem_ir().identifiers().Add("__global_init");
+    sem_ir().functions().Add(
+        {.name_id = SemIR::NameId::ForIdentifier(name_id),
+         .enclosing_scope_id = SemIR::NameScopeId::Package,
+         .implicit_param_refs_id = SemIR::InstBlockId::Empty,
+         .param_refs_id = SemIR::InstBlockId::Empty,
+         .return_type_id = SemIR::TypeId::Invalid,
+         .return_slot_id = SemIR::InstId::Invalid,
+         .body_block_ids = {SemIR::InstBlockId::GlobalInit}});
+  } else {
+    inst_block_stack().PopGlobalInit();
+  }
+}
+
 namespace {
 // Worklist-based type completion mechanism.
 //

toolchain/check/context.h

@@ -294,6 +294,9 @@ class Context {
     inst_blocks().Set(SemIR::InstBlockId::Exports, exports_);
   }
 
+  // Finalizes the initialization function (__global_init).
+  auto FinalizeGlobalInit() -> void;
+
   // Prints information for a stack dump.
   auto PrintForStackDump(llvm::raw_ostream& output) const -> void;
 

toolchain/check/handle_binding_pattern.cpp

@@ -116,6 +116,9 @@ auto HandleAnyBindingPattern(Context& context, Parse::NodeId parse_node,
       if (context_parse_node_kind == Parse::NodeKind::ReturnedModifier) {
         RegisterReturnedVar(context, bind_id);
       }
+      if (context.scope_stack().PeekIndex() == ScopeIndex::Package) {
+        context.inst_block_stack().PushGlobalInit();
+      }
       break;
     }
 

toolchain/check/handle_variable.cpp

@@ -95,6 +95,9 @@ auto HandleVariableDecl(Context& context, Parse::VariableDeclId parse_node)
   }
 
   context.decl_state_stack().Pop(DeclState::Var);
+  if (context.scope_stack().PeekIndex() == ScopeIndex::Package) {
+    context.inst_block_stack().PopGlobalInit();
+  }
 
   return true;
 }

toolchain/check/inst_block_stack.cpp

@@ -21,6 +21,11 @@ auto InstBlockStack::Push(SemIR::InstBlockId id) -> void {
   ++size_;
 }
 
+auto InstBlockStack::PushGlobalInit() -> void {
+  Push(SemIR::InstBlockId::GlobalInit);
+  stack_[size_ - 1].content = std::move(init_block_);
+}
+
 auto InstBlockStack::PeekOrAdd(int depth) -> SemIR::InstBlockId {
   CARBON_CHECK(size() > depth) << "no such block";
   int index = size() - depth - 1;
@@ -52,6 +57,14 @@ auto InstBlockStack::Pop() -> SemIR::InstBlockId {
   return back.id;
 }
 
+auto InstBlockStack::PopGlobalInit() -> void {
+  CARBON_CHECK(stack_[size_ - 1].id == SemIR::InstBlockId::GlobalInit)
+      << "Trying to pop Inits block from " << name_
+      << " but a different block is present!";
+  init_block_ = std::move(stack_[size_ - 1].content);
+  PopAndDiscard();
+}
+
 auto InstBlockStack::PopAndDiscard() -> void {
   CARBON_CHECK(!empty()) << "no current block";
   --size_;

toolchain/check/inst_block_stack.h

@@ -29,6 +29,13 @@ class InstBlockStack {
   // called in order to support lazy allocation.
   auto Push() -> void { Push(SemIR::InstBlockId::Invalid); }
 
+  // Pushes the `GlobalInit` inst block onto the stack, this block is handled
+  // separately from the rest.
+  // This method shall be used in conjunction with `PopGlobalInit` method to
+  // allow emitting initialization instructions to `GlobalInit` block from
+  // separate parts of the tree, accumulating them all in one block.
+  auto PushGlobalInit() -> void;
+
   // Pushes a new unreachable code block.
   auto PushUnreachable() -> void { Push(SemIR::InstBlockId::Unreachable); }
 
@@ -46,6 +53,11 @@ class InstBlockStack {
   // allocated.
   auto PopAndDiscard() -> void;
 
+  // Pops the `GlobalInit` inst block from the stack without finalizing it.
+  // `Pop` should be called at the end of the check phase, while `GlobalInit`
+  // is pushed, to finalize the block.
+  auto PopGlobalInit() -> void;
+
   // Adds the given instruction ID to the block at the top of the stack.
   auto AddInstId(SemIR::InstId inst_id) -> void {
     CARBON_CHECK(!empty()) << "no current block";
@@ -100,6 +112,8 @@ class InstBlockStack {
   // Whether to print verbose output.
   llvm::raw_ostream* vlog_stream_;
 
+  std::vector<SemIR::InstId> init_block_;
+
   // The actual stack.
   llvm::SmallVector<StackEntry> stack_;
 

toolchain/check/testdata/array/assign_var.carbon

@@ -30,41 +30,46 @@ var b: [i32; 3] = a;
 // CHECK:STDOUT:   %.loc7_22.2: type = converted %.loc7_22.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref (i32, i32, i32) = var a
 // CHECK:STDOUT:   %a: ref (i32, i32, i32) = bind_name a, %a.var
+// CHECK:STDOUT:   %.loc8_14: i32 = int_literal 3 [template = constants.%.6]
+// CHECK:STDOUT:   %.loc8_15: type = array_type %.loc8_14, i32 [template = constants.%.8]
+// CHECK:STDOUT:   %b.var: ref [i32; 3] = var b
+// CHECK:STDOUT:   %b: ref [i32; 3] = bind_name b, %b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_27: i32 = int_literal 1 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_30: i32 = int_literal 2 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_33: i32 = int_literal 3 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc7_34.1: (i32, i32, i32) = tuple_literal (%.loc7_27, %.loc7_30, %.loc7_33)
-// CHECK:STDOUT:   %.loc7_34.2: ref i32 = tuple_access %a.var, element0
+// CHECK:STDOUT:   %.loc7_34.2: ref i32 = tuple_access file.%a.var, element0
 // CHECK:STDOUT:   %.loc7_34.3: init i32 = initialize_from %.loc7_27 to %.loc7_34.2 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_34.4: ref i32 = tuple_access %a.var, element1
+// CHECK:STDOUT:   %.loc7_34.4: ref i32 = tuple_access file.%a.var, element1
 // CHECK:STDOUT:   %.loc7_34.5: init i32 = initialize_from %.loc7_30 to %.loc7_34.4 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc7_34.6: ref i32 = tuple_access %a.var, element2
+// CHECK:STDOUT:   %.loc7_34.6: ref i32 = tuple_access file.%a.var, element2
 // CHECK:STDOUT:   %.loc7_34.7: init i32 = initialize_from %.loc7_33 to %.loc7_34.6 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc7_34.8: init (i32, i32, i32) = tuple_init (%.loc7_34.3, %.loc7_34.5, %.loc7_34.7) to %a.var [template = constants.%.7]
+// CHECK:STDOUT:   %.loc7_34.8: init (i32, i32, i32) = tuple_init (%.loc7_34.3, %.loc7_34.5, %.loc7_34.7) to file.%a.var [template = constants.%.7]
 // CHECK:STDOUT:   %.loc7_34.9: init (i32, i32, i32) = converted %.loc7_34.1, %.loc7_34.8 [template = constants.%.7]
-// CHECK:STDOUT:   assign %a.var, %.loc7_34.9
-// CHECK:STDOUT:   %.loc8_14: i32 = int_literal 3 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc8_15: type = array_type %.loc8_14, i32 [template = constants.%.8]
-// CHECK:STDOUT:   %b.var: ref [i32; 3] = var b
-// CHECK:STDOUT:   %b: ref [i32; 3] = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref (i32, i32, i32) = name_ref a, %a
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_34.9
+// CHECK:STDOUT:   %a.ref: ref (i32, i32, i32) = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc8_19.1: ref i32 = tuple_access %a.ref, element0
 // CHECK:STDOUT:   %.loc8_19.2: i32 = bind_value %.loc8_19.1
 // CHECK:STDOUT:   %.loc8_19.3: i32 = int_literal 0 [template = constants.%.10]
-// CHECK:STDOUT:   %.loc8_19.4: ref i32 = array_index %b.var, %.loc8_19.3
+// CHECK:STDOUT:   %.loc8_19.4: ref i32 = array_index file.%b.var, %.loc8_19.3
 // CHECK:STDOUT:   %.loc8_19.5: init i32 = initialize_from %.loc8_19.2 to %.loc8_19.4
 // CHECK:STDOUT:   %.loc8_19.6: ref i32 = tuple_access %a.ref, element1
 // CHECK:STDOUT:   %.loc8_19.7: i32 = bind_value %.loc8_19.6
 // CHECK:STDOUT:   %.loc8_19.8: i32 = int_literal 1 [template = constants.%.11]
-// CHECK:STDOUT:   %.loc8_19.9: ref i32 = array_index %b.var, %.loc8_19.8
+// CHECK:STDOUT:   %.loc8_19.9: ref i32 = array_index file.%b.var, %.loc8_19.8
 // CHECK:STDOUT:   %.loc8_19.10: init i32 = initialize_from %.loc8_19.7 to %.loc8_19.9
 // CHECK:STDOUT:   %.loc8_19.11: ref i32 = tuple_access %a.ref, element2
 // CHECK:STDOUT:   %.loc8_19.12: i32 = bind_value %.loc8_19.11
 // CHECK:STDOUT:   %.loc8_19.13: i32 = int_literal 2 [template = constants.%.12]
-// CHECK:STDOUT:   %.loc8_19.14: ref i32 = array_index %b.var, %.loc8_19.13
+// CHECK:STDOUT:   %.loc8_19.14: ref i32 = array_index file.%b.var, %.loc8_19.13
 // CHECK:STDOUT:   %.loc8_19.15: init i32 = initialize_from %.loc8_19.12 to %.loc8_19.14
-// CHECK:STDOUT:   %.loc8_19.16: init [i32; 3] = array_init (%.loc8_19.5, %.loc8_19.10, %.loc8_19.15) to %b.var
+// CHECK:STDOUT:   %.loc8_19.16: init [i32; 3] = array_init (%.loc8_19.5, %.loc8_19.10, %.loc8_19.15) to file.%b.var
 // CHECK:STDOUT:   %.loc8_19.17: init [i32; 3] = converted %a.ref, %.loc8_19.16
-// CHECK:STDOUT:   assign %b.var, %.loc8_19.17
+// CHECK:STDOUT:   assign file.%b.var, %.loc8_19.17
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/array/base.carbon

@@ -43,36 +43,40 @@ var c: [(); 5] = ((), (), (), (), (),);
 // CHECK:STDOUT:   %.loc7_15: type = array_type %.loc7_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref [i32; 1] = var a
 // CHECK:STDOUT:   %a: ref [i32; 1] = bind_name a, %a.var
+// CHECK:STDOUT:   %.loc8_14: i32 = int_literal 2 [template = constants.%.7]
+// CHECK:STDOUT:   %.loc8_15: type = array_type %.loc8_14, f64 [template = constants.%.8]
+// CHECK:STDOUT:   %b.var: ref [f64; 2] = var b
+// CHECK:STDOUT:   %b: ref [f64; 2] = bind_name b, %b.var
+// CHECK:STDOUT:   %.loc9_10.1: () = tuple_literal ()
+// CHECK:STDOUT:   %.loc9_13: i32 = int_literal 5 [template = constants.%.16]
+// CHECK:STDOUT:   %.loc9_10.2: type = converted %.loc9_10.1, constants.%.15 [template = constants.%.15]
+// CHECK:STDOUT:   %.loc9_14: type = array_type %.loc9_13, () [template = constants.%.17]
+// CHECK:STDOUT:   %c.var: ref [(); 5] = var c
+// CHECK:STDOUT:   %c: ref [(); 5] = bind_name c, %c.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 1 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc7_22.1: (i32,) = tuple_literal (%.loc7_20)
 // CHECK:STDOUT:   %.loc7_22.2: i32 = int_literal 0 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc7_22.3: ref i32 = array_index %a.var, %.loc7_22.2
+// CHECK:STDOUT:   %.loc7_22.3: ref i32 = array_index file.%a.var, %.loc7_22.2
 // CHECK:STDOUT:   %.loc7_22.4: init i32 = initialize_from %.loc7_20 to %.loc7_22.3 [template = constants.%.1]
-// CHECK:STDOUT:   %.loc7_22.5: init [i32; 1] = array_init (%.loc7_22.4) to %a.var [template = constants.%.6]
+// CHECK:STDOUT:   %.loc7_22.5: init [i32; 1] = array_init (%.loc7_22.4) to file.%a.var [template = constants.%.6]
 // CHECK:STDOUT:   %.loc7_22.6: init [i32; 1] = converted %.loc7_22.1, %.loc7_22.5 [template = constants.%.6]
-// CHECK:STDOUT:   assign %a.var, %.loc7_22.6
-// CHECK:STDOUT:   %.loc8_14: i32 = int_literal 2 [template = constants.%.7]
-// CHECK:STDOUT:   %.loc8_15: type = array_type %.loc8_14, f64 [template = constants.%.8]
-// CHECK:STDOUT:   %b.var: ref [f64; 2] = var b
-// CHECK:STDOUT:   %b: ref [f64; 2] = bind_name b, %b.var
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_22.6
 // CHECK:STDOUT:   %.loc8_20: f64 = real_literal 111e-1 [template = constants.%.10]
 // CHECK:STDOUT:   %.loc8_26: f64 = real_literal 22e-1 [template = constants.%.11]
 // CHECK:STDOUT:   %.loc8_30.1: (f64, f64) = tuple_literal (%.loc8_20, %.loc8_26)
 // CHECK:STDOUT:   %.loc8_30.2: i32 = int_literal 0 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc8_30.3: ref f64 = array_index %b.var, %.loc8_30.2
+// CHECK:STDOUT:   %.loc8_30.3: ref f64 = array_index file.%b.var, %.loc8_30.2
 // CHECK:STDOUT:   %.loc8_30.4: init f64 = initialize_from %.loc8_20 to %.loc8_30.3 [template = constants.%.10]
 // CHECK:STDOUT:   %.loc8_30.5: i32 = int_literal 1 [template = constants.%.13]
-// CHECK:STDOUT:   %.loc8_30.6: ref f64 = array_index %b.var, %.loc8_30.5
+// CHECK:STDOUT:   %.loc8_30.6: ref f64 = array_index file.%b.var, %.loc8_30.5
 // CHECK:STDOUT:   %.loc8_30.7: init f64 = initialize_from %.loc8_26 to %.loc8_30.6 [template = constants.%.11]
-// CHECK:STDOUT:   %.loc8_30.8: init [f64; 2] = array_init (%.loc8_30.4, %.loc8_30.7) to %b.var [template = constants.%.14]
+// CHECK:STDOUT:   %.loc8_30.8: init [f64; 2] = array_init (%.loc8_30.4, %.loc8_30.7) to file.%b.var [template = constants.%.14]
 // CHECK:STDOUT:   %.loc8_30.9: init [f64; 2] = converted %.loc8_30.1, %.loc8_30.8 [template = constants.%.14]
-// CHECK:STDOUT:   assign %b.var, %.loc8_30.9
-// CHECK:STDOUT:   %.loc9_10.1: () = tuple_literal ()
-// CHECK:STDOUT:   %.loc9_13: i32 = int_literal 5 [template = constants.%.16]
-// CHECK:STDOUT:   %.loc9_10.2: type = converted %.loc9_10.1, constants.%.15 [template = constants.%.15]
-// CHECK:STDOUT:   %.loc9_14: type = array_type %.loc9_13, () [template = constants.%.17]
-// CHECK:STDOUT:   %c.var: ref [(); 5] = var c
-// CHECK:STDOUT:   %c: ref [(); 5] = bind_name c, %c.var
+// CHECK:STDOUT:   assign file.%b.var, %.loc8_30.9
 // CHECK:STDOUT:   %.loc9_20.1: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc9_24.1: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc9_28.1: () = tuple_literal ()
@@ -80,27 +84,28 @@ var c: [(); 5] = ((), (), (), (), (),);
 // CHECK:STDOUT:   %.loc9_36.1: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc9_38.1: ((), (), (), (), ()) = tuple_literal (%.loc9_20.1, %.loc9_24.1, %.loc9_28.1, %.loc9_32.1, %.loc9_36.1)
 // CHECK:STDOUT:   %.loc9_38.2: i32 = int_literal 0 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc9_38.3: ref () = array_index %c.var, %.loc9_38.2
+// CHECK:STDOUT:   %.loc9_38.3: ref () = array_index file.%c.var, %.loc9_38.2
 // CHECK:STDOUT:   %.loc9_20.2: init () = tuple_init () to %.loc9_38.3 [template = constants.%.20]
 // CHECK:STDOUT:   %.loc9_20.3: init () = converted %.loc9_20.1, %.loc9_20.2 [template = constants.%.20]
 // CHECK:STDOUT:   %.loc9_38.4: i32 = int_literal 1 [template = constants.%.13]
-// CHECK:STDOUT:   %.loc9_38.5: ref () = array_index %c.var, %.loc9_38.4
+// CHECK:STDOUT:   %.loc9_38.5: ref () = array_index file.%c.var, %.loc9_38.4
 // CHECK:STDOUT:   %.loc9_24.2: init () = tuple_init () to %.loc9_38.5 [template = constants.%.20]
 // CHECK:STDOUT:   %.loc9_24.3: init () = converted %.loc9_24.1, %.loc9_24.2 [template = constants.%.20]
 // CHECK:STDOUT:   %.loc9_38.6: i32 = int_literal 2 [template = constants.%.21]
-// CHECK:STDOUT:   %.loc9_38.7: ref () = array_index %c.var, %.loc9_38.6
+// CHECK:STDOUT:   %.loc9_38.7: ref () = array_index file.%c.var, %.loc9_38.6
 // CHECK:STDOUT:   %.loc9_28.2: init () = tuple_init () to %.loc9_38.7 [template = constants.%.20]
 // CHECK:STDOUT:   %.loc9_28.3: init () = converted %.loc9_28.1, %.loc9_28.2 [template = constants.%.20]
 // CHECK:STDOUT:   %.loc9_38.8: i32 = int_literal 3 [template = constants.%.22]
-// CHECK:STDOUT:   %.loc9_38.9: ref () = array_index %c.var, %.loc9_38.8
+// CHECK:STDOUT:   %.loc9_38.9: ref () = array_index file.%c.var, %.loc9_38.8
 // CHECK:STDOUT:   %.loc9_32.2: init () = tuple_init () to %.loc9_38.9 [template = constants.%.20]
 // CHECK:STDOUT:   %.loc9_32.3: init () = converted %.loc9_32.1, %.loc9_32.2 [template = constants.%.20]
 // CHECK:STDOUT:   %.loc9_38.10: i32 = int_literal 4 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc9_38.11: ref () = array_index %c.var, %.loc9_38.10
+// CHECK:STDOUT:   %.loc9_38.11: ref () = array_index file.%c.var, %.loc9_38.10
 // CHECK:STDOUT:   %.loc9_36.2: init () = tuple_init () to %.loc9_38.11 [template = constants.%.20]
 // CHECK:STDOUT:   %.loc9_36.3: init () = converted %.loc9_36.1, %.loc9_36.2 [template = constants.%.20]
-// CHECK:STDOUT:   %.loc9_38.12: init [(); 5] = array_init (%.loc9_20.3, %.loc9_24.3, %.loc9_28.3, %.loc9_32.3, %.loc9_36.3) to %c.var [template = constants.%.24]
+// CHECK:STDOUT:   %.loc9_38.12: init [(); 5] = array_init (%.loc9_20.3, %.loc9_24.3, %.loc9_28.3, %.loc9_32.3, %.loc9_36.3) to file.%c.var [template = constants.%.24]
 // CHECK:STDOUT:   %.loc9_38.13: init [(); 5] = converted %.loc9_38.1, %.loc9_38.12 [template = constants.%.24]
-// CHECK:STDOUT:   assign %c.var, %.loc9_38.13
+// CHECK:STDOUT:   assign file.%c.var, %.loc9_38.13
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/array/fail_incomplete_element.carbon

@@ -35,14 +35,19 @@ var p: Incomplete* = &a[0];
 // CHECK:STDOUT:   %a.var: ref <error> = var a
 // CHECK:STDOUT:   %a: ref <error> = bind_name a, %a.var
 // CHECK:STDOUT:   %Incomplete.ref.loc17: type = name_ref Incomplete, constants.%Incomplete [template = constants.%Incomplete]
-// CHECK:STDOUT:   %.loc17_18: type = ptr_type Incomplete [template = constants.%.3]
+// CHECK:STDOUT:   %.loc17: type = ptr_type Incomplete [template = constants.%.3]
 // CHECK:STDOUT:   %p.var: ref Incomplete* = var p
 // CHECK:STDOUT:   %p: ref Incomplete* = bind_name p, %p.var
-// CHECK:STDOUT:   %a.ref: ref <error> = name_ref a, %a
-// CHECK:STDOUT:   %.loc17_25: i32 = int_literal 0 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc17_22: <error> = addr_of <error> [template = <error>]
-// CHECK:STDOUT:   assign %p.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: class @Incomplete;
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %a.ref: ref <error> = name_ref a, file.%a
+// CHECK:STDOUT:   %.loc17_25: i32 = int_literal 0 [template = constants.%.4]
+// CHECK:STDOUT:   %.loc17_22: <error> = addr_of <error> [template = <error>]
+// CHECK:STDOUT:   assign file.%p.var, <error>
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/array/fail_out_of_bound.carbon

@@ -26,10 +26,15 @@ var a: [i32; 1] = (1, 2, 3);
 // CHECK:STDOUT:   %.loc10_15: type = array_type %.loc10_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref [i32; 1] = var a
 // CHECK:STDOUT:   %a: ref [i32; 1] = bind_name a, %a.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_20: i32 = int_literal 1 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc10_23: i32 = int_literal 2 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc10_26: i32 = int_literal 3 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc10_27: (i32, i32, i32) = tuple_literal (%.loc10_20, %.loc10_23, %.loc10_26)
-// CHECK:STDOUT:   assign %a.var, <error>
+// CHECK:STDOUT:   assign file.%a.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/array/fail_out_of_bound_non_literal.carbon

@@ -33,25 +33,29 @@ var b: i32 = a[{.index = 3}.index];
 // CHECK:STDOUT:   %.loc7_15: type = array_type %.loc7_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref [i32; 3] = var a
 // CHECK:STDOUT:   %a: ref [i32; 3] = bind_name a, %a.var
+// CHECK:STDOUT:   %b.var: ref i32 = var b
+// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 1 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_23: i32 = int_literal 2 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 3 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc7_27.1: (i32, i32, i32) = tuple_literal (%.loc7_20, %.loc7_23, %.loc7_26)
 // CHECK:STDOUT:   %.loc7_27.2: i32 = int_literal 0 [template = constants.%.7]
-// CHECK:STDOUT:   %.loc7_27.3: ref i32 = array_index %a.var, %.loc7_27.2
+// CHECK:STDOUT:   %.loc7_27.3: ref i32 = array_index file.%a.var, %.loc7_27.2
 // CHECK:STDOUT:   %.loc7_27.4: init i32 = initialize_from %.loc7_20 to %.loc7_27.3 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_27.5: i32 = int_literal 1 [template = constants.%.8]
-// CHECK:STDOUT:   %.loc7_27.6: ref i32 = array_index %a.var, %.loc7_27.5
+// CHECK:STDOUT:   %.loc7_27.6: ref i32 = array_index file.%a.var, %.loc7_27.5
 // CHECK:STDOUT:   %.loc7_27.7: init i32 = initialize_from %.loc7_23 to %.loc7_27.6 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_27.8: i32 = int_literal 2 [template = constants.%.9]
-// CHECK:STDOUT:   %.loc7_27.9: ref i32 = array_index %a.var, %.loc7_27.8
+// CHECK:STDOUT:   %.loc7_27.9: ref i32 = array_index file.%a.var, %.loc7_27.8
 // CHECK:STDOUT:   %.loc7_27.10: init i32 = initialize_from %.loc7_26 to %.loc7_27.9 [template = constants.%.1]
-// CHECK:STDOUT:   %.loc7_27.11: init [i32; 3] = array_init (%.loc7_27.4, %.loc7_27.7, %.loc7_27.10) to %a.var [template = constants.%.10]
+// CHECK:STDOUT:   %.loc7_27.11: init [i32; 3] = array_init (%.loc7_27.4, %.loc7_27.7, %.loc7_27.10) to file.%a.var [template = constants.%.10]
 // CHECK:STDOUT:   %.loc7_27.12: init [i32; 3] = converted %.loc7_27.1, %.loc7_27.11 [template = constants.%.10]
-// CHECK:STDOUT:   assign %a.var, %.loc7_27.12
-// CHECK:STDOUT:   %b.var: ref i32 = var b
-// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref [i32; 3] = name_ref a, %a
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_27.12
+// CHECK:STDOUT:   %a.ref: ref [i32; 3] = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc11_26: i32 = int_literal 3 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc11_27.1: {.index: i32} = struct_literal (%.loc11_26)
 // CHECK:STDOUT:   %.loc11_27.2: {.index: i32} = struct_value (%.loc11_26) [template = constants.%.12]
@@ -59,6 +63,7 @@ var b: i32 = a[{.index = 3}.index];
 // CHECK:STDOUT:   %.loc11_28: i32 = struct_access %.loc11_27.3, element0 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc11_34.1: ref i32 = array_index %a.ref, %.loc11_28 [template = <error>]
 // CHECK:STDOUT:   %.loc11_34.2: i32 = bind_value %.loc11_34.1
-// CHECK:STDOUT:   assign %b.var, %.loc11_34.2
+// CHECK:STDOUT:   assign file.%b.var, %.loc11_34.2
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/array/fail_type_mismatch.carbon

@@ -54,14 +54,6 @@ var d: [i32; 3] = t2;
 // CHECK:STDOUT:   %.loc10_15: type = array_type %.loc10_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref [i32; 3] = var a
 // CHECK:STDOUT:   %a: ref [i32; 3] = bind_name a, %a.var
-// CHECK:STDOUT:   %.loc10_20: i32 = int_literal 1 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc10_23: String = string_literal "Hello" [template = constants.%.6]
-// CHECK:STDOUT:   %.loc10_32: String = string_literal "World" [template = constants.%.7]
-// CHECK:STDOUT:   %.loc10_39.1: (i32, String, String) = tuple_literal (%.loc10_20, %.loc10_23, %.loc10_32)
-// CHECK:STDOUT:   %.loc10_39.2: i32 = int_literal 0 [template = constants.%.9]
-// CHECK:STDOUT:   %.loc10_39.3: ref i32 = array_index %a.var, %.loc10_39.2
-// CHECK:STDOUT:   %.loc10_39.4: init i32 = initialize_from %.loc10_20 to %.loc10_39.3 [template = constants.%.4]
-// CHECK:STDOUT:   assign %a.var, <error>
 // CHECK:STDOUT:   %.loc12_29.1: (type, type, type) = tuple_literal (i32, String, String)
 // CHECK:STDOUT:   %.loc12_29.2: type = converted %.loc12_29.1, constants.%.8 [template = constants.%.8]
 // CHECK:STDOUT:   %t1.var: ref (i32, String, String) = var t1
@@ -70,22 +62,10 @@ var d: [i32; 3] = t2;
 // CHECK:STDOUT:   %.loc16_15: type = array_type %.loc16_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %b.var: ref [i32; 3] = var b
 // CHECK:STDOUT:   %b: ref [i32; 3] = bind_name b, %b.var
-// CHECK:STDOUT:   %t1.ref: ref (i32, String, String) = name_ref t1, %t1
-// CHECK:STDOUT:   %.loc16_19.1: ref i32 = tuple_access %t1.ref, element0
-// CHECK:STDOUT:   %.loc16_19.2: i32 = bind_value %.loc16_19.1
-// CHECK:STDOUT:   %.loc16_19.3: i32 = int_literal 0 [template = constants.%.9]
-// CHECK:STDOUT:   %.loc16_19.4: ref i32 = array_index %b.var, %.loc16_19.3
-// CHECK:STDOUT:   %.loc16_19.5: init i32 = initialize_from %.loc16_19.2 to %.loc16_19.4
-// CHECK:STDOUT:   %.loc16_19.6: ref String = tuple_access %t1.ref, element1
-// CHECK:STDOUT:   assign %b.var, <error>
 // CHECK:STDOUT:   %.loc21_14: i32 = int_literal 3 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc21_15: type = array_type %.loc21_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %c.var: ref [i32; 3] = var c
 // CHECK:STDOUT:   %c: ref [i32; 3] = bind_name c, %c.var
-// CHECK:STDOUT:   %.loc21_20: i32 = int_literal 1 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc21_23: i32 = int_literal 2 [template = constants.%.14]
-// CHECK:STDOUT:   %.loc21_24: (i32, i32) = tuple_literal (%.loc21_20, %.loc21_23)
-// CHECK:STDOUT:   assign %c.var, <error>
 // CHECK:STDOUT:   %.loc23_18.1: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc23_18.2: type = converted %.loc23_18.1, constants.%.15 [template = constants.%.15]
 // CHECK:STDOUT:   %t2.var: ref (i32, i32) = var t2
@@ -94,7 +74,32 @@ var d: [i32; 3] = t2;
 // CHECK:STDOUT:   %.loc27_15: type = array_type %.loc27_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %d.var: ref [i32; 3] = var d
 // CHECK:STDOUT:   %d: ref [i32; 3] = bind_name d, %d.var
-// CHECK:STDOUT:   %t2.ref: ref (i32, i32) = name_ref t2, %t2
-// CHECK:STDOUT:   assign %d.var, <error>
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc10_20: i32 = int_literal 1 [template = constants.%.4]
+// CHECK:STDOUT:   %.loc10_23: String = string_literal "Hello" [template = constants.%.6]
+// CHECK:STDOUT:   %.loc10_32: String = string_literal "World" [template = constants.%.7]
+// CHECK:STDOUT:   %.loc10_39.1: (i32, String, String) = tuple_literal (%.loc10_20, %.loc10_23, %.loc10_32)
+// CHECK:STDOUT:   %.loc10_39.2: i32 = int_literal 0 [template = constants.%.9]
+// CHECK:STDOUT:   %.loc10_39.3: ref i32 = array_index file.%a.var, %.loc10_39.2
+// CHECK:STDOUT:   %.loc10_39.4: init i32 = initialize_from %.loc10_20 to %.loc10_39.3 [template = constants.%.4]
+// CHECK:STDOUT:   assign file.%a.var, <error>
+// CHECK:STDOUT:   %t1.ref: ref (i32, String, String) = name_ref t1, file.%t1
+// CHECK:STDOUT:   %.loc16_19.1: ref i32 = tuple_access %t1.ref, element0
+// CHECK:STDOUT:   %.loc16_19.2: i32 = bind_value %.loc16_19.1
+// CHECK:STDOUT:   %.loc16_19.3: i32 = int_literal 0 [template = constants.%.9]
+// CHECK:STDOUT:   %.loc16_19.4: ref i32 = array_index file.%b.var, %.loc16_19.3
+// CHECK:STDOUT:   %.loc16_19.5: init i32 = initialize_from %.loc16_19.2 to %.loc16_19.4
+// CHECK:STDOUT:   %.loc16_19.6: ref String = tuple_access %t1.ref, element1
+// CHECK:STDOUT:   assign file.%b.var, <error>
+// CHECK:STDOUT:   %.loc21_20: i32 = int_literal 1 [template = constants.%.4]
+// CHECK:STDOUT:   %.loc21_23: i32 = int_literal 2 [template = constants.%.14]
+// CHECK:STDOUT:   %.loc21_24: (i32, i32) = tuple_literal (%.loc21_20, %.loc21_23)
+// CHECK:STDOUT:   assign file.%c.var, <error>
+// CHECK:STDOUT:   %t2.ref: ref (i32, i32) = name_ref t2, file.%t2
+// CHECK:STDOUT:   assign file.%d.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/array/index_not_literal.carbon

@@ -30,25 +30,29 @@ var b: i32 = a[{.index = 2}.index];
 // CHECK:STDOUT:   %.loc7_15: type = array_type %.loc7_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref [i32; 3] = var a
 // CHECK:STDOUT:   %a: ref [i32; 3] = bind_name a, %a.var
+// CHECK:STDOUT:   %b.var: ref i32 = var b
+// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 1 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_23: i32 = int_literal 2 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 3 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc7_27.1: (i32, i32, i32) = tuple_literal (%.loc7_20, %.loc7_23, %.loc7_26)
 // CHECK:STDOUT:   %.loc7_27.2: i32 = int_literal 0 [template = constants.%.7]
-// CHECK:STDOUT:   %.loc7_27.3: ref i32 = array_index %a.var, %.loc7_27.2
+// CHECK:STDOUT:   %.loc7_27.3: ref i32 = array_index file.%a.var, %.loc7_27.2
 // CHECK:STDOUT:   %.loc7_27.4: init i32 = initialize_from %.loc7_20 to %.loc7_27.3 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_27.5: i32 = int_literal 1 [template = constants.%.8]
-// CHECK:STDOUT:   %.loc7_27.6: ref i32 = array_index %a.var, %.loc7_27.5
+// CHECK:STDOUT:   %.loc7_27.6: ref i32 = array_index file.%a.var, %.loc7_27.5
 // CHECK:STDOUT:   %.loc7_27.7: init i32 = initialize_from %.loc7_23 to %.loc7_27.6 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_27.8: i32 = int_literal 2 [template = constants.%.9]
-// CHECK:STDOUT:   %.loc7_27.9: ref i32 = array_index %a.var, %.loc7_27.8
+// CHECK:STDOUT:   %.loc7_27.9: ref i32 = array_index file.%a.var, %.loc7_27.8
 // CHECK:STDOUT:   %.loc7_27.10: init i32 = initialize_from %.loc7_26 to %.loc7_27.9 [template = constants.%.1]
-// CHECK:STDOUT:   %.loc7_27.11: init [i32; 3] = array_init (%.loc7_27.4, %.loc7_27.7, %.loc7_27.10) to %a.var [template = constants.%.10]
+// CHECK:STDOUT:   %.loc7_27.11: init [i32; 3] = array_init (%.loc7_27.4, %.loc7_27.7, %.loc7_27.10) to file.%a.var [template = constants.%.10]
 // CHECK:STDOUT:   %.loc7_27.12: init [i32; 3] = converted %.loc7_27.1, %.loc7_27.11 [template = constants.%.10]
-// CHECK:STDOUT:   assign %a.var, %.loc7_27.12
-// CHECK:STDOUT:   %b.var: ref i32 = var b
-// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref [i32; 3] = name_ref a, %a
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_27.12
+// CHECK:STDOUT:   %a.ref: ref [i32; 3] = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc8_26: i32 = int_literal 2 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc8_27.1: {.index: i32} = struct_literal (%.loc8_26)
 // CHECK:STDOUT:   %.loc8_27.2: {.index: i32} = struct_value (%.loc8_26) [template = constants.%.12]
@@ -56,6 +60,7 @@ var b: i32 = a[{.index = 2}.index];
 // CHECK:STDOUT:   %.loc8_28: i32 = struct_access %.loc8_27.3, element0 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc8_34.1: ref i32 = array_index %a.ref, %.loc8_28
 // CHECK:STDOUT:   %.loc8_34.2: i32 = bind_value %.loc8_34.1
-// CHECK:STDOUT:   assign %b.var, %.loc8_34.2
+// CHECK:STDOUT:   assign file.%b.var, %.loc8_34.2
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/array/nine_elements.carbon

@@ -39,6 +39,10 @@ var a: [i32; 9] = (1, 2, 3, 4, 5, 6, 7, 8, 9);
 // CHECK:STDOUT:   %.loc7_15: type = array_type %.loc7_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref [i32; 9] = var a
 // CHECK:STDOUT:   %a: ref [i32; 9] = bind_name a, %a.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 1 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_23: i32 = int_literal 2 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 3 [template = constants.%.6]
@@ -50,34 +54,35 @@ var a: [i32; 9] = (1, 2, 3, 4, 5, 6, 7, 8, 9);
 // CHECK:STDOUT:   %.loc7_44: i32 = int_literal 9 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc7_45.1: (i32, i32, i32, i32, i32, i32, i32, i32, i32) = tuple_literal (%.loc7_20, %.loc7_23, %.loc7_26, %.loc7_29, %.loc7_32, %.loc7_35, %.loc7_38, %.loc7_41, %.loc7_44)
 // CHECK:STDOUT:   %.loc7_45.2: i32 = int_literal 0 [template = constants.%.13]
-// CHECK:STDOUT:   %.loc7_45.3: ref i32 = array_index %a.var, %.loc7_45.2
+// CHECK:STDOUT:   %.loc7_45.3: ref i32 = array_index file.%a.var, %.loc7_45.2
 // CHECK:STDOUT:   %.loc7_45.4: init i32 = initialize_from %.loc7_20 to %.loc7_45.3 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_45.5: i32 = int_literal 1 [template = constants.%.14]
-// CHECK:STDOUT:   %.loc7_45.6: ref i32 = array_index %a.var, %.loc7_45.5
+// CHECK:STDOUT:   %.loc7_45.6: ref i32 = array_index file.%a.var, %.loc7_45.5
 // CHECK:STDOUT:   %.loc7_45.7: init i32 = initialize_from %.loc7_23 to %.loc7_45.6 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_45.8: i32 = int_literal 2 [template = constants.%.15]
-// CHECK:STDOUT:   %.loc7_45.9: ref i32 = array_index %a.var, %.loc7_45.8
+// CHECK:STDOUT:   %.loc7_45.9: ref i32 = array_index file.%a.var, %.loc7_45.8
 // CHECK:STDOUT:   %.loc7_45.10: init i32 = initialize_from %.loc7_26 to %.loc7_45.9 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc7_45.11: i32 = int_literal 3 [template = constants.%.16]
-// CHECK:STDOUT:   %.loc7_45.12: ref i32 = array_index %a.var, %.loc7_45.11
+// CHECK:STDOUT:   %.loc7_45.12: ref i32 = array_index file.%a.var, %.loc7_45.11
 // CHECK:STDOUT:   %.loc7_45.13: init i32 = initialize_from %.loc7_29 to %.loc7_45.12 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc7_45.14: i32 = int_literal 4 [template = constants.%.17]
-// CHECK:STDOUT:   %.loc7_45.15: ref i32 = array_index %a.var, %.loc7_45.14
+// CHECK:STDOUT:   %.loc7_45.15: ref i32 = array_index file.%a.var, %.loc7_45.14
 // CHECK:STDOUT:   %.loc7_45.16: init i32 = initialize_from %.loc7_32 to %.loc7_45.15 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc7_45.17: i32 = int_literal 5 [template = constants.%.18]
-// CHECK:STDOUT:   %.loc7_45.18: ref i32 = array_index %a.var, %.loc7_45.17
+// CHECK:STDOUT:   %.loc7_45.18: ref i32 = array_index file.%a.var, %.loc7_45.17
 // CHECK:STDOUT:   %.loc7_45.19: init i32 = initialize_from %.loc7_35 to %.loc7_45.18 [template = constants.%.9]
 // CHECK:STDOUT:   %.loc7_45.20: i32 = int_literal 6 [template = constants.%.19]
-// CHECK:STDOUT:   %.loc7_45.21: ref i32 = array_index %a.var, %.loc7_45.20
+// CHECK:STDOUT:   %.loc7_45.21: ref i32 = array_index file.%a.var, %.loc7_45.20
 // CHECK:STDOUT:   %.loc7_45.22: init i32 = initialize_from %.loc7_38 to %.loc7_45.21 [template = constants.%.10]
 // CHECK:STDOUT:   %.loc7_45.23: i32 = int_literal 7 [template = constants.%.20]
-// CHECK:STDOUT:   %.loc7_45.24: ref i32 = array_index %a.var, %.loc7_45.23
+// CHECK:STDOUT:   %.loc7_45.24: ref i32 = array_index file.%a.var, %.loc7_45.23
 // CHECK:STDOUT:   %.loc7_45.25: init i32 = initialize_from %.loc7_41 to %.loc7_45.24 [template = constants.%.11]
 // CHECK:STDOUT:   %.loc7_45.26: i32 = int_literal 8 [template = constants.%.21]
-// CHECK:STDOUT:   %.loc7_45.27: ref i32 = array_index %a.var, %.loc7_45.26
+// CHECK:STDOUT:   %.loc7_45.27: ref i32 = array_index file.%a.var, %.loc7_45.26
 // CHECK:STDOUT:   %.loc7_45.28: init i32 = initialize_from %.loc7_44 to %.loc7_45.27 [template = constants.%.1]
-// CHECK:STDOUT:   %.loc7_45.29: init [i32; 9] = array_init (%.loc7_45.4, %.loc7_45.7, %.loc7_45.10, %.loc7_45.13, %.loc7_45.16, %.loc7_45.19, %.loc7_45.22, %.loc7_45.25, %.loc7_45.28) to %a.var [template = constants.%.22]
+// CHECK:STDOUT:   %.loc7_45.29: init [i32; 9] = array_init (%.loc7_45.4, %.loc7_45.7, %.loc7_45.10, %.loc7_45.13, %.loc7_45.16, %.loc7_45.19, %.loc7_45.22, %.loc7_45.25, %.loc7_45.28) to file.%a.var [template = constants.%.22]
 // CHECK:STDOUT:   %.loc7_45.30: init [i32; 9] = converted %.loc7_45.1, %.loc7_45.29 [template = constants.%.22]
-// CHECK:STDOUT:   assign %a.var, %.loc7_45.30
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_45.30
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/basics/builtin_insts.carbon

@@ -43,6 +43,7 @@
 // CHECK:STDOUT:   inst_blocks:
 // CHECK:STDOUT:     empty:           {}
 // CHECK:STDOUT:     exports:         {}
-// CHECK:STDOUT:     block2:
+// CHECK:STDOUT:     global_init:     {}
+// CHECK:STDOUT:     block3:
 // CHECK:STDOUT:       0:               inst+0
 // CHECK:STDOUT: ...

toolchain/check/testdata/basics/builtin_types.carbon

@@ -22,16 +22,21 @@ var test_type: type = i32;
 // CHECK:STDOUT:   package: <namespace> = namespace {.test_i32 = %test_i32, .test_f64 = %test_f64, .test_type = %test_type} [template]
 // CHECK:STDOUT:   %test_i32.var: ref i32 = var test_i32
 // CHECK:STDOUT:   %test_i32: ref i32 = bind_name test_i32, %test_i32.var
-// CHECK:STDOUT:   %.loc7: i32 = int_literal 0 [template = constants.%.1]
-// CHECK:STDOUT:   assign %test_i32.var, %.loc7
 // 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:   %.loc8: f64 = real_literal 1e-1 [template = constants.%.2]
-// CHECK:STDOUT:   assign %test_f64.var, %.loc8
 // CHECK:STDOUT:   %.loc9: String = string_literal "Test" [template = constants.%.4]
 // CHECK:STDOUT:   %test_str: String = bind_name test_str, %.loc9
 // 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:   assign %test_type.var, i32
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc7: i32 = int_literal 0 [template = constants.%.1]
+// CHECK:STDOUT:   assign file.%test_i32.var, %.loc7
+// CHECK:STDOUT:   %.loc8: f64 = real_literal 1e-1 [template = constants.%.2]
+// CHECK:STDOUT:   assign file.%test_f64.var, %.loc8
+// CHECK:STDOUT:   assign file.%test_type.var, i32
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/basics/fail_non_type_as_type.carbon

@@ -19,7 +19,12 @@ var x: type = 42;
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x} [template]
 // CHECK:STDOUT:   %x.var: ref type = var x
 // CHECK:STDOUT:   %x: ref type = bind_name x, %x.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10: i32 = int_literal 42 [template = constants.%.1]
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/basics/fail_qualifier_unsupported.carbon

@@ -18,7 +18,12 @@ var y: i32 = x.b;
 // CHECK:STDOUT:   %x: ref i32 = bind_name x, %x.var
 // CHECK:STDOUT:   %y.var: ref i32 = var y
 // CHECK:STDOUT:   %y: ref i32 = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref i32 = name_ref x, %x
-// CHECK:STDOUT:   assign %y.var, <error>
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %x.ref: ref i32 = name_ref x, file.%x
+// CHECK:STDOUT:   assign file.%y.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/basics/multifile_raw_and_textual_ir.carbon

@@ -26,7 +26,7 @@ fn B() {}
 // CHECK:STDOUT:     name_scope0:     {inst: inst+0, enclosing_scope: name_scope<invalid>, has_error: false, extended_scopes: [], names: {name0: inst+1}}
 // CHECK:STDOUT:   bind_names:      {}
 // CHECK:STDOUT:   functions:
-// CHECK:STDOUT:     function0:       {name: name0, enclosing_scope: name_scope0, param_refs: empty, body: [block2]}
+// CHECK:STDOUT:     function0:       {name: name0, enclosing_scope: name_scope0, param_refs: empty, body: [block3]}
 // CHECK:STDOUT:   classes:         {}
 // CHECK:STDOUT:   types:
 // CHECK:STDOUT:     type0:           {constant: template instNamespaceType, value_rep: {kind: copy, type: type0}}
@@ -43,9 +43,10 @@ fn B() {}
 // CHECK:STDOUT:     empty:           {}
 // CHECK:STDOUT:     exports:
 // CHECK:STDOUT:       0:               inst+1
-// CHECK:STDOUT:     block2:
-// CHECK:STDOUT:       0:               inst+2
+// CHECK:STDOUT:     global_init:     {}
 // CHECK:STDOUT:     block3:
+// CHECK:STDOUT:       0:               inst+2
+// CHECK:STDOUT:     block4:
 // CHECK:STDOUT:       0:               inst+0
 // CHECK:STDOUT:       1:               inst+1
 // CHECK:STDOUT: ...
@@ -70,7 +71,7 @@ fn B() {}
 // CHECK:STDOUT:     name_scope0:     {inst: inst+0, enclosing_scope: name_scope<invalid>, has_error: false, extended_scopes: [], names: {name0: inst+1}}
 // CHECK:STDOUT:   bind_names:      {}
 // CHECK:STDOUT:   functions:
-// CHECK:STDOUT:     function0:       {name: name0, enclosing_scope: name_scope0, param_refs: empty, body: [block2]}
+// CHECK:STDOUT:     function0:       {name: name0, enclosing_scope: name_scope0, param_refs: empty, body: [block3]}
 // CHECK:STDOUT:   classes:         {}
 // CHECK:STDOUT:   types:
 // CHECK:STDOUT:     type0:           {constant: template instNamespaceType, value_rep: {kind: copy, type: type0}}
@@ -87,9 +88,10 @@ fn B() {}
 // CHECK:STDOUT:     empty:           {}
 // CHECK:STDOUT:     exports:
 // CHECK:STDOUT:       0:               inst+1
-// CHECK:STDOUT:     block2:
-// CHECK:STDOUT:       0:               inst+2
+// CHECK:STDOUT:     global_init:     {}
 // CHECK:STDOUT:     block3:
+// CHECK:STDOUT:       0:               inst+2
+// CHECK:STDOUT:     block4:
 // CHECK:STDOUT:       0:               inst+0
 // CHECK:STDOUT:       1:               inst+1
 // CHECK:STDOUT: ...

toolchain/check/testdata/basics/multifile_raw_ir.carbon

@@ -26,7 +26,7 @@ fn B() {}
 // CHECK:STDOUT:     name_scope0:     {inst: inst+0, enclosing_scope: name_scope<invalid>, has_error: false, extended_scopes: [], names: {name0: inst+1}}
 // CHECK:STDOUT:   bind_names:      {}
 // CHECK:STDOUT:   functions:
-// CHECK:STDOUT:     function0:       {name: name0, enclosing_scope: name_scope0, param_refs: empty, body: [block2]}
+// CHECK:STDOUT:     function0:       {name: name0, enclosing_scope: name_scope0, param_refs: empty, body: [block3]}
 // CHECK:STDOUT:   classes:         {}
 // CHECK:STDOUT:   types:
 // CHECK:STDOUT:     type0:           {constant: template instNamespaceType, value_rep: {kind: copy, type: type0}}
@@ -43,9 +43,10 @@ fn B() {}
 // CHECK:STDOUT:     empty:           {}
 // CHECK:STDOUT:     exports:
 // CHECK:STDOUT:       0:               inst+1
-// CHECK:STDOUT:     block2:
-// CHECK:STDOUT:       0:               inst+2
+// CHECK:STDOUT:     global_init:     {}
 // CHECK:STDOUT:     block3:
+// CHECK:STDOUT:       0:               inst+2
+// CHECK:STDOUT:     block4:
 // CHECK:STDOUT:       0:               inst+0
 // CHECK:STDOUT:       1:               inst+1
 // CHECK:STDOUT: ...
@@ -57,7 +58,7 @@ fn B() {}
 // CHECK:STDOUT:     name_scope0:     {inst: inst+0, enclosing_scope: name_scope<invalid>, has_error: false, extended_scopes: [], names: {name0: inst+1}}
 // CHECK:STDOUT:   bind_names:      {}
 // CHECK:STDOUT:   functions:
-// CHECK:STDOUT:     function0:       {name: name0, enclosing_scope: name_scope0, param_refs: empty, body: [block2]}
+// CHECK:STDOUT:     function0:       {name: name0, enclosing_scope: name_scope0, param_refs: empty, body: [block3]}
 // CHECK:STDOUT:   classes:         {}
 // CHECK:STDOUT:   types:
 // CHECK:STDOUT:     type0:           {constant: template instNamespaceType, value_rep: {kind: copy, type: type0}}
@@ -74,9 +75,10 @@ fn B() {}
 // CHECK:STDOUT:     empty:           {}
 // CHECK:STDOUT:     exports:
 // CHECK:STDOUT:       0:               inst+1
-// CHECK:STDOUT:     block2:
-// CHECK:STDOUT:       0:               inst+2
+// CHECK:STDOUT:     global_init:     {}
 // CHECK:STDOUT:     block3:
+// CHECK:STDOUT:       0:               inst+2
+// CHECK:STDOUT:     block4:
 // CHECK:STDOUT:       0:               inst+0
 // CHECK:STDOUT:       1:               inst+1
 // CHECK:STDOUT: ...

toolchain/check/testdata/basics/parens.carbon

@@ -18,11 +18,16 @@ var b: i32 = ((2));
 // CHECK:STDOUT:   package: <namespace> = namespace {.a = %a, .b = %b} [template]
 // CHECK:STDOUT:   %a.var: ref i32 = var a
 // CHECK:STDOUT:   %a: ref i32 = bind_name a, %a.var
-// CHECK:STDOUT:   %.loc7: i32 = int_literal 1 [template = constants.%.1]
-// CHECK:STDOUT:   assign %a.var, %.loc7
 // CHECK:STDOUT:   %b.var: ref i32 = var b
 // CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc7: i32 = int_literal 1 [template = constants.%.1]
+// CHECK:STDOUT:   assign file.%a.var, %.loc7
 // CHECK:STDOUT:   %.loc8: i32 = int_literal 2 [template = constants.%.2]
-// CHECK:STDOUT:   assign %b.var, %.loc8
+// CHECK:STDOUT:   assign file.%b.var, %.loc8
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/basics/raw_and_textual_ir.carbon

@@ -21,7 +21,7 @@ fn Foo(n: i32) -> (i32, i32, f64) {
 // CHECK:STDOUT:   bind_names:
 // CHECK:STDOUT:     bindName0:       {name: name1, enclosing_scope: name_scope<invalid>}
 // CHECK:STDOUT:   functions:
-// CHECK:STDOUT:     function0:       {name: name0, enclosing_scope: name_scope0, param_refs: block2, return_type: type4, return_slot: inst+7, body: [block5]}
+// CHECK:STDOUT:     function0:       {name: name0, enclosing_scope: name_scope0, param_refs: block3, return_type: type4, return_slot: inst+7, body: [block6]}
 // CHECK:STDOUT:   classes:         {}
 // CHECK:STDOUT:   types:
 // CHECK:STDOUT:     type0:           {constant: template instNamespaceType, value_rep: {kind: copy, type: type0}}
@@ -49,7 +49,7 @@ fn Foo(n: i32) -> (i32, i32, f64) {
 // CHECK:STDOUT:     inst+1:          {kind: Param, arg0: name1, type: type1}
 // CHECK:STDOUT:     inst+2:          {kind: BindName, arg0: bindName0, arg1: inst+1, type: type1}
 // CHECK:STDOUT:     inst+3:          {kind: TupleType, arg0: typeBlock0, type: typeTypeType}
-// CHECK:STDOUT:     inst+4:          {kind: TupleLiteral, arg0: block3, type: type2}
+// CHECK:STDOUT:     inst+4:          {kind: TupleLiteral, arg0: block4, type: type2}
 // CHECK:STDOUT:     inst+5:          {kind: TupleType, arg0: typeBlock1, type: typeTypeType}
 // CHECK:STDOUT:     inst+6:          {kind: Converted, arg0: inst+4, arg1: inst+5, type: typeTypeType}
 // CHECK:STDOUT:     inst+7:          {kind: VarStorage, arg0: nameReturnSlot, type: type4}
@@ -60,14 +60,14 @@ fn Foo(n: i32) -> (i32, i32, f64) {
 // CHECK:STDOUT:     inst+12:         {kind: IntLiteral, arg0: int4, type: type1}
 // CHECK:STDOUT:     inst+13:         {kind: RealLiteral, arg0: real0, type: type3}
 // CHECK:STDOUT:     inst+14:         {kind: RealLiteral, arg0: real0, type: type3}
-// CHECK:STDOUT:     inst+15:         {kind: TupleLiteral, arg0: block6, type: type4}
+// CHECK:STDOUT:     inst+15:         {kind: TupleLiteral, arg0: block7, type: type4}
 // CHECK:STDOUT:     inst+16:         {kind: TupleAccess, arg0: inst+7, arg1: element0, type: type1}
 // CHECK:STDOUT:     inst+17:         {kind: InitializeFrom, arg0: inst+10, arg1: inst+16, type: type1}
 // CHECK:STDOUT:     inst+18:         {kind: TupleAccess, arg0: inst+7, arg1: element1, type: type1}
 // CHECK:STDOUT:     inst+19:         {kind: InitializeFrom, arg0: inst+11, arg1: inst+18, type: type1}
 // CHECK:STDOUT:     inst+20:         {kind: TupleAccess, arg0: inst+7, arg1: element2, type: type3}
 // CHECK:STDOUT:     inst+21:         {kind: InitializeFrom, arg0: inst+13, arg1: inst+20, type: type3}
-// CHECK:STDOUT:     inst+22:         {kind: TupleInit, arg0: block7, arg1: inst+7, type: type4}
+// CHECK:STDOUT:     inst+22:         {kind: TupleInit, arg0: block8, arg1: inst+7, type: type4}
 // CHECK:STDOUT:     inst+23:         {kind: Converted, arg0: inst+15, arg1: inst+22, type: type4}
 // CHECK:STDOUT:     inst+24:         {kind: ReturnExpr, arg0: inst+23}
 // CHECK:STDOUT:   constant_values:
@@ -87,19 +87,20 @@ fn Foo(n: i32) -> (i32, i32, f64) {
 // CHECK:STDOUT:     empty:           {}
 // CHECK:STDOUT:     exports:
 // CHECK:STDOUT:       0:               inst+9
-// CHECK:STDOUT:     block2:
-// CHECK:STDOUT:       0:               inst+2
+// CHECK:STDOUT:     global_init:     {}
 // CHECK:STDOUT:     block3:
+// CHECK:STDOUT:       0:               inst+2
+// CHECK:STDOUT:     block4:
 // CHECK:STDOUT:       0:               instIntType
 // CHECK:STDOUT:       1:               instIntType
 // CHECK:STDOUT:       2:               instFloatType
-// CHECK:STDOUT:     block4:
+// CHECK:STDOUT:     block5:
 // CHECK:STDOUT:       0:               inst+1
 // CHECK:STDOUT:       1:               inst+2
 // CHECK:STDOUT:       2:               inst+4
 // CHECK:STDOUT:       3:               inst+6
 // CHECK:STDOUT:       4:               inst+7
-// CHECK:STDOUT:     block5:
+// CHECK:STDOUT:     block6:
 // CHECK:STDOUT:       0:               inst+10
 // CHECK:STDOUT:       1:               inst+11
 // CHECK:STDOUT:       2:               inst+13
@@ -113,15 +114,15 @@ fn Foo(n: i32) -> (i32, i32, f64) {
 // CHECK:STDOUT:       10:              inst+22
 // CHECK:STDOUT:       11:              inst+23
 // CHECK:STDOUT:       12:              inst+24
-// CHECK:STDOUT:     block6:
+// CHECK:STDOUT:     block7:
 // CHECK:STDOUT:       0:               inst+10
 // CHECK:STDOUT:       1:               inst+11
 // CHECK:STDOUT:       2:               inst+13
-// CHECK:STDOUT:     block7:
+// CHECK:STDOUT:     block8:
 // CHECK:STDOUT:       0:               inst+17
 // CHECK:STDOUT:       1:               inst+19
 // CHECK:STDOUT:       2:               inst+21
-// CHECK:STDOUT:     block8:
+// CHECK:STDOUT:     block9:
 // CHECK:STDOUT:       0:               inst+0
 // CHECK:STDOUT:       1:               inst+9
 // CHECK:STDOUT: ...

toolchain/check/testdata/basics/raw_ir.carbon

@@ -21,7 +21,7 @@ fn Foo(n: i32) -> (i32, i32, f64) {
 // CHECK:STDOUT:   bind_names:
 // CHECK:STDOUT:     bindName0:       {name: name1, enclosing_scope: name_scope<invalid>}
 // CHECK:STDOUT:   functions:
-// CHECK:STDOUT:     function0:       {name: name0, enclosing_scope: name_scope0, param_refs: block2, return_type: type4, return_slot: inst+7, body: [block5]}
+// CHECK:STDOUT:     function0:       {name: name0, enclosing_scope: name_scope0, param_refs: block3, return_type: type4, return_slot: inst+7, body: [block6]}
 // CHECK:STDOUT:   classes:         {}
 // CHECK:STDOUT:   types:
 // CHECK:STDOUT:     type0:           {constant: template instNamespaceType, value_rep: {kind: copy, type: type0}}
@@ -49,7 +49,7 @@ fn Foo(n: i32) -> (i32, i32, f64) {
 // CHECK:STDOUT:     inst+1:          {kind: Param, arg0: name1, type: type1}
 // CHECK:STDOUT:     inst+2:          {kind: BindName, arg0: bindName0, arg1: inst+1, type: type1}
 // CHECK:STDOUT:     inst+3:          {kind: TupleType, arg0: typeBlock0, type: typeTypeType}
-// CHECK:STDOUT:     inst+4:          {kind: TupleLiteral, arg0: block3, type: type2}
+// CHECK:STDOUT:     inst+4:          {kind: TupleLiteral, arg0: block4, type: type2}
 // CHECK:STDOUT:     inst+5:          {kind: TupleType, arg0: typeBlock1, type: typeTypeType}
 // CHECK:STDOUT:     inst+6:          {kind: Converted, arg0: inst+4, arg1: inst+5, type: typeTypeType}
 // CHECK:STDOUT:     inst+7:          {kind: VarStorage, arg0: nameReturnSlot, type: type4}
@@ -60,14 +60,14 @@ fn Foo(n: i32) -> (i32, i32, f64) {
 // CHECK:STDOUT:     inst+12:         {kind: IntLiteral, arg0: int4, type: type1}
 // CHECK:STDOUT:     inst+13:         {kind: RealLiteral, arg0: real0, type: type3}
 // CHECK:STDOUT:     inst+14:         {kind: RealLiteral, arg0: real0, type: type3}
-// CHECK:STDOUT:     inst+15:         {kind: TupleLiteral, arg0: block6, type: type4}
+// CHECK:STDOUT:     inst+15:         {kind: TupleLiteral, arg0: block7, type: type4}
 // CHECK:STDOUT:     inst+16:         {kind: TupleAccess, arg0: inst+7, arg1: element0, type: type1}
 // CHECK:STDOUT:     inst+17:         {kind: InitializeFrom, arg0: inst+10, arg1: inst+16, type: type1}
 // CHECK:STDOUT:     inst+18:         {kind: TupleAccess, arg0: inst+7, arg1: element1, type: type1}
 // CHECK:STDOUT:     inst+19:         {kind: InitializeFrom, arg0: inst+11, arg1: inst+18, type: type1}
 // CHECK:STDOUT:     inst+20:         {kind: TupleAccess, arg0: inst+7, arg1: element2, type: type3}
 // CHECK:STDOUT:     inst+21:         {kind: InitializeFrom, arg0: inst+13, arg1: inst+20, type: type3}
-// CHECK:STDOUT:     inst+22:         {kind: TupleInit, arg0: block7, arg1: inst+7, type: type4}
+// CHECK:STDOUT:     inst+22:         {kind: TupleInit, arg0: block8, arg1: inst+7, type: type4}
 // CHECK:STDOUT:     inst+23:         {kind: Converted, arg0: inst+15, arg1: inst+22, type: type4}
 // CHECK:STDOUT:     inst+24:         {kind: ReturnExpr, arg0: inst+23}
 // CHECK:STDOUT:   constant_values:
@@ -87,19 +87,20 @@ fn Foo(n: i32) -> (i32, i32, f64) {
 // CHECK:STDOUT:     empty:           {}
 // CHECK:STDOUT:     exports:
 // CHECK:STDOUT:       0:               inst+9
-// CHECK:STDOUT:     block2:
-// CHECK:STDOUT:       0:               inst+2
+// CHECK:STDOUT:     global_init:     {}
 // CHECK:STDOUT:     block3:
+// CHECK:STDOUT:       0:               inst+2
+// CHECK:STDOUT:     block4:
 // CHECK:STDOUT:       0:               instIntType
 // CHECK:STDOUT:       1:               instIntType
 // CHECK:STDOUT:       2:               instFloatType
-// CHECK:STDOUT:     block4:
+// CHECK:STDOUT:     block5:
 // CHECK:STDOUT:       0:               inst+1
 // CHECK:STDOUT:       1:               inst+2
 // CHECK:STDOUT:       2:               inst+4
 // CHECK:STDOUT:       3:               inst+6
 // CHECK:STDOUT:       4:               inst+7
-// CHECK:STDOUT:     block5:
+// CHECK:STDOUT:     block6:
 // CHECK:STDOUT:       0:               inst+10
 // CHECK:STDOUT:       1:               inst+11
 // CHECK:STDOUT:       2:               inst+13
@@ -113,15 +114,15 @@ fn Foo(n: i32) -> (i32, i32, f64) {
 // CHECK:STDOUT:       10:              inst+22
 // CHECK:STDOUT:       11:              inst+23
 // CHECK:STDOUT:       12:              inst+24
-// CHECK:STDOUT:     block6:
+// CHECK:STDOUT:     block7:
 // CHECK:STDOUT:       0:               inst+10
 // CHECK:STDOUT:       1:               inst+11
 // CHECK:STDOUT:       2:               inst+13
-// CHECK:STDOUT:     block7:
+// CHECK:STDOUT:     block8:
 // CHECK:STDOUT:       0:               inst+17
 // CHECK:STDOUT:       1:               inst+19
 // CHECK:STDOUT:       2:               inst+21
-// CHECK:STDOUT:     block8:
+// CHECK:STDOUT:     block9:
 // CHECK:STDOUT:       0:               inst+0
 // CHECK:STDOUT:       1:               inst+9
 // CHECK:STDOUT: ...

toolchain/check/testdata/class/fail_todo_import.carbon

@@ -67,24 +67,13 @@ var d: (ForwardDeclared,) = d_ref;
 // CHECK:STDOUT:   %Empty.ref: type = name_ref Empty, constants.%Empty [template = constants.%Empty]
 // CHECK:STDOUT:   %a_ref.var: ref Empty = var a_ref
 // CHECK:STDOUT:   %a_ref: ref Empty = bind_name a_ref, %a_ref.var
-// CHECK:STDOUT:   %.loc13_21.1: {} = struct_literal ()
-// CHECK:STDOUT:   %.loc13_21.2: init Empty = class_init (), %a_ref.var [template = constants.%.4]
-// CHECK:STDOUT:   %.loc13_21.3: init Empty = converted %.loc13_21.1, %.loc13_21.2 [template = constants.%.4]
-// CHECK:STDOUT:   assign %a_ref.var, %.loc13_21.3
 // CHECK:STDOUT:   %ForwardDeclared.ref.loc14: type = name_ref ForwardDeclared, constants.%ForwardDeclared [template = constants.%ForwardDeclared]
 // CHECK:STDOUT:   %b_ref.var: ref ForwardDeclared = var b_ref
 // CHECK:STDOUT:   %b_ref: ref ForwardDeclared = bind_name b_ref, %b_ref.var
-// CHECK:STDOUT:   %.loc14_31.1: {} = struct_literal ()
-// CHECK:STDOUT:   %.loc14_31.2: init ForwardDeclared = class_init (), %b_ref.var [template = constants.%.5]
-// CHECK:STDOUT:   %.loc14_31.3: init ForwardDeclared = converted %.loc14_31.1, %.loc14_31.2 [template = constants.%.5]
-// CHECK:STDOUT:   assign %b_ref.var, %.loc14_31.3
 // CHECK:STDOUT:   %ForwardDeclared.ref.loc15: type = name_ref ForwardDeclared, constants.%ForwardDeclared [template = constants.%ForwardDeclared]
-// CHECK:STDOUT:   %.loc15_27: type = ptr_type ForwardDeclared [template = constants.%.6]
+// CHECK:STDOUT:   %.loc15: type = ptr_type ForwardDeclared [template = constants.%.6]
 // CHECK:STDOUT:   %c_ref.var: ref ForwardDeclared* = var c_ref
 // CHECK:STDOUT:   %c_ref: ref ForwardDeclared* = bind_name c_ref, %c_ref.var
-// CHECK:STDOUT:   %b_ref.ref: ref ForwardDeclared = name_ref b_ref, %b_ref
-// CHECK:STDOUT:   %.loc15_31: ForwardDeclared* = addr_of %b_ref.ref
-// CHECK:STDOUT:   assign %c_ref.var, %.loc15_31
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: class @Empty {
@@ -101,6 +90,22 @@ var d: (ForwardDeclared,) = d_ref;
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @F();
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc13_21.1: {} = struct_literal ()
+// CHECK:STDOUT:   %.loc13_21.2: init Empty = class_init (), file.%a_ref.var [template = constants.%.4]
+// CHECK:STDOUT:   %.loc13_21.3: init Empty = converted %.loc13_21.1, %.loc13_21.2 [template = constants.%.4]
+// CHECK:STDOUT:   assign file.%a_ref.var, %.loc13_21.3
+// CHECK:STDOUT:   %.loc14_31.1: {} = struct_literal ()
+// CHECK:STDOUT:   %.loc14_31.2: init ForwardDeclared = class_init (), file.%b_ref.var [template = constants.%.5]
+// CHECK:STDOUT:   %.loc14_31.3: init ForwardDeclared = converted %.loc14_31.1, %.loc14_31.2 [template = constants.%.5]
+// CHECK:STDOUT:   assign file.%b_ref.var, %.loc14_31.3
+// CHECK:STDOUT:   %b_ref.ref: ref ForwardDeclared = name_ref b_ref, file.%b_ref
+// CHECK:STDOUT:   %.loc15: ForwardDeclared* = addr_of %b_ref.ref
+// CHECK:STDOUT:   assign file.%c_ref.var, %.loc15
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
 // CHECK:STDOUT: --- b.carbon
 // CHECK:STDOUT:
 // CHECK:STDOUT: constants {
@@ -118,25 +123,17 @@ var d: (ForwardDeclared,) = d_ref;
 // CHECK:STDOUT:   %Empty.ref: <error> = name_ref Empty, %import_ref.1
 // CHECK:STDOUT:   %a.var: ref <error> = var a
 // CHECK:STDOUT:   %a: ref <error> = bind_name a, %a.var
-// CHECK:STDOUT:   %a_ref.ref: ref <error> = name_ref a_ref, %import_ref.3
-// CHECK:STDOUT:   assign %a.var, <error>
 // CHECK:STDOUT:   %ForwardDeclared.ref.loc13: <error> = name_ref ForwardDeclared, %import_ref.2
 // CHECK:STDOUT:   %b.var: ref <error> = var b
 // CHECK:STDOUT:   %b: ref <error> = bind_name b, %b.var
-// CHECK:STDOUT:   %b_ref.ref: ref <error> = name_ref b_ref, %import_ref.4
-// CHECK:STDOUT:   assign %b.var, <error>
 // CHECK:STDOUT:   %ForwardDeclared.ref.loc14: <error> = name_ref ForwardDeclared, %import_ref.2
 // CHECK:STDOUT:   %.loc14: type = ptr_type <error> [template = <error>]
 // CHECK:STDOUT:   %c.var: ref <error> = var c
 // CHECK:STDOUT:   %c: ref <error> = bind_name c, %c.var
-// CHECK:STDOUT:   %c_ref.ref: ref <error> = name_ref c_ref, %import_ref.5
-// CHECK:STDOUT:   assign %c.var, <error>
 // CHECK:STDOUT:   %ForwardDeclared.ref.loc18: <error> = name_ref ForwardDeclared, %import_ref.2
 // CHECK:STDOUT:   %.loc18: <error> = tuple_literal (%ForwardDeclared.ref.loc18)
 // CHECK:STDOUT:   %d.var: ref <error> = var d
 // CHECK:STDOUT:   %d: ref <error> = bind_name d, %d.var
-// CHECK:STDOUT:   %d_ref.ref: <error> = name_ref d_ref, <error> [template = <error>]
-// CHECK:STDOUT:   assign %d.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Run() {
@@ -155,3 +152,16 @@ var d: (ForwardDeclared,) = d_ref;
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %a_ref.ref: ref <error> = name_ref a_ref, file.%import_ref.3
+// CHECK:STDOUT:   assign file.%a.var, <error>
+// CHECK:STDOUT:   %b_ref.ref: ref <error> = name_ref b_ref, file.%import_ref.4
+// CHECK:STDOUT:   assign file.%b.var, <error>
+// CHECK:STDOUT:   %c_ref.ref: ref <error> = name_ref c_ref, file.%import_ref.5
+// CHECK:STDOUT:   assign file.%c.var, <error>
+// CHECK:STDOUT:   %d_ref.ref: <error> = name_ref d_ref, <error> [template = <error>]
+// CHECK:STDOUT:   assign file.%d.var, <error>
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/const/import.carbon

@@ -32,23 +32,28 @@ var a_ptr: const i32* = a_ptr_ref;
 // CHECK:STDOUT: file {
 // CHECK:STDOUT:   package: <namespace> = namespace {.F = %F, .a_ref = %a_ref, .a_ptr_ref = %a_ptr_ref} [template]
 // CHECK:STDOUT:   %F: <function> = fn_decl @F [template]
-// CHECK:STDOUT:   %.loc6_12: type = const_type i32 [template = constants.%.1]
+// CHECK:STDOUT:   %.loc6: type = const_type i32 [template = constants.%.1]
 // CHECK:STDOUT:   %a_ref.var: ref const i32 = var a_ref
 // CHECK:STDOUT:   %a_ref: ref const i32 = bind_name a_ref, %a_ref.var
-// CHECK:STDOUT:   %F.ref: <function> = name_ref F, %F [template = %F]
-// CHECK:STDOUT:   %.loc6_25: init const i32 = call %F.ref()
-// CHECK:STDOUT:   assign %a_ref.var, %.loc6_25
 // CHECK:STDOUT:   %.loc7_16: type = const_type i32 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc7_25: type = ptr_type const i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a_ptr_ref.var: ref const i32* = var a_ptr_ref
 // CHECK:STDOUT:   %a_ptr_ref: ref const i32* = bind_name a_ptr_ref, %a_ptr_ref.var
-// CHECK:STDOUT:   %a_ref.ref: ref const i32 = name_ref a_ref, %a_ref
-// CHECK:STDOUT:   %.loc7_29: const i32* = addr_of %a_ref.ref
-// CHECK:STDOUT:   assign %a_ptr_ref.var, %.loc7_29
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @F() -> const i32;
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %F.ref: <function> = name_ref F, file.%F [template = file.%F]
+// CHECK:STDOUT:   %.loc6: init const i32 = call %F.ref()
+// CHECK:STDOUT:   assign file.%a_ref.var, %.loc6
+// CHECK:STDOUT:   %a_ref.ref: ref const i32 = name_ref a_ref, file.%a_ref
+// CHECK:STDOUT:   %.loc7: const i32* = addr_of %a_ref.ref
+// CHECK:STDOUT:   assign file.%a_ptr_ref.var, %.loc7
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
 // CHECK:STDOUT: --- implicit.impl.carbon
 // CHECK:STDOUT:
 // CHECK:STDOUT: constants {
@@ -65,15 +70,20 @@ var a_ptr: const i32* = a_ptr_ref;
 // CHECK:STDOUT:   %.loc6_17: type = ptr_type const i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref const i32* = var a
 // CHECK:STDOUT:   %a: ref const i32* = bind_name a, %a.var
-// CHECK:STDOUT:   %a_ref.ref: ref const i32 = name_ref a_ref, %import_ref.2
-// CHECK:STDOUT:   %.loc6_21: const i32* = addr_of %a_ref.ref
-// CHECK:STDOUT:   assign %a.var, %.loc6_21
 // CHECK:STDOUT:   %.loc7_12: type = const_type i32 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc7_21: type = ptr_type const i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a_ptr.var: ref const i32* = var a_ptr
 // CHECK:STDOUT:   %a_ptr: ref const i32* = bind_name a_ptr, %a_ptr.var
-// CHECK:STDOUT:   %a_ptr_ref.ref: ref const i32* = name_ref a_ptr_ref, %import_ref.3
-// CHECK:STDOUT:   %.loc7_25: const i32* = bind_value %a_ptr_ref.ref
-// CHECK:STDOUT:   assign %a_ptr.var, %.loc7_25
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %a_ref.ref: ref const i32 = name_ref a_ref, file.%import_ref.2
+// CHECK:STDOUT:   %.loc6: const i32* = addr_of %a_ref.ref
+// CHECK:STDOUT:   assign file.%a.var, %.loc6
+// CHECK:STDOUT:   %a_ptr_ref.ref: ref const i32* = name_ref a_ptr_ref, file.%import_ref.3
+// CHECK:STDOUT:   %.loc7: const i32* = bind_value %a_ptr_ref.ref
+// CHECK:STDOUT:   assign file.%a_ptr.var, %.loc7
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/eval/aggregate.carbon

@@ -52,21 +52,33 @@ var struct_access: [i32; 1] = (0,) as [i32; {.a = 3, .b = 1}.b];
 // CHECK:STDOUT:   %.loc7_26.2: type = converted %.loc7_26.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %tuple_copy.var: ref (i32, i32) = var tuple_copy
 // CHECK:STDOUT:   %tuple_copy: ref (i32, i32) = bind_name tuple_copy, %tuple_copy.var
+// CHECK:STDOUT:   %.loc9: type = struct_type {.a: i32, .b: i32, .c: i32} [template = constants.%.7]
+// CHECK:STDOUT:   %struct_copy.var: ref {.a: i32, .b: i32, .c: i32} = var struct_copy
+// CHECK:STDOUT:   %struct_copy: ref {.a: i32, .b: i32, .c: i32} = bind_name struct_copy, %struct_copy.var
+// CHECK:STDOUT:   %.loc11_24: i32 = int_literal 1 [template = constants.%.4]
+// CHECK:STDOUT:   %.loc11_25: type = array_type %.loc11_24, i32 [template = constants.%.15]
+// CHECK:STDOUT:   %tuple_index.var: ref [i32; 1] = var tuple_index
+// CHECK:STDOUT:   %tuple_index: ref [i32; 1] = bind_name tuple_index, %tuple_index.var
+// CHECK:STDOUT:   %.loc13_26: i32 = int_literal 1 [template = constants.%.4]
+// CHECK:STDOUT:   %.loc13_27: type = array_type %.loc13_26, i32 [template = constants.%.15]
+// CHECK:STDOUT:   %struct_access.var: ref [i32; 1] = var struct_access
+// CHECK:STDOUT:   %struct_access: ref [i32; 1] = bind_name struct_access, %struct_access.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_31: i32 = int_literal 1 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_34: i32 = int_literal 2 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_35.1: (i32, i32) = tuple_literal (%.loc7_31, %.loc7_34)
 // CHECK:STDOUT:   %.loc7_49.1: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc7_49.2: type = converted %.loc7_49.1, constants.%.2 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc7_35.2: ref i32 = tuple_access %tuple_copy.var, element0
+// CHECK:STDOUT:   %.loc7_35.2: ref i32 = tuple_access file.%tuple_copy.var, element0
 // CHECK:STDOUT:   %.loc7_35.3: init i32 = initialize_from %.loc7_31 to %.loc7_35.2 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_35.4: ref i32 = tuple_access %tuple_copy.var, element1
+// CHECK:STDOUT:   %.loc7_35.4: ref i32 = tuple_access file.%tuple_copy.var, element1
 // CHECK:STDOUT:   %.loc7_35.5: init i32 = initialize_from %.loc7_34 to %.loc7_35.4 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc7_35.6: init (i32, i32) = tuple_init (%.loc7_35.3, %.loc7_35.5) to %tuple_copy.var [template = constants.%.6]
+// CHECK:STDOUT:   %.loc7_35.6: init (i32, i32) = tuple_init (%.loc7_35.3, %.loc7_35.5) to file.%tuple_copy.var [template = constants.%.6]
 // CHECK:STDOUT:   %.loc7_35.7: init (i32, i32) = converted %.loc7_35.1, %.loc7_35.6 [template = constants.%.6]
-// CHECK:STDOUT:   assign %tuple_copy.var, %.loc7_35.7
-// CHECK:STDOUT:   %.loc9_44: type = struct_type {.a: i32, .b: i32, .c: i32} [template = constants.%.7]
-// CHECK:STDOUT:   %struct_copy.var: ref {.a: i32, .b: i32, .c: i32} = var struct_copy
-// CHECK:STDOUT:   %struct_copy: ref {.a: i32, .b: i32, .c: i32} = bind_name struct_copy, %struct_copy.var
+// CHECK:STDOUT:   assign file.%tuple_copy.var, %.loc7_35.7
 // CHECK:STDOUT:   %.loc9_54: i32 = int_literal 3 [template = constants.%.9]
 // CHECK:STDOUT:   %.loc9_62: i32 = int_literal 2 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc9_70: i32 = int_literal 1 [template = constants.%.4]
@@ -75,21 +87,17 @@ var struct_access: [i32; 1] = (0,) as [i32; {.a = 3, .b = 1}.b];
 // CHECK:STDOUT:   %.loc9_71.2: {.b: i32, .a: i32, .c: i32} = struct_value (%.loc9_62, %.loc9_70, %.loc9_54) [template = constants.%.13]
 // CHECK:STDOUT:   %.loc9_71.3: {.b: i32, .a: i32, .c: i32} = converted %.loc9_71.1, %.loc9_71.2 [template = constants.%.13]
 // CHECK:STDOUT:   %.loc9_71.4: i32 = struct_access %.loc9_71.3, element1 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc9_71.5: ref i32 = struct_access %struct_copy.var, element1
+// CHECK:STDOUT:   %.loc9_71.5: ref i32 = struct_access file.%struct_copy.var, element1
 // CHECK:STDOUT:   %.loc9_71.6: init i32 = initialize_from %.loc9_71.4 to %.loc9_71.5 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc9_71.7: i32 = struct_access %.loc9_71.3, element0 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc9_71.8: ref i32 = struct_access %struct_copy.var, element0
+// CHECK:STDOUT:   %.loc9_71.8: ref i32 = struct_access file.%struct_copy.var, element0
 // CHECK:STDOUT:   %.loc9_71.9: init i32 = initialize_from %.loc9_71.7 to %.loc9_71.8 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc9_71.10: i32 = struct_access %.loc9_71.3, element2 [template = constants.%.9]
-// CHECK:STDOUT:   %.loc9_71.11: ref i32 = struct_access %struct_copy.var, element2
+// CHECK:STDOUT:   %.loc9_71.11: ref i32 = struct_access file.%struct_copy.var, element2
 // CHECK:STDOUT:   %.loc9_71.12: init i32 = initialize_from %.loc9_71.10 to %.loc9_71.11 [template = constants.%.9]
-// CHECK:STDOUT:   %.loc9_71.13: init {.a: i32, .b: i32, .c: i32} = struct_init (%.loc9_71.6, %.loc9_71.9, %.loc9_71.12) to %struct_copy.var [template = constants.%.14]
+// CHECK:STDOUT:   %.loc9_71.13: init {.a: i32, .b: i32, .c: i32} = struct_init (%.loc9_71.6, %.loc9_71.9, %.loc9_71.12) to file.%struct_copy.var [template = constants.%.14]
 // CHECK:STDOUT:   %.loc9_71.14: init {.a: i32, .b: i32, .c: i32} = converted %.loc9_71.3, %.loc9_71.13 [template = constants.%.14]
-// CHECK:STDOUT:   assign %struct_copy.var, %.loc9_71.14
-// CHECK:STDOUT:   %.loc11_24: i32 = int_literal 1 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc11_25: type = array_type %.loc11_24, i32 [template = constants.%.15]
-// CHECK:STDOUT:   %tuple_index.var: ref [i32; 1] = var tuple_index
-// CHECK:STDOUT:   %tuple_index: ref [i32; 1] = bind_name tuple_index, %tuple_index.var
+// CHECK:STDOUT:   assign file.%struct_copy.var, %.loc9_71.14
 // CHECK:STDOUT:   %.loc11_30: i32 = int_literal 0 [template = constants.%.17]
 // CHECK:STDOUT:   %.loc11_32.1: (i32,) = tuple_literal (%.loc11_30)
 // CHECK:STDOUT:   %.loc11_44: i32 = int_literal 5 [template = constants.%.19]
@@ -102,17 +110,13 @@ var struct_access: [i32; 1] = (0,) as [i32; {.a = 3, .b = 1}.b];
 // CHECK:STDOUT:   %.loc11_54.3: (i32, i32, i32, i32) = converted %.loc11_54.1, %.loc11_54.2 [template = constants.%.24]
 // CHECK:STDOUT:   %.loc11_57: i32 = tuple_index %.loc11_54.3, %.loc11_56 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc11_58: type = array_type %.loc11_57, i32 [template = constants.%.15]
-// CHECK:STDOUT:   %.loc11_5: ref [i32; 1] = splice_block %tuple_index.var {}
+// CHECK:STDOUT:   %.loc11_5: ref [i32; 1] = splice_block file.%tuple_index.var {}
 // CHECK:STDOUT:   %.loc11_32.2: i32 = int_literal 0 [template = constants.%.25]
 // CHECK:STDOUT:   %.loc11_32.3: ref i32 = array_index %.loc11_5, %.loc11_32.2
 // CHECK:STDOUT:   %.loc11_32.4: init i32 = initialize_from %.loc11_30 to %.loc11_32.3 [template = constants.%.17]
 // CHECK:STDOUT:   %.loc11_32.5: init [i32; 1] = array_init (%.loc11_32.4) to %.loc11_5 [template = constants.%.26]
 // CHECK:STDOUT:   %.loc11_32.6: init [i32; 1] = converted %.loc11_32.1, %.loc11_32.5 [template = constants.%.26]
-// CHECK:STDOUT:   assign %tuple_index.var, %.loc11_32.6
-// CHECK:STDOUT:   %.loc13_26: i32 = int_literal 1 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc13_27: type = array_type %.loc13_26, i32 [template = constants.%.15]
-// CHECK:STDOUT:   %struct_access.var: ref [i32; 1] = var struct_access
-// CHECK:STDOUT:   %struct_access: ref [i32; 1] = bind_name struct_access, %struct_access.var
+// CHECK:STDOUT:   assign file.%tuple_index.var, %.loc11_32.6
 // CHECK:STDOUT:   %.loc13_32: i32 = int_literal 0 [template = constants.%.17]
 // CHECK:STDOUT:   %.loc13_34.1: (i32,) = tuple_literal (%.loc13_32)
 // CHECK:STDOUT:   %.loc13_51: i32 = int_literal 3 [template = constants.%.9]
@@ -122,12 +126,13 @@ var struct_access: [i32; 1] = (0,) as [i32; {.a = 3, .b = 1}.b];
 // CHECK:STDOUT:   %.loc13_60.3: {.a: i32, .b: i32} = converted %.loc13_60.1, %.loc13_60.2 [template = constants.%.29]
 // CHECK:STDOUT:   %.loc13_61: i32 = struct_access %.loc13_60.3, element1 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc13_63: type = array_type %.loc13_61, i32 [template = constants.%.15]
-// CHECK:STDOUT:   %.loc13_5: ref [i32; 1] = splice_block %struct_access.var {}
+// CHECK:STDOUT:   %.loc13_5: ref [i32; 1] = splice_block file.%struct_access.var {}
 // CHECK:STDOUT:   %.loc13_34.2: i32 = int_literal 0 [template = constants.%.25]
 // CHECK:STDOUT:   %.loc13_34.3: ref i32 = array_index %.loc13_5, %.loc13_34.2
 // CHECK:STDOUT:   %.loc13_34.4: init i32 = initialize_from %.loc13_32 to %.loc13_34.3 [template = constants.%.17]
 // CHECK:STDOUT:   %.loc13_34.5: init [i32; 1] = array_init (%.loc13_34.4) to %.loc13_5 [template = constants.%.26]
 // CHECK:STDOUT:   %.loc13_34.6: init [i32; 1] = converted %.loc13_34.1, %.loc13_34.5 [template = constants.%.26]
-// CHECK:STDOUT:   assign %struct_access.var, %.loc13_34.6
+// CHECK:STDOUT:   assign file.%struct_access.var, %.loc13_34.6
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/eval/fail_aggregate.carbon

@@ -40,6 +40,10 @@ var array_index: [i32; 1] = (0,) as [i32; ((5, 7, 1, 9) as [i32; 4])[2]];
 // CHECK:STDOUT:   %.loc12_25: type = array_type %.loc12_24, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %array_index.var: ref [i32; 1] = var array_index
 // CHECK:STDOUT:   %array_index: ref [i32; 1] = bind_name array_index, %array_index.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc12_30: i32 = int_literal 0 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc12_32: (i32,) = tuple_literal (%.loc12_30)
 // CHECK:STDOUT:   %.loc12_45: i32 = int_literal 5 [template = constants.%.6]
@@ -68,6 +72,7 @@ var array_index: [i32; 1] = (0,) as [i32; ((5, 7, 1, 9) as [i32; 4])[2]];
 // CHECK:STDOUT:   %.loc12_55.17: ref [i32; 4] = temporary %.loc12_55.2, %.loc12_55.16
 // CHECK:STDOUT:   %.loc12_71.1: ref i32 = array_index %.loc12_55.17, %.loc12_70
 // CHECK:STDOUT:   %.loc12_71.2: i32 = bind_value %.loc12_71.1
-// CHECK:STDOUT:   assign %array_index.var, <error>
+// CHECK:STDOUT:   assign file.%array_index.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/global/class_obj.carbon

@@ -0,0 +1,41 @@
+// 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
+class A {}
+
+var a: A = {};
+
+// CHECK:STDOUT: --- class_obj.carbon
+// CHECK:STDOUT:
+// CHECK:STDOUT: constants {
+// CHECK:STDOUT:   %A: type = class_type @A [template]
+// CHECK:STDOUT:   %.1: type = struct_type {} [template]
+// CHECK:STDOUT:   %.2: type = tuple_type () [template]
+// CHECK:STDOUT:   %.3: type = ptr_type {} [template]
+// CHECK:STDOUT:   %.4: A = struct_value () [template]
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: file {
+// CHECK:STDOUT:   package: <namespace> = namespace {.A = %A.decl, .a = %a} [template]
+// CHECK:STDOUT:   %A.decl = class_decl @A, ()
+// CHECK:STDOUT:   %A.ref: type = name_ref A, constants.%A [template = constants.%A]
+// CHECK:STDOUT:   %a.var: ref A = var a
+// CHECK:STDOUT:   %a: ref A = bind_name a, %a.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: class @A {
+// CHECK:STDOUT:
+// CHECK:STDOUT: !members:
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc8_13.1: {} = struct_literal ()
+// CHECK:STDOUT:   %.loc8_13.2: init A = class_init (), file.%a.var [template = constants.%.4]
+// CHECK:STDOUT:   %.loc8_13.3: init A = converted %.loc8_13.1, %.loc8_13.2 [template = constants.%.4]
+// CHECK:STDOUT:   assign file.%a.var, %.loc8_13.3
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/global/class_with_fun.carbon

@@ -0,0 +1,54 @@
+// 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
+class A {}
+
+fn ret_a() -> A {
+  return {};
+}
+
+var a: A = {};
+
+// CHECK:STDOUT: --- class_with_fun.carbon
+// CHECK:STDOUT:
+// CHECK:STDOUT: constants {
+// CHECK:STDOUT:   %A: type = class_type @A [template]
+// CHECK:STDOUT:   %.1: type = struct_type {} [template]
+// CHECK:STDOUT:   %.2: type = tuple_type () [template]
+// CHECK:STDOUT:   %.3: type = ptr_type {} [template]
+// CHECK:STDOUT:   %.4: A = struct_value () [template]
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: file {
+// CHECK:STDOUT:   package: <namespace> = namespace {.A = %A.decl, .ret_a = %ret_a, .a = %a} [template]
+// CHECK:STDOUT:   %A.decl = class_decl @A, ()
+// CHECK:STDOUT:   %ret_a: <function> = fn_decl @ret_a [template]
+// CHECK:STDOUT:   %A.ref: type = name_ref A, constants.%A [template = constants.%A]
+// CHECK:STDOUT:   %a.var: ref A = var a
+// CHECK:STDOUT:   %a: ref A = bind_name a, %a.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: class @A {
+// CHECK:STDOUT:
+// CHECK:STDOUT: !members:
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @ret_a() -> %return: A {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc9_11.1: {} = struct_literal ()
+// CHECK:STDOUT:   %.loc9_11.2: init A = class_init (), %return [template = constants.%.4]
+// CHECK:STDOUT:   %.loc9_11.3: init A = converted %.loc9_11.1, %.loc9_11.2 [template = constants.%.4]
+// CHECK:STDOUT:   return %.loc9_11.3
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc12_13.1: {} = struct_literal ()
+// CHECK:STDOUT:   %.loc12_13.2: init A = class_init (), file.%a.var [template = constants.%.4]
+// CHECK:STDOUT:   %.loc12_13.3: init A = converted %.loc12_13.1, %.loc12_13.2 [template = constants.%.4]
+// CHECK:STDOUT:   assign file.%a.var, %.loc12_13.3
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/global/decl.carbon

@@ -0,0 +1,15 @@
+// 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
+var a: i32;
+
+// CHECK:STDOUT: --- decl.carbon
+// CHECK:STDOUT:
+// CHECK:STDOUT: file {
+// CHECK:STDOUT:   package: <namespace> = namespace {.a = %a} [template]
+// CHECK:STDOUT:   %a.var: ref i32 = var a
+// CHECK:STDOUT:   %a: ref i32 = bind_name a, %a.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/global/simple_init.carbon

@@ -0,0 +1,26 @@
+// 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
+var a: i32 = 0;
+
+// CHECK:STDOUT: --- simple_init.carbon
+// CHECK:STDOUT:
+// CHECK:STDOUT: constants {
+// CHECK:STDOUT:   %.1: i32 = int_literal 0 [template]
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: file {
+// CHECK:STDOUT:   package: <namespace> = namespace {.a = %a} [template]
+// CHECK:STDOUT:   %a.var: ref i32 = var a
+// CHECK:STDOUT:   %a: ref i32 = bind_name a, %a.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc6: i32 = int_literal 0 [template = constants.%.1]
+// CHECK:STDOUT:   assign file.%a.var, %.loc6
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/global/simple_with_fun.carbon

@@ -0,0 +1,39 @@
+// 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
+
+fn test_a() -> i32 {
+  return 0;
+}
+
+var a: i32 = test_a();
+
+// CHECK:STDOUT: --- simple_with_fun.carbon
+// CHECK:STDOUT:
+// CHECK:STDOUT: constants {
+// CHECK:STDOUT:   %.1: i32 = int_literal 0 [template]
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: file {
+// CHECK:STDOUT:   package: <namespace> = namespace {.test_a = %test_a, .a = %a} [template]
+// CHECK:STDOUT:   %test_a: <function> = fn_decl @test_a [template]
+// CHECK:STDOUT:   %a.var: ref i32 = var a
+// CHECK:STDOUT:   %a: ref i32 = bind_name a, %a.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @test_a() -> i32 {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc8: i32 = int_literal 0 [template = constants.%.1]
+// CHECK:STDOUT:   return %.loc8
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %test_a.ref: <function> = name_ref test_a, file.%test_a [template = file.%test_a]
+// CHECK:STDOUT:   %.loc11: init i32 = call %test_a.ref()
+// CHECK:STDOUT:   assign file.%a.var, %.loc11
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/if_expr/fail_not_in_function.carbon

@@ -43,7 +43,7 @@ class C {
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
-// CHECK:STDOUT:   %.loc17: i32 = block_arg <unexpected instblockref block5>
+// CHECK:STDOUT:   %.loc17: i32 = block_arg <unexpected instblockref block6>
 // CHECK:STDOUT:   %x: i32 = bind_name x, %.loc17
 // CHECK:STDOUT:   %C.decl = class_decl @C, ()
 // CHECK:STDOUT: }

toolchain/check/testdata/index/array_element_access.carbon

@@ -31,36 +31,41 @@ var d: i32 = a[b];
 // CHECK:STDOUT:   %.loc7_15: type = array_type %.loc7_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref [i32; 2] = var a
 // CHECK:STDOUT:   %a: ref [i32; 2] = bind_name a, %a.var
+// CHECK:STDOUT:   %b.var: ref i32 = var b
+// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT:   %c.var: ref i32 = var c
+// CHECK:STDOUT:   %c: ref i32 = bind_name c, %c.var
+// CHECK:STDOUT:   %d.var: ref i32 = var d
+// CHECK:STDOUT:   %d: ref i32 = bind_name d, %d.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 12 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_24: i32 = int_literal 24 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_26.1: (i32, i32) = tuple_literal (%.loc7_20, %.loc7_24)
 // CHECK:STDOUT:   %.loc7_26.2: i32 = int_literal 0 [template = constants.%.7]
-// CHECK:STDOUT:   %.loc7_26.3: ref i32 = array_index %a.var, %.loc7_26.2
+// CHECK:STDOUT:   %.loc7_26.3: ref i32 = array_index file.%a.var, %.loc7_26.2
 // CHECK:STDOUT:   %.loc7_26.4: init i32 = initialize_from %.loc7_20 to %.loc7_26.3 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_26.5: i32 = int_literal 1 [template = constants.%.8]
-// CHECK:STDOUT:   %.loc7_26.6: ref i32 = array_index %a.var, %.loc7_26.5
+// CHECK:STDOUT:   %.loc7_26.6: ref i32 = array_index file.%a.var, %.loc7_26.5
 // CHECK:STDOUT:   %.loc7_26.7: init i32 = initialize_from %.loc7_24 to %.loc7_26.6 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc7_26.8: init [i32; 2] = array_init (%.loc7_26.4, %.loc7_26.7) to %a.var [template = constants.%.9]
+// CHECK:STDOUT:   %.loc7_26.8: init [i32; 2] = array_init (%.loc7_26.4, %.loc7_26.7) to file.%a.var [template = constants.%.9]
 // CHECK:STDOUT:   %.loc7_26.9: init [i32; 2] = converted %.loc7_26.1, %.loc7_26.8 [template = constants.%.9]
-// CHECK:STDOUT:   assign %a.var, %.loc7_26.9
-// CHECK:STDOUT:   %b.var: ref i32 = var b
-// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_26.9
 // CHECK:STDOUT:   %.loc8: i32 = int_literal 1 [template = constants.%.10]
-// CHECK:STDOUT:   assign %b.var, %.loc8
-// CHECK:STDOUT:   %c.var: ref i32 = var c
-// CHECK:STDOUT:   %c: ref i32 = bind_name c, %c.var
-// CHECK:STDOUT:   %a.ref.loc9: ref [i32; 2] = name_ref a, %a
+// CHECK:STDOUT:   assign file.%b.var, %.loc8
+// CHECK:STDOUT:   %a.ref.loc9: ref [i32; 2] = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc9_16: i32 = int_literal 0 [template = constants.%.11]
 // CHECK:STDOUT:   %.loc9_17.1: ref i32 = array_index %a.ref.loc9, %.loc9_16
 // CHECK:STDOUT:   %.loc9_17.2: i32 = bind_value %.loc9_17.1
-// CHECK:STDOUT:   assign %c.var, %.loc9_17.2
-// CHECK:STDOUT:   %d.var: ref i32 = var d
-// CHECK:STDOUT:   %d: ref i32 = bind_name d, %d.var
-// CHECK:STDOUT:   %a.ref.loc10: ref [i32; 2] = name_ref a, %a
-// CHECK:STDOUT:   %b.ref: ref i32 = name_ref b, %b
+// CHECK:STDOUT:   assign file.%c.var, %.loc9_17.2
+// CHECK:STDOUT:   %a.ref.loc10: ref [i32; 2] = name_ref a, file.%a
+// CHECK:STDOUT:   %b.ref: ref i32 = name_ref b, file.%b
 // CHECK:STDOUT:   %.loc10_16: i32 = bind_value %b.ref
 // CHECK:STDOUT:   %.loc10_17.1: ref i32 = array_index %a.ref.loc10, %.loc10_16
 // CHECK:STDOUT:   %.loc10_17.2: i32 = bind_value %.loc10_17.1
-// CHECK:STDOUT:   assign %d.var, %.loc10_17.2
+// CHECK:STDOUT:   assign file.%d.var, %.loc10_17.2
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/index/fail_array_large_index.carbon

@@ -29,20 +29,25 @@ var b: i32 = a[0xFFFFFFFFFFFFFFFFF];
 // CHECK:STDOUT:   %.loc7_15: type = array_type %.loc7_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref [i32; 1] = var a
 // CHECK:STDOUT:   %a: ref [i32; 1] = bind_name a, %a.var
+// CHECK:STDOUT:   %b.var: ref i32 = var b
+// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 12 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_23.1: (i32,) = tuple_literal (%.loc7_20)
 // CHECK:STDOUT:   %.loc7_23.2: i32 = int_literal 0 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc7_23.3: ref i32 = array_index %a.var, %.loc7_23.2
+// CHECK:STDOUT:   %.loc7_23.3: ref i32 = array_index file.%a.var, %.loc7_23.2
 // CHECK:STDOUT:   %.loc7_23.4: init i32 = initialize_from %.loc7_20 to %.loc7_23.3 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_23.5: init [i32; 1] = array_init (%.loc7_23.4) to %a.var [template = constants.%.7]
+// CHECK:STDOUT:   %.loc7_23.5: init [i32; 1] = array_init (%.loc7_23.4) to file.%a.var [template = constants.%.7]
 // CHECK:STDOUT:   %.loc7_23.6: init [i32; 1] = converted %.loc7_23.1, %.loc7_23.5 [template = constants.%.7]
-// CHECK:STDOUT:   assign %a.var, %.loc7_23.6
-// CHECK:STDOUT:   %b.var: ref i32 = var b
-// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref [i32; 1] = name_ref a, %a
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_23.6
+// CHECK:STDOUT:   %a.ref: ref [i32; 1] = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc11_16: i32 = int_literal 295147905179352825855 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc11_35.1: ref i32 = array_index %a.ref, %.loc11_16 [template = <error>]
 // CHECK:STDOUT:   %.loc11_35.2: i32 = bind_value %.loc11_35.1
-// CHECK:STDOUT:   assign %b.var, %.loc11_35.2
+// CHECK:STDOUT:   assign file.%b.var, %.loc11_35.2
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/index/fail_array_non_int_indexing.carbon

@@ -29,20 +29,25 @@ var b: i32 = a[2.6];
 // CHECK:STDOUT:   %.loc7_15: type = array_type %.loc7_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref [i32; 1] = var a
 // CHECK:STDOUT:   %a: ref [i32; 1] = bind_name a, %a.var
+// CHECK:STDOUT:   %b.var: ref i32 = var b
+// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 12 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_23.1: (i32,) = tuple_literal (%.loc7_20)
 // CHECK:STDOUT:   %.loc7_23.2: i32 = int_literal 0 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc7_23.3: ref i32 = array_index %a.var, %.loc7_23.2
+// CHECK:STDOUT:   %.loc7_23.3: ref i32 = array_index file.%a.var, %.loc7_23.2
 // CHECK:STDOUT:   %.loc7_23.4: init i32 = initialize_from %.loc7_20 to %.loc7_23.3 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_23.5: init [i32; 1] = array_init (%.loc7_23.4) to %a.var [template = constants.%.7]
+// CHECK:STDOUT:   %.loc7_23.5: init [i32; 1] = array_init (%.loc7_23.4) to file.%a.var [template = constants.%.7]
 // CHECK:STDOUT:   %.loc7_23.6: init [i32; 1] = converted %.loc7_23.1, %.loc7_23.5 [template = constants.%.7]
-// CHECK:STDOUT:   assign %a.var, %.loc7_23.6
-// CHECK:STDOUT:   %b.var: ref i32 = var b
-// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref [i32; 1] = name_ref a, %a
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_23.6
+// CHECK:STDOUT:   %a.ref: ref [i32; 1] = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc11_16: f64 = real_literal 26e-1 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc11_19.1: ref i32 = array_index %a.ref, <error>
 // CHECK:STDOUT:   %.loc11_19.2: i32 = bind_value %.loc11_19.1
-// CHECK:STDOUT:   assign %b.var, %.loc11_19.2
+// CHECK:STDOUT:   assign file.%b.var, %.loc11_19.2
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/index/fail_array_out_of_bound_access.carbon

@@ -28,20 +28,25 @@ var b: i32 = a[1];
 // CHECK:STDOUT:   %.loc7_15: type = array_type %.loc7_14, i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref [i32; 1] = var a
 // CHECK:STDOUT:   %a: ref [i32; 1] = bind_name a, %a.var
+// CHECK:STDOUT:   %b.var: ref i32 = var b
+// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 12 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_23.1: (i32,) = tuple_literal (%.loc7_20)
 // CHECK:STDOUT:   %.loc7_23.2: i32 = int_literal 0 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc7_23.3: ref i32 = array_index %a.var, %.loc7_23.2
+// CHECK:STDOUT:   %.loc7_23.3: ref i32 = array_index file.%a.var, %.loc7_23.2
 // CHECK:STDOUT:   %.loc7_23.4: init i32 = initialize_from %.loc7_20 to %.loc7_23.3 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_23.5: init [i32; 1] = array_init (%.loc7_23.4) to %a.var [template = constants.%.7]
+// CHECK:STDOUT:   %.loc7_23.5: init [i32; 1] = array_init (%.loc7_23.4) to file.%a.var [template = constants.%.7]
 // CHECK:STDOUT:   %.loc7_23.6: init [i32; 1] = converted %.loc7_23.1, %.loc7_23.5 [template = constants.%.7]
-// CHECK:STDOUT:   assign %a.var, %.loc7_23.6
-// CHECK:STDOUT:   %b.var: ref i32 = var b
-// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref [i32; 1] = name_ref a, %a
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_23.6
+// CHECK:STDOUT:   %a.ref: ref [i32; 1] = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc11_16: i32 = int_literal 1 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc11_17.1: ref i32 = array_index %a.ref, %.loc11_16 [template = <error>]
 // CHECK:STDOUT:   %.loc11_17.2: i32 = bind_value %.loc11_17.1
-// CHECK:STDOUT:   assign %b.var, %.loc11_17.2
+// CHECK:STDOUT:   assign file.%b.var, %.loc11_17.2
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/index/fail_invalid_base.carbon

@@ -46,30 +46,35 @@ var d: i32 = {.a: i32, .b: i32}[0];
 // CHECK:STDOUT:   %.loc11: <namespace> = namespace {} [template]
 // CHECK:STDOUT:   %a.var: ref i32 = var a
 // CHECK:STDOUT:   %a: ref i32 = bind_name a, %a.var
-// CHECK:STDOUT:   %N.ref: <namespace> = name_ref N, %.loc11 [template = %.loc11]
-// CHECK:STDOUT:   %.loc15: i32 = int_literal 0 [template = constants.%.1]
-// CHECK:STDOUT:   assign %a.var, <error>
 // CHECK:STDOUT:   %F: <function> = fn_decl @F [template]
 // CHECK:STDOUT:   %b.var: ref i32 = var b
 // CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
-// CHECK:STDOUT:   %F.ref: <function> = name_ref F, %F [template = %F]
-// CHECK:STDOUT:   %.loc21: i32 = int_literal 1 [template = constants.%.2]
-// CHECK:STDOUT:   assign %b.var, <error>
 // CHECK:STDOUT:   %c.var: ref i32 = var c
 // CHECK:STDOUT:   %c: ref i32 = bind_name c, %c.var
+// CHECK:STDOUT:   %d.var: ref i32 = var d
+// CHECK:STDOUT:   %d: ref i32 = bind_name d, %d.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @F();
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %N.ref: <namespace> = name_ref N, file.%.loc11 [template = file.%.loc11]
+// CHECK:STDOUT:   %.loc15: i32 = int_literal 0 [template = constants.%.1]
+// CHECK:STDOUT:   assign file.%a.var, <error>
+// CHECK:STDOUT:   %F.ref: <function> = name_ref F, file.%F [template = file.%F]
+// CHECK:STDOUT:   %.loc21: i32 = int_literal 1 [template = constants.%.2]
+// CHECK:STDOUT:   assign file.%b.var, <error>
 // CHECK:STDOUT:   %.loc26_20: i32 = int_literal 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc26_28: i32 = int_literal 2 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc26_29.1: {.a: i32, .b: i32} = struct_literal (%.loc26_20, %.loc26_28)
 // CHECK:STDOUT:   %.loc26_31: i32 = int_literal 0 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc26_29.2: {.a: i32, .b: i32} = struct_value (%.loc26_20, %.loc26_28) [template = constants.%.6]
 // CHECK:STDOUT:   %.loc26_29.3: {.a: i32, .b: i32} = converted %.loc26_29.1, %.loc26_29.2 [template = constants.%.6]
-// CHECK:STDOUT:   assign %c.var, <error>
-// CHECK:STDOUT:   %d.var: ref i32 = var d
-// CHECK:STDOUT:   %d: ref i32 = bind_name d, %d.var
+// CHECK:STDOUT:   assign file.%c.var, <error>
 // CHECK:STDOUT:   %.loc31_31: type = struct_type {.a: i32, .b: i32} [template = constants.%.4]
 // CHECK:STDOUT:   %.loc31_33: i32 = int_literal 0 [template = constants.%.1]
-// CHECK:STDOUT:   assign %d.var, <error>
+// CHECK:STDOUT:   assign file.%d.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: fn @F();
-// CHECK:STDOUT:

toolchain/check/testdata/index/fail_non_deterministic_type.carbon

@@ -29,26 +29,31 @@ var c: i32 = a[b];
 // CHECK:STDOUT:   %.loc7_17.2: type = converted %.loc7_17.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref (i32, i32) = var a
 // CHECK:STDOUT:   %a: ref (i32, i32) = bind_name a, %a.var
+// CHECK:STDOUT:   %b.var: ref i32 = var b
+// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT:   %c.var: ref i32 = var c
+// CHECK:STDOUT:   %c: ref i32 = bind_name c, %c.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_22: i32 = int_literal 2 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_25: i32 = int_literal 3 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_26.1: (i32, i32) = tuple_literal (%.loc7_22, %.loc7_25)
-// CHECK:STDOUT:   %.loc7_26.2: ref i32 = tuple_access %a.var, element0
+// CHECK:STDOUT:   %.loc7_26.2: ref i32 = tuple_access file.%a.var, element0
 // CHECK:STDOUT:   %.loc7_26.3: init i32 = initialize_from %.loc7_22 to %.loc7_26.2 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_26.4: ref i32 = tuple_access %a.var, element1
+// CHECK:STDOUT:   %.loc7_26.4: ref i32 = tuple_access file.%a.var, element1
 // CHECK:STDOUT:   %.loc7_26.5: init i32 = initialize_from %.loc7_25 to %.loc7_26.4 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc7_26.6: init (i32, i32) = tuple_init (%.loc7_26.3, %.loc7_26.5) to %a.var [template = constants.%.6]
+// CHECK:STDOUT:   %.loc7_26.6: init (i32, i32) = tuple_init (%.loc7_26.3, %.loc7_26.5) to file.%a.var [template = constants.%.6]
 // CHECK:STDOUT:   %.loc7_26.7: init (i32, i32) = converted %.loc7_26.1, %.loc7_26.6 [template = constants.%.6]
-// CHECK:STDOUT:   assign %a.var, %.loc7_26.7
-// CHECK:STDOUT:   %b.var: ref i32 = var b
-// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_26.7
 // CHECK:STDOUT:   %.loc8: i32 = int_literal 0 [template = constants.%.7]
-// CHECK:STDOUT:   assign %b.var, %.loc8
-// CHECK:STDOUT:   %c.var: ref i32 = var c
-// CHECK:STDOUT:   %c: ref i32 = bind_name c, %c.var
-// CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_ref a, %a
-// CHECK:STDOUT:   %b.ref: ref i32 = name_ref b, %b
+// CHECK:STDOUT:   assign file.%b.var, %.loc8
+// CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_ref a, file.%a
+// CHECK:STDOUT:   %b.ref: ref i32 = name_ref b, file.%b
 // CHECK:STDOUT:   %.loc12_16: i32 = bind_value %b.ref
 // CHECK:STDOUT:   %.loc12_17: ref <error> = tuple_index %a.ref, <error>
-// CHECK:STDOUT:   assign %c.var, <error>
+// CHECK:STDOUT:   assign file.%c.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/index/fail_out_of_bound_not_literal.carbon

@@ -30,25 +30,30 @@ var b: i32 = a[{.index = 2}.index];
 // CHECK:STDOUT:   %.loc7_17.2: type = converted %.loc7_17.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref (i32, i32) = var a
 // CHECK:STDOUT:   %a: ref (i32, i32) = bind_name a, %a.var
+// CHECK:STDOUT:   %b.var: ref i32 = var b
+// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_22: i32 = int_literal 12 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 34 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_28.1: (i32, i32) = tuple_literal (%.loc7_22, %.loc7_26)
-// CHECK:STDOUT:   %.loc7_28.2: ref i32 = tuple_access %a.var, element0
+// CHECK:STDOUT:   %.loc7_28.2: ref i32 = tuple_access file.%a.var, element0
 // CHECK:STDOUT:   %.loc7_28.3: init i32 = initialize_from %.loc7_22 to %.loc7_28.2 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_28.4: ref i32 = tuple_access %a.var, element1
+// CHECK:STDOUT:   %.loc7_28.4: ref i32 = tuple_access file.%a.var, element1
 // CHECK:STDOUT:   %.loc7_28.5: init i32 = initialize_from %.loc7_26 to %.loc7_28.4 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc7_28.6: init (i32, i32) = tuple_init (%.loc7_28.3, %.loc7_28.5) to %a.var [template = constants.%.6]
+// CHECK:STDOUT:   %.loc7_28.6: init (i32, i32) = tuple_init (%.loc7_28.3, %.loc7_28.5) to file.%a.var [template = constants.%.6]
 // CHECK:STDOUT:   %.loc7_28.7: init (i32, i32) = converted %.loc7_28.1, %.loc7_28.6 [template = constants.%.6]
-// CHECK:STDOUT:   assign %a.var, %.loc7_28.7
-// CHECK:STDOUT:   %b.var: ref i32 = var b
-// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_ref a, %a
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_28.7
+// CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc11_26: i32 = int_literal 2 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc11_27.1: {.index: i32} = struct_literal (%.loc11_26)
 // CHECK:STDOUT:   %.loc11_27.2: {.index: i32} = struct_value (%.loc11_26) [template = constants.%.9]
 // CHECK:STDOUT:   %.loc11_27.3: {.index: i32} = converted %.loc11_27.1, %.loc11_27.2 [template = constants.%.9]
 // CHECK:STDOUT:   %.loc11_28: i32 = struct_access %.loc11_27.3, element0 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc11_34: ref <error> = tuple_index %a.ref, <error>
-// CHECK:STDOUT:   assign %b.var, <error>
+// CHECK:STDOUT:   assign file.%b.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/index/fail_tuple_index_error.carbon

@@ -27,21 +27,26 @@ var b: i32 = a[oops];
 // CHECK:STDOUT:   %.loc7_17.2: type = converted %.loc7_17.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref (i32, i32) = var a
 // CHECK:STDOUT:   %a: ref (i32, i32) = bind_name a, %a.var
+// CHECK:STDOUT:   %b.var: ref i32 = var b
+// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_22: i32 = int_literal 12 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 6 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_27.1: (i32, i32) = tuple_literal (%.loc7_22, %.loc7_26)
-// CHECK:STDOUT:   %.loc7_27.2: ref i32 = tuple_access %a.var, element0
+// CHECK:STDOUT:   %.loc7_27.2: ref i32 = tuple_access file.%a.var, element0
 // CHECK:STDOUT:   %.loc7_27.3: init i32 = initialize_from %.loc7_22 to %.loc7_27.2 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_27.4: ref i32 = tuple_access %a.var, element1
+// CHECK:STDOUT:   %.loc7_27.4: ref i32 = tuple_access file.%a.var, element1
 // CHECK:STDOUT:   %.loc7_27.5: init i32 = initialize_from %.loc7_26 to %.loc7_27.4 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc7_27.6: init (i32, i32) = tuple_init (%.loc7_27.3, %.loc7_27.5) to %a.var [template = constants.%.6]
+// CHECK:STDOUT:   %.loc7_27.6: init (i32, i32) = tuple_init (%.loc7_27.3, %.loc7_27.5) to file.%a.var [template = constants.%.6]
 // CHECK:STDOUT:   %.loc7_27.7: init (i32, i32) = converted %.loc7_27.1, %.loc7_27.6 [template = constants.%.6]
-// CHECK:STDOUT:   assign %a.var, %.loc7_27.7
-// CHECK:STDOUT:   %b.var: ref i32 = var b
-// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_ref a, %a
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_27.7
+// CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_ref a, file.%a
 // CHECK:STDOUT:   %oops.ref: <error> = name_ref oops, <error> [template = <error>]
 // CHECK:STDOUT:   %.loc11: ref <error> = tuple_index %a.ref, <error>
-// CHECK:STDOUT:   assign %b.var, <error>
+// CHECK:STDOUT:   assign file.%b.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/index/fail_tuple_large_index.carbon

@@ -27,26 +27,31 @@ var c: i32 = b[0xFFFFFFFFFFFFFFFFF];
 // CHECK:STDOUT:   %.loc7_13.2: type = converted %.loc7_13.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref (i32,) = var a
 // CHECK:STDOUT:   %a: ref (i32,) = bind_name a, %a.var
-// CHECK:STDOUT:   %.loc7_18: i32 = int_literal 12 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc7_21.1: (i32,) = tuple_literal (%.loc7_18)
-// CHECK:STDOUT:   %.loc7_21.2: init (i32,) = tuple_init (%.loc7_18) to %a.var [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_21.3: init (i32,) = converted %.loc7_21.1, %.loc7_21.2 [template = constants.%.4]
-// CHECK:STDOUT:   assign %a.var, %.loc7_21.3
 // CHECK:STDOUT:   %.loc8_13.1: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc8_13.2: type = converted %.loc8_13.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %b.var: ref (i32,) = var b
 // CHECK:STDOUT:   %b: ref (i32,) = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref (i32,) = name_ref a, %a
+// CHECK:STDOUT:   %c.var: ref i32 = var c
+// CHECK:STDOUT:   %c: ref i32 = bind_name c, %c.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc7_18: i32 = int_literal 12 [template = constants.%.3]
+// CHECK:STDOUT:   %.loc7_21.1: (i32,) = tuple_literal (%.loc7_18)
+// CHECK:STDOUT:   %.loc7_21.2: init (i32,) = tuple_init (%.loc7_18) to file.%a.var [template = constants.%.4]
+// CHECK:STDOUT:   %.loc7_21.3: init (i32,) = converted %.loc7_21.1, %.loc7_21.2 [template = constants.%.4]
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_21.3
+// CHECK:STDOUT:   %a.ref: ref (i32,) = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc8_17.1: ref i32 = tuple_access %a.ref, element0
 // CHECK:STDOUT:   %.loc8_17.2: i32 = bind_value %.loc8_17.1
-// CHECK:STDOUT:   %.loc8_17.3: init (i32,) = tuple_init (%.loc8_17.2) to %b.var
+// CHECK:STDOUT:   %.loc8_17.3: init (i32,) = tuple_init (%.loc8_17.2) to file.%b.var
 // CHECK:STDOUT:   %.loc8_17.4: init (i32,) = converted %a.ref, %.loc8_17.3
-// CHECK:STDOUT:   assign %b.var, %.loc8_17.4
-// CHECK:STDOUT:   %c.var: ref i32 = var c
-// CHECK:STDOUT:   %c: ref i32 = bind_name c, %c.var
-// CHECK:STDOUT:   %b.ref: ref (i32,) = name_ref b, %b
+// CHECK:STDOUT:   assign file.%b.var, %.loc8_17.4
+// CHECK:STDOUT:   %b.ref: ref (i32,) = name_ref b, file.%b
 // CHECK:STDOUT:   %.loc12_16: i32 = int_literal 295147905179352825855 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc12_35: ref <error> = tuple_index %b.ref, <error>
-// CHECK:STDOUT:   assign %c.var, <error>
+// CHECK:STDOUT:   assign file.%c.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/index/fail_tuple_non_int_indexing.carbon

@@ -28,21 +28,26 @@ var b: i32 = a[2.6];
 // CHECK:STDOUT:   %.loc7_17.2: type = converted %.loc7_17.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref (i32, i32) = var a
 // CHECK:STDOUT:   %a: ref (i32, i32) = bind_name a, %a.var
+// CHECK:STDOUT:   %b.var: ref i32 = var b
+// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_22: i32 = int_literal 12 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 6 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_27.1: (i32, i32) = tuple_literal (%.loc7_22, %.loc7_26)
-// CHECK:STDOUT:   %.loc7_27.2: ref i32 = tuple_access %a.var, element0
+// CHECK:STDOUT:   %.loc7_27.2: ref i32 = tuple_access file.%a.var, element0
 // CHECK:STDOUT:   %.loc7_27.3: init i32 = initialize_from %.loc7_22 to %.loc7_27.2 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_27.4: ref i32 = tuple_access %a.var, element1
+// CHECK:STDOUT:   %.loc7_27.4: ref i32 = tuple_access file.%a.var, element1
 // CHECK:STDOUT:   %.loc7_27.5: init i32 = initialize_from %.loc7_26 to %.loc7_27.4 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc7_27.6: init (i32, i32) = tuple_init (%.loc7_27.3, %.loc7_27.5) to %a.var [template = constants.%.6]
+// CHECK:STDOUT:   %.loc7_27.6: init (i32, i32) = tuple_init (%.loc7_27.3, %.loc7_27.5) to file.%a.var [template = constants.%.6]
 // CHECK:STDOUT:   %.loc7_27.7: init (i32, i32) = converted %.loc7_27.1, %.loc7_27.6 [template = constants.%.6]
-// CHECK:STDOUT:   assign %a.var, %.loc7_27.7
-// CHECK:STDOUT:   %b.var: ref i32 = var b
-// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_ref a, %a
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_27.7
+// CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc11_16: f64 = real_literal 26e-1 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc11_19: ref <error> = tuple_index %a.ref, <error>
-// CHECK:STDOUT:   assign %b.var, <error>
+// CHECK:STDOUT:   assign file.%b.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/index/fail_tuple_out_of_bound_access.carbon

@@ -28,21 +28,26 @@ var b: i32 = a[2];
 // CHECK:STDOUT:   %.loc7_17.2: type = converted %.loc7_17.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref (i32, i32) = var a
 // CHECK:STDOUT:   %a: ref (i32, i32) = bind_name a, %a.var
+// CHECK:STDOUT:   %b.var: ref i32 = var b
+// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_22: i32 = int_literal 12 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 6 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_27.1: (i32, i32) = tuple_literal (%.loc7_22, %.loc7_26)
-// CHECK:STDOUT:   %.loc7_27.2: ref i32 = tuple_access %a.var, element0
+// CHECK:STDOUT:   %.loc7_27.2: ref i32 = tuple_access file.%a.var, element0
 // CHECK:STDOUT:   %.loc7_27.3: init i32 = initialize_from %.loc7_22 to %.loc7_27.2 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_27.4: ref i32 = tuple_access %a.var, element1
+// CHECK:STDOUT:   %.loc7_27.4: ref i32 = tuple_access file.%a.var, element1
 // CHECK:STDOUT:   %.loc7_27.5: init i32 = initialize_from %.loc7_26 to %.loc7_27.4 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc7_27.6: init (i32, i32) = tuple_init (%.loc7_27.3, %.loc7_27.5) to %a.var [template = constants.%.6]
+// CHECK:STDOUT:   %.loc7_27.6: init (i32, i32) = tuple_init (%.loc7_27.3, %.loc7_27.5) to file.%a.var [template = constants.%.6]
 // CHECK:STDOUT:   %.loc7_27.7: init (i32, i32) = converted %.loc7_27.1, %.loc7_27.6 [template = constants.%.6]
-// CHECK:STDOUT:   assign %a.var, %.loc7_27.7
-// CHECK:STDOUT:   %b.var: ref i32 = var b
-// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_ref a, %a
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_27.7
+// CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc11_16: i32 = int_literal 2 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc11_17: ref <error> = tuple_index %a.ref, <error>
-// CHECK:STDOUT:   assign %b.var, <error>
+// CHECK:STDOUT:   assign file.%b.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/index/index_not_literal.carbon

@@ -27,19 +27,23 @@ var b: i32 = a[{.index = 1}.index];
 // CHECK:STDOUT:   %.loc7_17.2: type = converted %.loc7_17.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref (i32, i32) = var a
 // CHECK:STDOUT:   %a: ref (i32, i32) = bind_name a, %a.var
+// CHECK:STDOUT:   %b.var: ref i32 = var b
+// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_22: i32 = int_literal 12 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 34 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_28.1: (i32, i32) = tuple_literal (%.loc7_22, %.loc7_26)
-// CHECK:STDOUT:   %.loc7_28.2: ref i32 = tuple_access %a.var, element0
+// CHECK:STDOUT:   %.loc7_28.2: ref i32 = tuple_access file.%a.var, element0
 // CHECK:STDOUT:   %.loc7_28.3: init i32 = initialize_from %.loc7_22 to %.loc7_28.2 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_28.4: ref i32 = tuple_access %a.var, element1
+// CHECK:STDOUT:   %.loc7_28.4: ref i32 = tuple_access file.%a.var, element1
 // CHECK:STDOUT:   %.loc7_28.5: init i32 = initialize_from %.loc7_26 to %.loc7_28.4 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc7_28.6: init (i32, i32) = tuple_init (%.loc7_28.3, %.loc7_28.5) to %a.var [template = constants.%.6]
+// CHECK:STDOUT:   %.loc7_28.6: init (i32, i32) = tuple_init (%.loc7_28.3, %.loc7_28.5) to file.%a.var [template = constants.%.6]
 // CHECK:STDOUT:   %.loc7_28.7: init (i32, i32) = converted %.loc7_28.1, %.loc7_28.6 [template = constants.%.6]
-// CHECK:STDOUT:   assign %a.var, %.loc7_28.7
-// CHECK:STDOUT:   %b.var: ref i32 = var b
-// CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_ref a, %a
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_28.7
+// CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc8_26: i32 = int_literal 1 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc8_27.1: {.index: i32} = struct_literal (%.loc8_26)
 // CHECK:STDOUT:   %.loc8_27.2: {.index: i32} = struct_value (%.loc8_26) [template = constants.%.9]
@@ -47,6 +51,7 @@ var b: i32 = a[{.index = 1}.index];
 // CHECK:STDOUT:   %.loc8_28: i32 = struct_access %.loc8_27.3, element0 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc8_34.1: ref i32 = tuple_index %a.ref, %.loc8_28
 // CHECK:STDOUT:   %.loc8_34.2: i32 = bind_value %.loc8_34.1
-// CHECK:STDOUT:   assign %b.var, %.loc8_34.2
+// CHECK:STDOUT:   assign file.%b.var, %.loc8_34.2
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/index/tuple_element_access.carbon

@@ -24,27 +24,32 @@ var c: i32 = b[0];
 // CHECK:STDOUT:   %.loc7_13.2: type = converted %.loc7_13.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref (i32,) = var a
 // CHECK:STDOUT:   %a: ref (i32,) = bind_name a, %a.var
-// CHECK:STDOUT:   %.loc7_18: i32 = int_literal 12 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc7_21.1: (i32,) = tuple_literal (%.loc7_18)
-// CHECK:STDOUT:   %.loc7_21.2: init (i32,) = tuple_init (%.loc7_18) to %a.var [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_21.3: init (i32,) = converted %.loc7_21.1, %.loc7_21.2 [template = constants.%.4]
-// CHECK:STDOUT:   assign %a.var, %.loc7_21.3
 // CHECK:STDOUT:   %.loc8_13.1: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc8_13.2: type = converted %.loc8_13.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %b.var: ref (i32,) = var b
 // CHECK:STDOUT:   %b: ref (i32,) = bind_name b, %b.var
-// CHECK:STDOUT:   %a.ref: ref (i32,) = name_ref a, %a
+// CHECK:STDOUT:   %c.var: ref i32 = var c
+// CHECK:STDOUT:   %c: ref i32 = bind_name c, %c.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc7_18: i32 = int_literal 12 [template = constants.%.3]
+// CHECK:STDOUT:   %.loc7_21.1: (i32,) = tuple_literal (%.loc7_18)
+// CHECK:STDOUT:   %.loc7_21.2: init (i32,) = tuple_init (%.loc7_18) to file.%a.var [template = constants.%.4]
+// CHECK:STDOUT:   %.loc7_21.3: init (i32,) = converted %.loc7_21.1, %.loc7_21.2 [template = constants.%.4]
+// CHECK:STDOUT:   assign file.%a.var, %.loc7_21.3
+// CHECK:STDOUT:   %a.ref: ref (i32,) = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc8_17.1: ref i32 = tuple_access %a.ref, element0
 // CHECK:STDOUT:   %.loc8_17.2: i32 = bind_value %.loc8_17.1
-// CHECK:STDOUT:   %.loc8_17.3: init (i32,) = tuple_init (%.loc8_17.2) to %b.var
+// CHECK:STDOUT:   %.loc8_17.3: init (i32,) = tuple_init (%.loc8_17.2) to file.%b.var
 // CHECK:STDOUT:   %.loc8_17.4: init (i32,) = converted %a.ref, %.loc8_17.3
-// CHECK:STDOUT:   assign %b.var, %.loc8_17.4
-// CHECK:STDOUT:   %c.var: ref i32 = var c
-// CHECK:STDOUT:   %c: ref i32 = bind_name c, %c.var
-// CHECK:STDOUT:   %b.ref: ref (i32,) = name_ref b, %b
+// CHECK:STDOUT:   assign file.%b.var, %.loc8_17.4
+// CHECK:STDOUT:   %b.ref: ref (i32,) = name_ref b, file.%b
 // CHECK:STDOUT:   %.loc9_16: i32 = int_literal 0 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc9_17.1: ref i32 = tuple_index %b.ref, %.loc9_16
 // CHECK:STDOUT:   %.loc9_17.2: i32 = bind_value %.loc9_17.1
-// CHECK:STDOUT:   assign %c.var, %.loc9_17.2
+// CHECK:STDOUT:   assign file.%c.var, %.loc9_17.2
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/namespace/add_to_import.carbon

@@ -38,10 +38,6 @@ var a: i32 = NS.A();
 // CHECK:STDOUT:   %A: <function> = fn_decl @A [template]
 // CHECK:STDOUT:   %a.var: ref i32 = var a
 // CHECK:STDOUT:   %a: ref i32 = bind_name a, %a.var
-// CHECK:STDOUT:   %NS.ref: <namespace> = name_ref NS, %.2 [template = %.2]
-// CHECK:STDOUT:   %A.ref: <function> = name_ref A, %A [template = %A]
-// CHECK:STDOUT:   %.loc6: init i32 = call %A.ref()
-// CHECK:STDOUT:   assign %a.var, %.loc6
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @A() -> i32 {
@@ -50,3 +46,12 @@ var a: i32 = NS.A();
 // CHECK:STDOUT:   return %.loc4
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %NS.ref: <namespace> = name_ref NS, file.%.2 [template = file.%.2]
+// CHECK:STDOUT:   %A.ref: <function> = name_ref A, file.%A [template = file.%A]
+// CHECK:STDOUT:   %.loc6: init i32 = call %A.ref()
+// CHECK:STDOUT:   assign file.%a.var, %.loc6
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/namespace/fail_todo_imported.carbon

@@ -68,33 +68,38 @@ var package_b: () = package.NS.ChildNS.B();
 // CHECK:STDOUT:   %.loc7_9.2: type = converted %.loc7_9.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %a.var: ref () = var a
 // CHECK:STDOUT:   %a: ref () = bind_name a, %a.var
-// CHECK:STDOUT:   %NS.ref.loc7: <namespace> = name_ref NS, %.2 [template = %.2]
-// CHECK:STDOUT:   %A.ref.loc7: <function> = name_ref A, %import_ref.3
-// CHECK:STDOUT:   assign %a.var, <error>
 // CHECK:STDOUT:   %.loc11_9.1: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc11_9.2: type = converted %.loc11_9.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %b.var: ref () = var b
 // CHECK:STDOUT:   %b: ref () = bind_name b, %b.var
-// CHECK:STDOUT:   %NS.ref.loc11: <namespace> = name_ref NS, %.2 [template = %.2]
-// CHECK:STDOUT:   %ChildNS.ref.loc11: <namespace> = name_ref ChildNS, %.3 [template = %.3]
-// CHECK:STDOUT:   %B.ref.loc11: <function> = name_ref B, %import_ref.4
-// CHECK:STDOUT:   assign %b.var, <error>
 // CHECK:STDOUT:   %.loc16_17.1: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc16_17.2: type = converted %.loc16_17.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %package_a.var: ref () = var package_a
 // CHECK:STDOUT:   %package_a: ref () = bind_name package_a, %package_a.var
-// CHECK:STDOUT:   %package.ref.loc16: <namespace> = name_ref package, package [template = package]
-// CHECK:STDOUT:   %NS.ref.loc16: <namespace> = name_ref NS, %.2 [template = %.2]
-// CHECK:STDOUT:   %A.ref.loc16: <function> = name_ref A, %import_ref.3
-// CHECK:STDOUT:   assign %package_a.var, <error>
 // CHECK:STDOUT:   %.loc20_17.1: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc20_17.2: type = converted %.loc20_17.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %package_b.var: ref () = var package_b
 // CHECK:STDOUT:   %package_b: ref () = bind_name package_b, %package_b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %NS.ref.loc7: <namespace> = name_ref NS, file.%.2 [template = file.%.2]
+// CHECK:STDOUT:   %A.ref.loc7: <function> = name_ref A, file.%import_ref.3
+// CHECK:STDOUT:   assign file.%a.var, <error>
+// CHECK:STDOUT:   %NS.ref.loc11: <namespace> = name_ref NS, file.%.2 [template = file.%.2]
+// CHECK:STDOUT:   %ChildNS.ref.loc11: <namespace> = name_ref ChildNS, file.%.3 [template = file.%.3]
+// CHECK:STDOUT:   %B.ref.loc11: <function> = name_ref B, file.%import_ref.4
+// CHECK:STDOUT:   assign file.%b.var, <error>
+// CHECK:STDOUT:   %package.ref.loc16: <namespace> = name_ref package, package [template = package]
+// CHECK:STDOUT:   %NS.ref.loc16: <namespace> = name_ref NS, file.%.2 [template = file.%.2]
+// CHECK:STDOUT:   %A.ref.loc16: <function> = name_ref A, file.%import_ref.3
+// CHECK:STDOUT:   assign file.%package_a.var, <error>
 // CHECK:STDOUT:   %package.ref.loc20: <namespace> = name_ref package, package [template = package]
-// CHECK:STDOUT:   %NS.ref.loc20: <namespace> = name_ref NS, %.2 [template = %.2]
-// CHECK:STDOUT:   %ChildNS.ref.loc20: <namespace> = name_ref ChildNS, %.3 [template = %.3]
-// CHECK:STDOUT:   %B.ref.loc20: <function> = name_ref B, %import_ref.4
-// CHECK:STDOUT:   assign %package_b.var, <error>
+// CHECK:STDOUT:   %NS.ref.loc20: <namespace> = name_ref NS, file.%.2 [template = file.%.2]
+// CHECK:STDOUT:   %ChildNS.ref.loc20: <namespace> = name_ref ChildNS, file.%.3 [template = file.%.3]
+// CHECK:STDOUT:   %B.ref.loc20: <function> = name_ref B, file.%import_ref.4
+// CHECK:STDOUT:   assign file.%package_b.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/namespace/fail_todo_imported_indirect.carbon

@@ -105,10 +105,15 @@ var e: () = A.B.C.D();
 // CHECK:STDOUT:   %.loc8_9.2: type = converted %.loc8_9.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %e.var: ref () = var e
 // CHECK:STDOUT:   %e: ref () = bind_name e, %e.var
-// CHECK:STDOUT:   %A.ref: <namespace> = name_ref A, %.2 [template = %.2]
-// CHECK:STDOUT:   %B.ref: <namespace> = name_ref B, %.3 [template = %.3]
-// CHECK:STDOUT:   %C.ref: <namespace> = name_ref C, %.4 [template = %.4]
-// CHECK:STDOUT:   %D.ref: <function> = name_ref D, %import_ref.4
-// CHECK:STDOUT:   assign %e.var, <error>
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %A.ref: <namespace> = name_ref A, file.%.2 [template = file.%.2]
+// CHECK:STDOUT:   %B.ref: <namespace> = name_ref B, file.%.3 [template = file.%.3]
+// CHECK:STDOUT:   %C.ref: <namespace> = name_ref C, file.%.4 [template = file.%.4]
+// CHECK:STDOUT:   %D.ref: <function> = name_ref D, file.%import_ref.4
+// CHECK:STDOUT:   assign file.%e.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/operators/fail_and_or_not_in_function.carbon

@@ -40,7 +40,7 @@ var or_: F(true or true);
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
-// CHECK:STDOUT:   %.loc33_17: bool = block_arg <unexpected instblockref block13>
+// CHECK:STDOUT:   %.loc33_17: bool = block_arg <unexpected instblockref block14>
 // CHECK:STDOUT:   %.loc33_11.1: init type = call <unexpected instref inst+27>(%.loc33_17)
 // CHECK:STDOUT:   %.loc33_24: type = value_of_initializer %.loc33_11.1
 // CHECK:STDOUT:   %.loc33_11.2: type = converted %.loc33_11.1, %.loc33_24

toolchain/check/testdata/package_expr/syntax.carbon

@@ -53,8 +53,6 @@ fn Main() {
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x, .Main = %Main} [template]
 // CHECK:STDOUT:   %x.var: ref i32 = var x
 // CHECK:STDOUT:   %x: ref i32 = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc4: i32 = int_literal 0 [template = constants.%.1]
-// CHECK:STDOUT:   assign %x.var, %.loc4
 // CHECK:STDOUT:   %Main: <function> = fn_decl @Main [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -73,6 +71,13 @@ fn Main() {
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc4: i32 = int_literal 0 [template = constants.%.1]
+// CHECK:STDOUT:   assign file.%x.var, %.loc4
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
 // CHECK:STDOUT: --- inside_fn.carbon
 // CHECK:STDOUT:
 // CHECK:STDOUT: constants {
@@ -84,8 +89,6 @@ fn Main() {
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x, .Main = %Main} [template]
 // CHECK:STDOUT:   %x.var: ref i32 = var x
 // CHECK:STDOUT:   %x: ref i32 = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc4: i32 = int_literal 0 [template = constants.%.1]
-// CHECK:STDOUT:   assign %x.var, %.loc4
 // CHECK:STDOUT:   %Main: <function> = fn_decl @Main [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -104,6 +107,13 @@ fn Main() {
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc4: i32 = int_literal 0 [template = constants.%.1]
+// CHECK:STDOUT:   assign file.%x.var, %.loc4
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
 // CHECK:STDOUT: --- namespace.carbon
 // CHECK:STDOUT:
 // CHECK:STDOUT: constants {

toolchain/check/testdata/packages/fail_import_type_error.carbon

@@ -67,19 +67,24 @@ var d: i32 = d_ref;
 // CHECK:STDOUT:   %import_ref.4: ref <error> = import_ref ir1, inst+16, used
 // CHECK:STDOUT:   %a.var: ref i32 = var a
 // CHECK:STDOUT:   %a: ref i32 = bind_name a, %a.var
-// CHECK:STDOUT:   %a_ref.ref: ref <error> = name_ref a_ref, %import_ref.1
-// CHECK:STDOUT:   assign %a.var, <error>
 // CHECK:STDOUT:   %b.var: ref i32 = var b
 // CHECK:STDOUT:   %b: ref i32 = bind_name b, %b.var
-// CHECK:STDOUT:   %b_ref.ref: ref <error> = name_ref b_ref, %import_ref.2
-// CHECK:STDOUT:   assign %b.var, <error>
 // CHECK:STDOUT:   %c.var: ref i32 = var c
 // CHECK:STDOUT:   %c: ref i32 = bind_name c, %c.var
-// CHECK:STDOUT:   %c_ref.ref: ref <error> = name_ref c_ref, %import_ref.3
-// CHECK:STDOUT:   assign %c.var, <error>
 // CHECK:STDOUT:   %d.var: ref i32 = var d
 // CHECK:STDOUT:   %d: ref i32 = bind_name d, %d.var
-// CHECK:STDOUT:   %d_ref.ref: ref <error> = name_ref d_ref, %import_ref.4
-// CHECK:STDOUT:   assign %d.var, <error>
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %a_ref.ref: ref <error> = name_ref a_ref, file.%import_ref.1
+// CHECK:STDOUT:   assign file.%a.var, <error>
+// CHECK:STDOUT:   %b_ref.ref: ref <error> = name_ref b_ref, file.%import_ref.2
+// CHECK:STDOUT:   assign file.%b.var, <error>
+// CHECK:STDOUT:   %c_ref.ref: ref <error> = name_ref c_ref, file.%import_ref.3
+// CHECK:STDOUT:   assign file.%c.var, <error>
+// CHECK:STDOUT:   %d_ref.ref: ref <error> = name_ref d_ref, file.%import_ref.4
+// CHECK:STDOUT:   assign file.%d.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/packages/fail_name_with_import_failure.carbon

@@ -25,7 +25,12 @@ var a: () = A();
 // CHECK:STDOUT:   %.loc7_9.2: type = converted %.loc7_9.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %a.var: ref () = var a
 // CHECK:STDOUT:   %a: ref () = bind_name a, %a.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %A.ref: <error> = name_ref A, <error> [template = <error>]
-// CHECK:STDOUT:   assign %a.var, <error>
+// CHECK:STDOUT:   assign file.%a.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/packages/fail_todo_loaded_global.carbon

@@ -68,15 +68,20 @@ var package_b: () = package.B();
 // CHECK:STDOUT:   %.loc7_9.2: type = converted %.loc7_9.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %a.var: ref () = var a
 // CHECK:STDOUT:   %a: ref () = bind_name a, %a.var
-// CHECK:STDOUT:   %A.ref.loc7: <function> = name_ref A, %import_ref
-// CHECK:STDOUT:   assign %a.var, <error>
 // CHECK:STDOUT:   %.loc12_17.1: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc12_17.2: type = converted %.loc12_17.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %package_a.var: ref () = var package_a
 // CHECK:STDOUT:   %package_a: ref () = bind_name package_a, %package_a.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %A.ref.loc7: <function> = name_ref A, file.%import_ref
+// CHECK:STDOUT:   assign file.%a.var, <error>
 // CHECK:STDOUT:   %package.ref: <namespace> = name_ref package, package [template = package]
-// CHECK:STDOUT:   %A.ref.loc12: <function> = name_ref A, %import_ref
-// CHECK:STDOUT:   assign %package_a.var, <error>
+// CHECK:STDOUT:   %A.ref.loc12: <function> = name_ref A, file.%import_ref
+// CHECK:STDOUT:   assign file.%package_a.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: --- same_package.carbon
@@ -101,14 +106,19 @@ var package_b: () = package.B();
 // CHECK:STDOUT:   %.loc9_9.2: type = converted %.loc9_9.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %b.var: ref () = var b
 // CHECK:STDOUT:   %b: ref () = bind_name b, %b.var
-// CHECK:STDOUT:   %B.ref.loc9: <function> = name_ref B, %import_ref
-// CHECK:STDOUT:   assign %b.var, <error>
 // CHECK:STDOUT:   %.loc14_17.1: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc14_17.2: type = converted %.loc14_17.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %package_b.var: ref () = var package_b
 // CHECK:STDOUT:   %package_b: ref () = bind_name package_b, %package_b.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %B.ref.loc9: <function> = name_ref B, file.%import_ref
+// CHECK:STDOUT:   assign file.%b.var, <error>
 // CHECK:STDOUT:   %package.ref: <namespace> = name_ref package, package [template = package]
-// CHECK:STDOUT:   %B.ref.loc14: <function> = name_ref B, %import_ref
-// CHECK:STDOUT:   assign %package_b.var, <error>
+// CHECK:STDOUT:   %B.ref.loc14: <function> = name_ref B, file.%import_ref
+// CHECK:STDOUT:   assign file.%package_b.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/pointer/import.carbon

@@ -28,14 +28,19 @@ var a: i32* = a_ref;
 // CHECK:STDOUT:   package: <namespace> = namespace {.a_orig = %a_orig, .a_ref = %a_ref} [template]
 // CHECK:STDOUT:   %a_orig.var: ref i32 = var a_orig
 // CHECK:STDOUT:   %a_orig: ref i32 = bind_name a_orig, %a_orig.var
-// CHECK:STDOUT:   %.loc4: i32 = int_literal 0 [template = constants.%.1]
-// CHECK:STDOUT:   assign %a_orig.var, %.loc4
-// CHECK:STDOUT:   %.loc5_15: type = ptr_type i32 [template = constants.%.2]
+// CHECK:STDOUT:   %.loc5: type = ptr_type i32 [template = constants.%.2]
 // CHECK:STDOUT:   %a_ref.var: ref i32* = var a_ref
 // CHECK:STDOUT:   %a_ref: ref i32* = bind_name a_ref, %a_ref.var
-// CHECK:STDOUT:   %a_orig.ref: ref i32 = name_ref a_orig, %a_orig
-// CHECK:STDOUT:   %.loc5_19: i32* = addr_of %a_orig.ref
-// CHECK:STDOUT:   assign %a_ref.var, %.loc5_19
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc4: i32 = int_literal 0 [template = constants.%.1]
+// CHECK:STDOUT:   assign file.%a_orig.var, %.loc4
+// CHECK:STDOUT:   %a_orig.ref: ref i32 = name_ref a_orig, file.%a_orig
+// CHECK:STDOUT:   %.loc5: i32* = addr_of %a_orig.ref
+// CHECK:STDOUT:   assign file.%a_ref.var, %.loc5
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: --- implicit.impl.carbon
@@ -48,11 +53,16 @@ var a: i32* = a_ref;
 // CHECK:STDOUT:   package: <namespace> = namespace {.a_orig = %import_ref.1, .a_ref = %import_ref.2, .a = %a} [template]
 // CHECK:STDOUT:   %import_ref.1 = import_ref ir1, inst+2, unused
 // CHECK:STDOUT:   %import_ref.2: ref i32* = import_ref ir1, inst+9, used
-// CHECK:STDOUT:   %.loc4_11: type = ptr_type i32 [template = constants.%.1]
+// CHECK:STDOUT:   %.loc4: type = ptr_type i32 [template = constants.%.1]
 // CHECK:STDOUT:   %a.var: ref i32* = var a
 // CHECK:STDOUT:   %a: ref i32* = bind_name a, %a.var
-// CHECK:STDOUT:   %a_ref.ref: ref i32* = name_ref a_ref, %import_ref.2
-// CHECK:STDOUT:   %.loc4_15: i32* = bind_value %a_ref.ref
-// CHECK:STDOUT:   assign %a.var, %.loc4_15
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %a_ref.ref: ref i32* = name_ref a_ref, file.%import_ref.2
+// CHECK:STDOUT:   %.loc4: i32* = bind_value %a_ref.ref
+// CHECK:STDOUT:   assign file.%a.var, %.loc4
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/return/fail_var_in_type.carbon

@@ -20,7 +20,6 @@ fn Six() -> x { return 6; }
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x, .Six = %Six} [template]
 // CHECK:STDOUT:   %x.var: ref type = var x
 // CHECK:STDOUT:   %x: ref type = bind_name x, %x.var
-// CHECK:STDOUT:   assign %x.var, i32
 // CHECK:STDOUT:   %Six: <function> = fn_decl @Six [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -30,3 +29,9 @@ fn Six() -> x { return 6; }
 // CHECK:STDOUT:   return <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   assign file.%x.var, i32
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/struct/empty.carbon

@@ -21,17 +21,22 @@ var y: {} = x;
 // CHECK:STDOUT:   %.loc7_9.2: type = converted %.loc7_9.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref {} = var x
 // CHECK:STDOUT:   %x: ref {} = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc7_14.1: {} = struct_literal ()
-// CHECK:STDOUT:   %.loc7_14.2: init {} = struct_init () to %x.var [template = constants.%.3]
-// CHECK:STDOUT:   %.loc7_14.3: init {} = converted %.loc7_14.1, %.loc7_14.2 [template = constants.%.3]
-// CHECK:STDOUT:   assign %x.var, %.loc7_14.3
 // CHECK:STDOUT:   %.loc8_9.1: {} = struct_literal ()
 // CHECK:STDOUT:   %.loc8_9.2: type = converted %.loc8_9.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %y.var: ref {} = var y
 // CHECK:STDOUT:   %y: ref {} = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref {} = name_ref x, %x
-// CHECK:STDOUT:   %.loc8_13.1: init {} = struct_init () to %y.var [template = constants.%.3]
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc7_14.1: {} = struct_literal ()
+// CHECK:STDOUT:   %.loc7_14.2: init {} = struct_init () to file.%x.var [template = constants.%.3]
+// CHECK:STDOUT:   %.loc7_14.3: init {} = converted %.loc7_14.1, %.loc7_14.2 [template = constants.%.3]
+// CHECK:STDOUT:   assign file.%x.var, %.loc7_14.3
+// CHECK:STDOUT:   %x.ref: ref {} = name_ref x, file.%x
+// CHECK:STDOUT:   %.loc8_13.1: init {} = struct_init () to file.%y.var [template = constants.%.3]
 // CHECK:STDOUT:   %.loc8_13.2: init {} = converted %x.ref, %.loc8_13.1 [template = constants.%.3]
-// CHECK:STDOUT:   assign %y.var, %.loc8_13.2
+// CHECK:STDOUT:   assign file.%y.var, %.loc8_13.2
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/fail_assign_empty.carbon

@@ -18,10 +18,15 @@ var x: {.a: i32} = {};
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x} [template]
-// CHECK:STDOUT:   %.loc10_16: type = struct_type {.a: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %.loc10: type = struct_type {.a: i32} [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref {.a: i32} = var x
 // CHECK:STDOUT:   %x: ref {.a: i32} = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc10_21: {} = struct_literal ()
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc10: {} = struct_literal ()
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/fail_assign_nested.carbon

@@ -26,8 +26,13 @@ var x: {.a: {}} = {.b = {}};
 // CHECK:STDOUT:   %.loc10_15: type = struct_type {.a: {}} [template = constants.%.2]
 // CHECK:STDOUT:   %x.var: ref {.a: {}} = var x
 // CHECK:STDOUT:   %x: ref {.a: {}} = bind_name x, %x.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_26: {} = struct_literal ()
 // CHECK:STDOUT:   %.loc10_27: {.b: {}} = struct_literal (%.loc10_26)
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/fail_assign_to_empty.carbon

@@ -24,8 +24,13 @@ var x: {} = {.a = 1};
 // CHECK:STDOUT:   %.loc10_9.2: type = converted %.loc10_9.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref {} = var x
 // CHECK:STDOUT:   %x: ref {} = bind_name x, %x.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_19: i32 = int_literal 1 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc10_20: {.a: i32} = struct_literal (%.loc10_19)
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/fail_duplicate_name.carbon

@@ -65,19 +65,24 @@ var y: {.b: i32, .c: i32} = {.b = 3, .b = 4};
 // CHECK:STDOUT:   %.loc29_22: i32 = int_literal 1 [template = constants.%.1]
 // CHECK:STDOUT:   %.loc29_32: i32 = int_literal 2 [template = constants.%.3]
 // CHECK:STDOUT:   %w: i32 = bind_name w, <error>
-// CHECK:STDOUT:   %.loc37_16: type = struct_type {.a: i32} [template = constants.%.2]
+// CHECK:STDOUT:   %.loc37: type = struct_type {.a: i32} [template = constants.%.2]
 // CHECK:STDOUT:   %x.var: ref {.a: i32} = var x
 // CHECK:STDOUT:   %x: ref {.a: i32} = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc37_26: i32 = int_literal 1 [template = constants.%.1]
-// CHECK:STDOUT:   %.loc37_34: i32 = int_literal 2 [template = constants.%.3]
-// CHECK:STDOUT:   assign %x.var, <error>
-// CHECK:STDOUT:   %.loc45_25: type = struct_type {.b: i32, .c: i32} [template = constants.%.4]
+// CHECK:STDOUT:   %.loc45: type = struct_type {.b: i32, .c: i32} [template = constants.%.4]
 // CHECK:STDOUT:   %y.var: ref {.b: i32, .c: i32} = var y
 // CHECK:STDOUT:   %y: ref {.b: i32, .c: i32} = bind_name y, %y.var
-// CHECK:STDOUT:   %.loc45_35: i32 = int_literal 3 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc45_43: i32 = int_literal 4 [template = constants.%.7]
-// CHECK:STDOUT:   assign %y.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @F() -> <error>;
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc37_26: i32 = int_literal 1 [template = constants.%.1]
+// CHECK:STDOUT:   %.loc37_34: i32 = int_literal 2 [template = constants.%.3]
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   %.loc45_35: i32 = int_literal 3 [template = constants.%.6]
+// CHECK:STDOUT:   %.loc45_43: i32 = int_literal 4 [template = constants.%.7]
+// CHECK:STDOUT:   assign file.%y.var, <error>
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/struct/fail_field_name_mismatch.carbon

@@ -24,16 +24,21 @@ var y: {.b: i32} = x;
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x, .y = %y} [template]
-// CHECK:STDOUT:   %.loc10_16: type = struct_type {.a: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %.loc10: type = struct_type {.a: i32} [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref {.a: i32} = var x
 // CHECK:STDOUT:   %x: ref {.a: i32} = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc10_26: i32 = int_literal 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc10_27: {.b: i32} = struct_literal (%.loc10_26)
-// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT:   %.loc15: type = struct_type {.b: i32} [template = constants.%.3]
 // CHECK:STDOUT:   %y.var: ref {.b: i32} = var y
 // CHECK:STDOUT:   %y: ref {.b: i32} = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref {.a: i32} = name_ref x, %x
-// CHECK:STDOUT:   assign %y.var, <error>
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc10_26: i32 = int_literal 1 [template = constants.%.2]
+// CHECK:STDOUT:   %.loc10_27: {.b: i32} = struct_literal (%.loc10_26)
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   %x.ref: ref {.a: i32} = name_ref x, file.%x
+// CHECK:STDOUT:   assign file.%y.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/fail_field_type_mismatch.carbon

@@ -19,11 +19,16 @@ var x: {.a: i32} = {.b = 1.0};
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x} [template]
-// CHECK:STDOUT:   %.loc10_16: type = struct_type {.a: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %.loc10: type = struct_type {.a: i32} [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref {.a: i32} = var x
 // CHECK:STDOUT:   %x: ref {.a: i32} = bind_name x, %x.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_26: f64 = real_literal 10e-1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc10_29: {.b: f64} = struct_literal (%.loc10_26)
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/fail_member_access_type.carbon

@@ -20,17 +20,22 @@ var y: i32 = x.b;
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x, .y = %y} [template]
-// CHECK:STDOUT:   %.loc7_16: type = struct_type {.a: f64} [template = constants.%.1]
+// CHECK:STDOUT:   %.loc7: type = struct_type {.a: f64} [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref {.a: f64} = var x
 // CHECK:STDOUT:   %x: ref {.a: f64} = bind_name x, %x.var
+// CHECK:STDOUT:   %y.var: ref i32 = var y
+// CHECK:STDOUT:   %y: ref i32 = bind_name y, %y.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_26: f64 = real_literal 40e-1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc7_29.1: {.a: f64} = struct_literal (%.loc7_26)
-// CHECK:STDOUT:   %.loc7_29.2: init {.a: f64} = struct_init (%.loc7_26) to %x.var [template = constants.%.3]
+// CHECK:STDOUT:   %.loc7_29.2: init {.a: f64} = struct_init (%.loc7_26) to file.%x.var [template = constants.%.3]
 // CHECK:STDOUT:   %.loc7_29.3: init {.a: f64} = converted %.loc7_29.1, %.loc7_29.2 [template = constants.%.3]
-// CHECK:STDOUT:   assign %x.var, %.loc7_29.3
-// CHECK:STDOUT:   %y.var: ref i32 = var y
-// CHECK:STDOUT:   %y: ref i32 = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref {.a: f64} = name_ref x, %x
-// CHECK:STDOUT:   assign %y.var, <error>
+// CHECK:STDOUT:   assign file.%x.var, %.loc7_29.3
+// CHECK:STDOUT:   %x.ref: ref {.a: f64} = name_ref x, file.%x
+// CHECK:STDOUT:   assign file.%y.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/fail_nested_incomplete.carbon

@@ -32,13 +32,18 @@ var p: Incomplete* = &s.a;
 // CHECK:STDOUT:   %s.var: ref <error> = var s
 // CHECK:STDOUT:   %s: ref <error> = bind_name s, %s.var
 // CHECK:STDOUT:   %Incomplete.ref.loc17: type = name_ref Incomplete, constants.%Incomplete [template = constants.%Incomplete]
-// CHECK:STDOUT:   %.loc17_18: type = ptr_type Incomplete [template = constants.%.2]
+// CHECK:STDOUT:   %.loc17: type = ptr_type Incomplete [template = constants.%.2]
 // CHECK:STDOUT:   %p.var: ref Incomplete* = var p
 // CHECK:STDOUT:   %p: ref Incomplete* = bind_name p, %p.var
-// CHECK:STDOUT:   %s.ref: ref <error> = name_ref s, %s
-// CHECK:STDOUT:   %.loc17_22: <error> = addr_of <error> [template = <error>]
-// CHECK:STDOUT:   assign %p.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: class @Incomplete;
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %s.ref: ref <error> = name_ref s, file.%s
+// CHECK:STDOUT:   %.loc17: <error> = addr_of <error> [template = <error>]
+// CHECK:STDOUT:   assign file.%p.var, <error>
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/struct/fail_non_member_access.carbon

@@ -20,17 +20,22 @@ var y: i32 = x.b;
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x, .y = %y} [template]
-// CHECK:STDOUT:   %.loc7_16: type = struct_type {.a: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %.loc7: type = struct_type {.a: i32} [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref {.a: i32} = var x
 // CHECK:STDOUT:   %x: ref {.a: i32} = bind_name x, %x.var
+// CHECK:STDOUT:   %y.var: ref i32 = var y
+// CHECK:STDOUT:   %y: ref i32 = bind_name y, %y.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 4 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc7_27.1: {.a: i32} = struct_literal (%.loc7_26)
-// CHECK:STDOUT:   %.loc7_27.2: init {.a: i32} = struct_init (%.loc7_26) to %x.var [template = constants.%.3]
+// CHECK:STDOUT:   %.loc7_27.2: init {.a: i32} = struct_init (%.loc7_26) to file.%x.var [template = constants.%.3]
 // CHECK:STDOUT:   %.loc7_27.3: init {.a: i32} = converted %.loc7_27.1, %.loc7_27.2 [template = constants.%.3]
-// CHECK:STDOUT:   assign %x.var, %.loc7_27.3
-// CHECK:STDOUT:   %y.var: ref i32 = var y
-// CHECK:STDOUT:   %y: ref i32 = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref {.a: i32} = name_ref x, %x
-// CHECK:STDOUT:   assign %y.var, <error>
+// CHECK:STDOUT:   assign file.%x.var, %.loc7_27.3
+// CHECK:STDOUT:   %x.ref: ref {.a: i32} = name_ref x, file.%x
+// CHECK:STDOUT:   assign file.%y.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/fail_too_few_values.carbon

@@ -20,11 +20,16 @@ var x: {.a: i32, .b: i32} = {.a = 1};
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x} [template]
-// CHECK:STDOUT:   %.loc10_25: type = struct_type {.a: i32, .b: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %.loc10: type = struct_type {.a: i32, .b: i32} [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref {.a: i32, .b: i32} = var x
 // CHECK:STDOUT:   %x: ref {.a: i32, .b: i32} = bind_name x, %x.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_35: i32 = int_literal 1 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc10_36: {.a: i32} = struct_literal (%.loc10_35)
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/fail_type_assign.carbon

@@ -17,10 +17,15 @@ var x: {.a: i32} = {.a: i32};
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x} [template]
-// CHECK:STDOUT:   %.loc10_16: type = struct_type {.a: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %.loc10: type = struct_type {.a: i32} [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref {.a: i32} = var x
 // CHECK:STDOUT:   %x: ref {.a: i32} = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc10_28: type = struct_type {.a: i32} [template = constants.%.1]
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc10: type = struct_type {.a: i32} [template = constants.%.1]
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/import.carbon

@@ -39,27 +39,31 @@ var b: {.a: {.b: i32, .c: (i32,)}, .d: i32} = b_ref;
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
 // CHECK:STDOUT:   package: <namespace> = namespace {.a_ref = %a_ref, .b_ref = %b_ref} [template]
-// CHECK:STDOUT:   %.loc4_20: type = struct_type {.a: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %.loc4: type = struct_type {.a: i32} [template = constants.%.1]
 // CHECK:STDOUT:   %a_ref.var: ref {.a: i32} = var a_ref
 // CHECK:STDOUT:   %a_ref: ref {.a: i32} = bind_name a_ref, %a_ref.var
-// CHECK:STDOUT:   %.loc4_30: i32 = int_literal 0 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc4_31.1: {.a: i32} = struct_literal (%.loc4_30)
-// CHECK:STDOUT:   %.loc4_31.2: init {.a: i32} = struct_init (%.loc4_30) to %a_ref.var [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_31.3: init {.a: i32} = converted %.loc4_31.1, %.loc4_31.2 [template = constants.%.3]
-// CHECK:STDOUT:   assign %a_ref.var, %.loc4_31.3
 // CHECK:STDOUT:   %.loc5_36.1: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc5_36.2: type = converted %.loc5_36.1, constants.%.5 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc5_37: type = struct_type {.b: i32, .c: (i32,)} [template = constants.%.6]
 // CHECK:STDOUT:   %.loc5_47: type = struct_type {.a: {.b: i32, .c: (i32,)}, .d: i32} [template = constants.%.7]
 // CHECK:STDOUT:   %b_ref.var: ref {.a: {.b: i32, .c: (i32,)}, .d: i32} = var b_ref
 // CHECK:STDOUT:   %b_ref: ref {.a: {.b: i32, .c: (i32,)}, .d: i32} = bind_name b_ref, %b_ref.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc4_30: i32 = int_literal 0 [template = constants.%.2]
+// CHECK:STDOUT:   %.loc4_31.1: {.a: i32} = struct_literal (%.loc4_30)
+// CHECK:STDOUT:   %.loc4_31.2: init {.a: i32} = struct_init (%.loc4_30) to file.%a_ref.var [template = constants.%.3]
+// CHECK:STDOUT:   %.loc4_31.3: init {.a: i32} = converted %.loc4_31.1, %.loc4_31.2 [template = constants.%.3]
+// CHECK:STDOUT:   assign file.%a_ref.var, %.loc4_31.3
 // CHECK:STDOUT:   %.loc6_17: i32 = int_literal 0 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc6_26: i32 = int_literal 0 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc6_28.1: (i32,) = tuple_literal (%.loc6_26)
 // CHECK:STDOUT:   %.loc6_29.1: {.b: i32, .c: (i32,)} = struct_literal (%.loc6_17, %.loc6_28.1)
 // CHECK:STDOUT:   %.loc6_37: i32 = int_literal 0 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc6_38.1: {.a: {.b: i32, .c: (i32,)}, .d: i32} = struct_literal (%.loc6_29.1, %.loc6_37)
-// CHECK:STDOUT:   %.loc6_38.2: ref {.b: i32, .c: (i32,)} = struct_access %b_ref.var, element0
+// CHECK:STDOUT:   %.loc6_38.2: ref {.b: i32, .c: (i32,)} = struct_access file.%b_ref.var, element0
 // CHECK:STDOUT:   %.loc6_29.2: ref i32 = struct_access %.loc6_38.2, element0
 // CHECK:STDOUT:   %.loc6_29.3: init i32 = initialize_from %.loc6_17 to %.loc6_29.2 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc6_29.4: ref (i32,) = struct_access %.loc6_38.2, element1
@@ -68,11 +72,12 @@ var b: {.a: {.b: i32, .c: (i32,)}, .d: i32} = b_ref;
 // CHECK:STDOUT:   %.loc6_29.5: init (i32,) = initialize_from %.loc6_28.3 to %.loc6_29.4 [template = constants.%.11]
 // CHECK:STDOUT:   %.loc6_29.6: init {.b: i32, .c: (i32,)} = struct_init (%.loc6_29.3, %.loc6_29.5) to %.loc6_38.2 [template = constants.%.12]
 // CHECK:STDOUT:   %.loc6_29.7: init {.b: i32, .c: (i32,)} = converted %.loc6_29.1, %.loc6_29.6 [template = constants.%.12]
-// CHECK:STDOUT:   %.loc6_38.3: ref i32 = struct_access %b_ref.var, element1
+// CHECK:STDOUT:   %.loc6_38.3: ref i32 = struct_access file.%b_ref.var, element1
 // CHECK:STDOUT:   %.loc6_38.4: init i32 = initialize_from %.loc6_37 to %.loc6_38.3 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc6_38.5: init {.a: {.b: i32, .c: (i32,)}, .d: i32} = struct_init (%.loc6_29.7, %.loc6_38.4) to %b_ref.var [template = constants.%.13]
+// CHECK:STDOUT:   %.loc6_38.5: init {.a: {.b: i32, .c: (i32,)}, .d: i32} = struct_init (%.loc6_29.7, %.loc6_38.4) to file.%b_ref.var [template = constants.%.13]
 // CHECK:STDOUT:   %.loc6_38.6: init {.a: {.b: i32, .c: (i32,)}, .d: i32} = converted %.loc6_38.1, %.loc6_38.5 [template = constants.%.13]
-// CHECK:STDOUT:   assign %b_ref.var, %.loc6_38.6
+// CHECK:STDOUT:   assign file.%b_ref.var, %.loc6_38.6
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: --- implicit.impl.carbon
@@ -92,26 +97,30 @@ var b: {.a: {.b: i32, .c: (i32,)}, .d: i32} = b_ref;
 // CHECK:STDOUT:   package: <namespace> = namespace {.a_ref = %import_ref.1, .b_ref = %import_ref.2, .a = %a, .b = %b} [template]
 // CHECK:STDOUT:   %import_ref.1: ref {.a: i32} = import_ref ir1, inst+6, used
 // CHECK:STDOUT:   %import_ref.2: ref {.a: {.b: i32, .c: (i32,)}, .d: i32} = import_ref ir1, inst+37, used
-// CHECK:STDOUT:   %.loc4_16: type = struct_type {.a: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %.loc4: type = struct_type {.a: i32} [template = constants.%.1]
 // CHECK:STDOUT:   %a.var: ref {.a: i32} = var a
 // CHECK:STDOUT:   %a: ref {.a: i32} = bind_name a, %a.var
-// CHECK:STDOUT:   %a_ref.ref: ref {.a: i32} = name_ref a_ref, %import_ref.1
-// CHECK:STDOUT:   %.loc4_20.1: ref i32 = struct_access %a_ref.ref, element0
-// CHECK:STDOUT:   %.loc4_20.2: i32 = bind_value %.loc4_20.1
-// CHECK:STDOUT:   %.loc4_20.3: init {.a: i32} = struct_init (%.loc4_20.2) to %a.var
-// CHECK:STDOUT:   %.loc4_20.4: init {.a: i32} = converted %a_ref.ref, %.loc4_20.3
-// CHECK:STDOUT:   assign %a.var, %.loc4_20.4
 // CHECK:STDOUT:   %.loc5_32.1: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc5_32.2: type = converted %.loc5_32.1, constants.%.3 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc5_33: type = struct_type {.b: i32, .c: (i32,)} [template = constants.%.4]
 // CHECK:STDOUT:   %.loc5_43: type = struct_type {.a: {.b: i32, .c: (i32,)}, .d: i32} [template = constants.%.5]
 // CHECK:STDOUT:   %b.var: ref {.a: {.b: i32, .c: (i32,)}, .d: i32} = var b
 // CHECK:STDOUT:   %b: ref {.a: {.b: i32, .c: (i32,)}, .d: i32} = bind_name b, %b.var
-// CHECK:STDOUT:   %b_ref.ref: ref {.a: {.b: i32, .c: (i32,)}, .d: i32} = name_ref b_ref, %import_ref.2
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %a_ref.ref: ref {.a: i32} = name_ref a_ref, file.%import_ref.1
+// CHECK:STDOUT:   %.loc4_20.1: ref i32 = struct_access %a_ref.ref, element0
+// CHECK:STDOUT:   %.loc4_20.2: i32 = bind_value %.loc4_20.1
+// CHECK:STDOUT:   %.loc4_20.3: init {.a: i32} = struct_init (%.loc4_20.2) to file.%a.var
+// CHECK:STDOUT:   %.loc4_20.4: init {.a: i32} = converted %a_ref.ref, %.loc4_20.3
+// CHECK:STDOUT:   assign file.%a.var, %.loc4_20.4
+// CHECK:STDOUT:   %b_ref.ref: ref {.a: {.b: i32, .c: (i32,)}, .d: i32} = name_ref b_ref, file.%import_ref.2
 // CHECK:STDOUT:   %.loc5_47.1: ref {.b: i32, .c: (i32,)} = struct_access %b_ref.ref, element0
 // CHECK:STDOUT:   %.loc5_47.2: ref i32 = struct_access %.loc5_47.1, element0
 // CHECK:STDOUT:   %.loc5_47.3: i32 = bind_value %.loc5_47.2
-// CHECK:STDOUT:   %.loc5_47.4: ref {.b: i32, .c: (i32,)} = struct_access %b.var, element0
+// CHECK:STDOUT:   %.loc5_47.4: ref {.b: i32, .c: (i32,)} = struct_access file.%b.var, element0
 // CHECK:STDOUT:   %.loc5_47.5: ref i32 = struct_access %.loc5_47.4, element0
 // CHECK:STDOUT:   %.loc5_47.6: init i32 = initialize_from %.loc5_47.3 to %.loc5_47.5
 // CHECK:STDOUT:   %.loc5_47.7: ref (i32,) = struct_access %.loc5_47.1, element1
@@ -125,10 +134,11 @@ var b: {.a: {.b: i32, .c: (i32,)}, .d: i32} = b_ref;
 // CHECK:STDOUT:   %.loc5_47.15: init {.b: i32, .c: (i32,)} = converted %.loc5_47.1, %.loc5_47.14
 // CHECK:STDOUT:   %.loc5_47.16: ref i32 = struct_access %b_ref.ref, element1
 // CHECK:STDOUT:   %.loc5_47.17: i32 = bind_value %.loc5_47.16
-// CHECK:STDOUT:   %.loc5_47.18: ref i32 = struct_access %b.var, element1
+// CHECK:STDOUT:   %.loc5_47.18: ref i32 = struct_access file.%b.var, element1
 // CHECK:STDOUT:   %.loc5_47.19: init i32 = initialize_from %.loc5_47.17 to %.loc5_47.18
-// CHECK:STDOUT:   %.loc5_47.20: init {.a: {.b: i32, .c: (i32,)}, .d: i32} = struct_init (%.loc5_47.15, %.loc5_47.19) to %b.var
+// CHECK:STDOUT:   %.loc5_47.20: init {.a: {.b: i32, .c: (i32,)}, .d: i32} = struct_init (%.loc5_47.15, %.loc5_47.19) to file.%b.var
 // CHECK:STDOUT:   %.loc5_47.21: init {.a: {.b: i32, .c: (i32,)}, .d: i32} = converted %b_ref.ref, %.loc5_47.20
-// CHECK:STDOUT:   assign %b.var, %.loc5_47.21
+// CHECK:STDOUT:   assign file.%b.var, %.loc5_47.21
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/member_access.carbon

@@ -20,29 +20,34 @@ var z: i32 = y;
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x, .y = %y, .z = %z} [template]
-// CHECK:STDOUT:   %.loc7_25: type = struct_type {.a: f64, .b: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %.loc7: type = struct_type {.a: f64, .b: i32} [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref {.a: f64, .b: i32} = var x
 // CHECK:STDOUT:   %x: ref {.a: f64, .b: i32} = bind_name x, %x.var
+// CHECK:STDOUT:   %y.var: ref i32 = var y
+// CHECK:STDOUT:   %y: ref i32 = bind_name y, %y.var
+// CHECK:STDOUT:   %z.var: ref i32 = var z
+// CHECK:STDOUT:   %z: ref i32 = bind_name z, %z.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_35: f64 = real_literal 0e-1 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc7_45: i32 = int_literal 1 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc7_46.1: {.a: f64, .b: i32} = struct_literal (%.loc7_35, %.loc7_45)
-// CHECK:STDOUT:   %.loc7_46.2: ref f64 = struct_access %x.var, element0
+// CHECK:STDOUT:   %.loc7_46.2: ref f64 = struct_access file.%x.var, element0
 // CHECK:STDOUT:   %.loc7_46.3: init f64 = initialize_from %.loc7_35 to %.loc7_46.2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc7_46.4: ref i32 = struct_access %x.var, element1
+// CHECK:STDOUT:   %.loc7_46.4: ref i32 = struct_access file.%x.var, element1
 // CHECK:STDOUT:   %.loc7_46.5: init i32 = initialize_from %.loc7_45 to %.loc7_46.4 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_46.6: init {.a: f64, .b: i32} = struct_init (%.loc7_46.3, %.loc7_46.5) to %x.var [template = constants.%.5]
+// CHECK:STDOUT:   %.loc7_46.6: init {.a: f64, .b: i32} = struct_init (%.loc7_46.3, %.loc7_46.5) to file.%x.var [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_46.7: init {.a: f64, .b: i32} = converted %.loc7_46.1, %.loc7_46.6 [template = constants.%.5]
-// CHECK:STDOUT:   assign %x.var, %.loc7_46.7
-// CHECK:STDOUT:   %y.var: ref i32 = var y
-// CHECK:STDOUT:   %y: ref i32 = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref {.a: f64, .b: i32} = name_ref x, %x
+// CHECK:STDOUT:   assign file.%x.var, %.loc7_46.7
+// CHECK:STDOUT:   %x.ref: ref {.a: f64, .b: i32} = name_ref x, file.%x
 // CHECK:STDOUT:   %.loc8_15.1: ref i32 = struct_access %x.ref, element1
 // CHECK:STDOUT:   %.loc8_15.2: i32 = bind_value %.loc8_15.1
-// CHECK:STDOUT:   assign %y.var, %.loc8_15.2
-// CHECK:STDOUT:   %z.var: ref i32 = var z
-// CHECK:STDOUT:   %z: ref i32 = bind_name z, %z.var
-// CHECK:STDOUT:   %y.ref: ref i32 = name_ref y, %y
+// CHECK:STDOUT:   assign file.%y.var, %.loc8_15.2
+// CHECK:STDOUT:   %y.ref: ref i32 = name_ref y, file.%y
 // CHECK:STDOUT:   %.loc9: i32 = bind_value %y.ref
-// CHECK:STDOUT:   assign %z.var, %.loc9
+// CHECK:STDOUT:   assign file.%z.var, %.loc9
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/one_entry.carbon

@@ -17,22 +17,27 @@ var y: {.a: i32} = x;
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x, .y = %y} [template]
-// CHECK:STDOUT:   %.loc7_16: type = struct_type {.a: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %.loc7: type = struct_type {.a: i32} [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref {.a: i32} = var x
 // CHECK:STDOUT:   %x: ref {.a: i32} = bind_name x, %x.var
+// CHECK:STDOUT:   %.loc8: type = struct_type {.a: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %y.var: ref {.a: i32} = var y
+// CHECK:STDOUT:   %y: ref {.a: i32} = bind_name y, %y.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 4 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc7_27.1: {.a: i32} = struct_literal (%.loc7_26)
-// CHECK:STDOUT:   %.loc7_27.2: init {.a: i32} = struct_init (%.loc7_26) to %x.var [template = constants.%.3]
+// CHECK:STDOUT:   %.loc7_27.2: init {.a: i32} = struct_init (%.loc7_26) to file.%x.var [template = constants.%.3]
 // CHECK:STDOUT:   %.loc7_27.3: init {.a: i32} = converted %.loc7_27.1, %.loc7_27.2 [template = constants.%.3]
-// CHECK:STDOUT:   assign %x.var, %.loc7_27.3
-// CHECK:STDOUT:   %.loc8_16: type = struct_type {.a: i32} [template = constants.%.1]
-// CHECK:STDOUT:   %y.var: ref {.a: i32} = var y
-// CHECK:STDOUT:   %y: ref {.a: i32} = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref {.a: i32} = name_ref x, %x
+// CHECK:STDOUT:   assign file.%x.var, %.loc7_27.3
+// CHECK:STDOUT:   %x.ref: ref {.a: i32} = name_ref x, file.%x
 // CHECK:STDOUT:   %.loc8_20.1: ref i32 = struct_access %x.ref, element0
 // CHECK:STDOUT:   %.loc8_20.2: i32 = bind_value %.loc8_20.1
-// CHECK:STDOUT:   %.loc8_20.3: init {.a: i32} = struct_init (%.loc8_20.2) to %y.var
+// CHECK:STDOUT:   %.loc8_20.3: init {.a: i32} = struct_init (%.loc8_20.2) to file.%y.var
 // CHECK:STDOUT:   %.loc8_20.4: init {.a: i32} = converted %x.ref, %.loc8_20.3
-// CHECK:STDOUT:   assign %y.var, %.loc8_20.4
+// CHECK:STDOUT:   assign file.%y.var, %.loc8_20.4
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/tuple_as_element.carbon

@@ -27,38 +27,43 @@ var y: {.a: i32, .b: (i32,)} = x;
 // CHECK:STDOUT:   %.loc7_28: type = struct_type {.a: i32, .b: (i32,)} [template = constants.%.3]
 // CHECK:STDOUT:   %x.var: ref {.a: i32, .b: (i32,)} = var x
 // CHECK:STDOUT:   %x: ref {.a: i32, .b: (i32,)} = bind_name x, %x.var
+// CHECK:STDOUT:   %.loc8_27.1: (type,) = tuple_literal (i32)
+// CHECK:STDOUT:   %.loc8_27.2: type = converted %.loc8_27.1, constants.%.2 [template = constants.%.2]
+// CHECK:STDOUT:   %.loc8_28: type = struct_type {.a: i32, .b: (i32,)} [template = constants.%.3]
+// CHECK:STDOUT:   %y.var: ref {.a: i32, .b: (i32,)} = var y
+// CHECK:STDOUT:   %y: ref {.a: i32, .b: (i32,)} = bind_name y, %y.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_38: i32 = int_literal 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc7_47: i32 = int_literal 2 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc7_49.1: (i32,) = tuple_literal (%.loc7_47)
 // CHECK:STDOUT:   %.loc7_50.1: {.a: i32, .b: (i32,)} = struct_literal (%.loc7_38, %.loc7_49.1)
-// CHECK:STDOUT:   %.loc7_50.2: ref i32 = struct_access %x.var, element0
+// CHECK:STDOUT:   %.loc7_50.2: ref i32 = struct_access file.%x.var, element0
 // CHECK:STDOUT:   %.loc7_50.3: init i32 = initialize_from %.loc7_38 to %.loc7_50.2 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc7_50.4: ref (i32,) = struct_access %x.var, element1
+// CHECK:STDOUT:   %.loc7_50.4: ref (i32,) = struct_access file.%x.var, element1
 // CHECK:STDOUT:   %.loc7_49.2: init (i32,) = tuple_init (%.loc7_47) to %.loc7_50.4 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc7_49.3: init (i32,) = converted %.loc7_49.1, %.loc7_49.2 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc7_50.5: init (i32,) = initialize_from %.loc7_49.3 to %.loc7_50.4 [template = constants.%.7]
-// CHECK:STDOUT:   %.loc7_50.6: init {.a: i32, .b: (i32,)} = struct_init (%.loc7_50.3, %.loc7_50.5) to %x.var [template = constants.%.8]
+// CHECK:STDOUT:   %.loc7_50.6: init {.a: i32, .b: (i32,)} = struct_init (%.loc7_50.3, %.loc7_50.5) to file.%x.var [template = constants.%.8]
 // CHECK:STDOUT:   %.loc7_50.7: init {.a: i32, .b: (i32,)} = converted %.loc7_50.1, %.loc7_50.6 [template = constants.%.8]
-// CHECK:STDOUT:   assign %x.var, %.loc7_50.7
-// CHECK:STDOUT:   %.loc8_27.1: (type,) = tuple_literal (i32)
-// CHECK:STDOUT:   %.loc8_27.2: type = converted %.loc8_27.1, constants.%.2 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc8_28: type = struct_type {.a: i32, .b: (i32,)} [template = constants.%.3]
-// CHECK:STDOUT:   %y.var: ref {.a: i32, .b: (i32,)} = var y
-// CHECK:STDOUT:   %y: ref {.a: i32, .b: (i32,)} = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref {.a: i32, .b: (i32,)} = name_ref x, %x
+// CHECK:STDOUT:   assign file.%x.var, %.loc7_50.7
+// CHECK:STDOUT:   %x.ref: ref {.a: i32, .b: (i32,)} = name_ref x, file.%x
 // CHECK:STDOUT:   %.loc8_32.1: ref i32 = struct_access %x.ref, element0
 // CHECK:STDOUT:   %.loc8_32.2: i32 = bind_value %.loc8_32.1
-// CHECK:STDOUT:   %.loc8_32.3: ref i32 = struct_access %y.var, element0
+// CHECK:STDOUT:   %.loc8_32.3: ref i32 = struct_access file.%y.var, element0
 // CHECK:STDOUT:   %.loc8_32.4: init i32 = initialize_from %.loc8_32.2 to %.loc8_32.3
 // CHECK:STDOUT:   %.loc8_32.5: ref (i32,) = struct_access %x.ref, element1
 // CHECK:STDOUT:   %.loc8_32.6: ref i32 = tuple_access %.loc8_32.5, element0
 // CHECK:STDOUT:   %.loc8_32.7: i32 = bind_value %.loc8_32.6
-// CHECK:STDOUT:   %.loc8_32.8: ref (i32,) = struct_access %y.var, element1
+// CHECK:STDOUT:   %.loc8_32.8: ref (i32,) = struct_access file.%y.var, element1
 // CHECK:STDOUT:   %.loc8_32.9: init (i32,) = tuple_init (%.loc8_32.7) to %.loc8_32.8
 // CHECK:STDOUT:   %.loc8_32.10: init (i32,) = converted %.loc8_32.5, %.loc8_32.9
 // CHECK:STDOUT:   %.loc8_32.11: init (i32,) = initialize_from %.loc8_32.10 to %.loc8_32.8
-// CHECK:STDOUT:   %.loc8_32.12: init {.a: i32, .b: (i32,)} = struct_init (%.loc8_32.4, %.loc8_32.11) to %y.var
+// CHECK:STDOUT:   %.loc8_32.12: init {.a: i32, .b: (i32,)} = struct_init (%.loc8_32.4, %.loc8_32.11) to file.%y.var
 // CHECK:STDOUT:   %.loc8_32.13: init {.a: i32, .b: (i32,)} = converted %x.ref, %.loc8_32.12
-// CHECK:STDOUT:   assign %y.var, %.loc8_32.13
+// CHECK:STDOUT:   assign file.%y.var, %.loc8_32.13
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/struct/two_entries.carbon

@@ -32,33 +32,38 @@ var y: {.a: i32, .b: i32} = x;
 // CHECK:STDOUT:   %.loc8: type = struct_type {.a: i32, .b: i32} [template = constants.%.1]
 // CHECK:STDOUT:   %v.ref: {.a: i32, .b: i32} = name_ref v, %v
 // CHECK:STDOUT:   %w: {.a: i32, .b: i32} = bind_name w, %v.ref
-// CHECK:STDOUT:   %.loc10_25: type = struct_type {.a: i32, .b: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %.loc10: type = struct_type {.a: i32, .b: i32} [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref {.a: i32, .b: i32} = var x
 // CHECK:STDOUT:   %x: ref {.a: i32, .b: i32} = bind_name x, %x.var
+// CHECK:STDOUT:   %.loc11: type = struct_type {.a: i32, .b: i32} [template = constants.%.1]
+// CHECK:STDOUT:   %y.var: ref {.a: i32, .b: i32} = var y
+// CHECK:STDOUT:   %y: ref {.a: i32, .b: i32} = bind_name y, %y.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_35: i32 = int_literal 1 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc10_43: i32 = int_literal 2 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc10_44.1: {.a: i32, .b: i32} = struct_literal (%.loc10_35, %.loc10_43)
-// CHECK:STDOUT:   %.loc10_44.2: ref i32 = struct_access %x.var, element0
+// CHECK:STDOUT:   %.loc10_44.2: ref i32 = struct_access file.%x.var, element0
 // CHECK:STDOUT:   %.loc10_44.3: init i32 = initialize_from %.loc10_35 to %.loc10_44.2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc10_44.4: ref i32 = struct_access %x.var, element1
+// CHECK:STDOUT:   %.loc10_44.4: ref i32 = struct_access file.%x.var, element1
 // CHECK:STDOUT:   %.loc10_44.5: init i32 = initialize_from %.loc10_43 to %.loc10_44.4 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc10_44.6: init {.a: i32, .b: i32} = struct_init (%.loc10_44.3, %.loc10_44.5) to %x.var [template = constants.%.5]
+// CHECK:STDOUT:   %.loc10_44.6: init {.a: i32, .b: i32} = struct_init (%.loc10_44.3, %.loc10_44.5) to file.%x.var [template = constants.%.5]
 // CHECK:STDOUT:   %.loc10_44.7: init {.a: i32, .b: i32} = converted %.loc10_44.1, %.loc10_44.6 [template = constants.%.5]
-// CHECK:STDOUT:   assign %x.var, %.loc10_44.7
-// CHECK:STDOUT:   %.loc11_25: type = struct_type {.a: i32, .b: i32} [template = constants.%.1]
-// CHECK:STDOUT:   %y.var: ref {.a: i32, .b: i32} = var y
-// CHECK:STDOUT:   %y: ref {.a: i32, .b: i32} = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref {.a: i32, .b: i32} = name_ref x, %x
+// CHECK:STDOUT:   assign file.%x.var, %.loc10_44.7
+// CHECK:STDOUT:   %x.ref: ref {.a: i32, .b: i32} = name_ref x, file.%x
 // CHECK:STDOUT:   %.loc11_29.1: ref i32 = struct_access %x.ref, element0
 // CHECK:STDOUT:   %.loc11_29.2: i32 = bind_value %.loc11_29.1
-// CHECK:STDOUT:   %.loc11_29.3: ref i32 = struct_access %y.var, element0
+// CHECK:STDOUT:   %.loc11_29.3: ref i32 = struct_access file.%y.var, element0
 // CHECK:STDOUT:   %.loc11_29.4: init i32 = initialize_from %.loc11_29.2 to %.loc11_29.3
 // CHECK:STDOUT:   %.loc11_29.5: ref i32 = struct_access %x.ref, element1
 // CHECK:STDOUT:   %.loc11_29.6: i32 = bind_value %.loc11_29.5
-// CHECK:STDOUT:   %.loc11_29.7: ref i32 = struct_access %y.var, element1
+// CHECK:STDOUT:   %.loc11_29.7: ref i32 = struct_access file.%y.var, element1
 // CHECK:STDOUT:   %.loc11_29.8: init i32 = initialize_from %.loc11_29.6 to %.loc11_29.7
-// CHECK:STDOUT:   %.loc11_29.9: init {.a: i32, .b: i32} = struct_init (%.loc11_29.4, %.loc11_29.8) to %y.var
+// CHECK:STDOUT:   %.loc11_29.9: init {.a: i32, .b: i32} = struct_init (%.loc11_29.4, %.loc11_29.8) to file.%y.var
 // CHECK:STDOUT:   %.loc11_29.10: init {.a: i32, .b: i32} = converted %x.ref, %.loc11_29.9
-// CHECK:STDOUT:   assign %y.var, %.loc11_29.10
+// CHECK:STDOUT:   assign file.%y.var, %.loc11_29.10
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/tuples/empty.carbon

@@ -20,17 +20,22 @@ var y: () = x;
 // CHECK:STDOUT:   %.loc7_9.2: type = converted %.loc7_9.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref () = var x
 // CHECK:STDOUT:   %x: ref () = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc7_14.1: () = tuple_literal ()
-// CHECK:STDOUT:   %.loc7_14.2: init () = tuple_init () to %x.var [template = constants.%.2]
-// CHECK:STDOUT:   %.loc7_14.3: init () = converted %.loc7_14.1, %.loc7_14.2 [template = constants.%.2]
-// CHECK:STDOUT:   assign %x.var, %.loc7_14.3
 // CHECK:STDOUT:   %.loc8_9.1: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc8_9.2: type = converted %.loc8_9.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %y.var: ref () = var y
 // CHECK:STDOUT:   %y: ref () = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref () = name_ref x, %x
-// CHECK:STDOUT:   %.loc8_13.1: init () = tuple_init () to %y.var [template = constants.%.2]
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc7_14.1: () = tuple_literal ()
+// CHECK:STDOUT:   %.loc7_14.2: init () = tuple_init () to file.%x.var [template = constants.%.2]
+// CHECK:STDOUT:   %.loc7_14.3: init () = converted %.loc7_14.1, %.loc7_14.2 [template = constants.%.2]
+// CHECK:STDOUT:   assign file.%x.var, %.loc7_14.3
+// CHECK:STDOUT:   %x.ref: ref () = name_ref x, file.%x
+// CHECK:STDOUT:   %.loc8_13.1: init () = tuple_init () to file.%y.var [template = constants.%.2]
 // CHECK:STDOUT:   %.loc8_13.2: init () = converted %x.ref, %.loc8_13.1 [template = constants.%.2]
-// CHECK:STDOUT:   assign %y.var, %.loc8_13.2
+// CHECK:STDOUT:   assign file.%y.var, %.loc8_13.2
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/tuples/fail_assign_empty.carbon

@@ -23,7 +23,12 @@ var x: (i32,) = ();
 // CHECK:STDOUT:   %.loc10_13.2: type = converted %.loc10_13.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %x.var: ref (i32,) = var x
 // CHECK:STDOUT:   %x: ref (i32,) = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc10_18: () = tuple_literal ()
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc10: () = tuple_literal ()
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/tuples/fail_assign_nested.carbon

@@ -39,6 +39,10 @@ var x: ((i32, i32), (i32, i32)) = ((1, 2, 3), (4, 5, 6));
 // CHECK:STDOUT:   %.loc10_31.2: type = converted %.loc10_31.1, constants.%.4 [template = constants.%.4]
 // CHECK:STDOUT:   %x.var: ref ((i32, i32), (i32, i32)) = var x
 // CHECK:STDOUT:   %x: ref ((i32, i32), (i32, i32)) = bind_name x, %x.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_37: i32 = int_literal 1 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc10_40: i32 = int_literal 2 [template = constants.%.9]
 // CHECK:STDOUT:   %.loc10_43: i32 = int_literal 3 [template = constants.%.10]
@@ -48,6 +52,7 @@ var x: ((i32, i32), (i32, i32)) = ((1, 2, 3), (4, 5, 6));
 // CHECK:STDOUT:   %.loc10_54: i32 = int_literal 6 [template = constants.%.14]
 // CHECK:STDOUT:   %.loc10_55: (i32, i32, i32) = tuple_literal (%.loc10_48, %.loc10_51, %.loc10_54)
 // CHECK:STDOUT:   %.loc10_56: ((i32, i32, i32), (i32, i32, i32)) = tuple_literal (%.loc10_44, %.loc10_55)
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/tuples/fail_assign_to_empty.carbon

@@ -22,7 +22,12 @@ var x: () = (66);
 // CHECK:STDOUT:   %.loc10_9.2: type = converted %.loc10_9.1, constants.%.1 [template = constants.%.1]
 // CHECK:STDOUT:   %x.var: ref () = var x
 // CHECK:STDOUT:   %x: ref () = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc10_14: i32 = int_literal 66 [template = constants.%.2]
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc10: i32 = int_literal 66 [template = constants.%.2]
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/tuples/fail_element_type_mismatch.carbon

@@ -26,11 +26,16 @@ var x: (i32, i32) = (2, 65.89);
 // CHECK:STDOUT:   %.loc10_17.2: type = converted %.loc10_17.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %x.var: ref (i32, i32) = var x
 // CHECK:STDOUT:   %x: ref (i32, i32) = bind_name x, %x.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_22: i32 = int_literal 2 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc10_25: f64 = real_literal 6589e-2 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc10_30.1: (i32, f64) = tuple_literal (%.loc10_22, %.loc10_25)
-// CHECK:STDOUT:   %.loc10_30.2: ref i32 = tuple_access %x.var, element0
+// CHECK:STDOUT:   %.loc10_30.2: ref i32 = tuple_access file.%x.var, element0
 // CHECK:STDOUT:   %.loc10_30.3: init i32 = initialize_from %.loc10_22 to %.loc10_30.2 [template = constants.%.4]
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/tuples/fail_nested_incomplete.carbon

@@ -35,14 +35,19 @@ var p: Incomplete* = &t[1];
 // CHECK:STDOUT:   %t.var: ref <error> = var t
 // CHECK:STDOUT:   %t: ref <error> = bind_name t, %t.var
 // CHECK:STDOUT:   %Incomplete.ref.loc17: type = name_ref Incomplete, constants.%Incomplete [template = constants.%Incomplete]
-// CHECK:STDOUT:   %.loc17_18: type = ptr_type Incomplete [template = constants.%.3]
+// CHECK:STDOUT:   %.loc17: type = ptr_type Incomplete [template = constants.%.3]
 // CHECK:STDOUT:   %p.var: ref Incomplete* = var p
 // CHECK:STDOUT:   %p: ref Incomplete* = bind_name p, %p.var
-// CHECK:STDOUT:   %t.ref: ref <error> = name_ref t, %t
-// CHECK:STDOUT:   %.loc17_25: i32 = int_literal 1 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc17_22: <error> = addr_of <error> [template = <error>]
-// CHECK:STDOUT:   assign %p.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: class @Incomplete;
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %t.ref: ref <error> = name_ref t, file.%t
+// CHECK:STDOUT:   %.loc17_25: i32 = int_literal 1 [template = constants.%.4]
+// CHECK:STDOUT:   %.loc17_22: <error> = addr_of <error> [template = <error>]
+// CHECK:STDOUT:   assign file.%p.var, <error>
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/tuples/fail_too_few_element.carbon

@@ -25,8 +25,13 @@ var x: (i32, i32) = (2, );
 // CHECK:STDOUT:   %.loc10_17.2: type = converted %.loc10_17.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %x.var: ref (i32, i32) = var x
 // CHECK:STDOUT:   %x: ref (i32, i32) = bind_name x, %x.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_22: i32 = int_literal 2 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc10_25: (i32,) = tuple_literal (%.loc10_22)
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/tuples/fail_type_assign.carbon

@@ -22,7 +22,12 @@ var x: (i32, ) = (i32, );
 // CHECK:STDOUT:   %.loc10_14.2: type = converted %.loc10_14.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %x.var: ref (i32,) = var x
 // CHECK:STDOUT:   %x: ref (i32,) = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc10_24: (type,) = tuple_literal (i32)
-// CHECK:STDOUT:   assign %x.var, <error>
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc10: (type,) = tuple_literal (i32)
+// CHECK:STDOUT:   assign file.%x.var, <error>
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/tuples/import.carbon

@@ -49,11 +49,6 @@ var b: (((i32,), i32), (i32, i32)) = b_ref;
 // CHECK:STDOUT:   %.loc4_17.2: type = converted %.loc4_17.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %a_ref.var: ref (i32,) = var a_ref
 // CHECK:STDOUT:   %a_ref: ref (i32,) = bind_name a_ref, %a_ref.var
-// CHECK:STDOUT:   %.loc4_22: i32 = int_literal 0 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_24.1: (i32,) = tuple_literal (%.loc4_22)
-// CHECK:STDOUT:   %.loc4_24.2: init (i32,) = tuple_init (%.loc4_22) to %a_ref.var [template = constants.%.4]
-// CHECK:STDOUT:   %.loc4_24.3: init (i32,) = converted %.loc4_24.1, %.loc4_24.2 [template = constants.%.4]
-// CHECK:STDOUT:   assign %a_ref.var, %.loc4_24.3
 // CHECK:STDOUT:   %.loc5_19.1: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc5_25.1: ((type,), type) = tuple_literal (%.loc5_19.1, i32)
 // CHECK:STDOUT:   %.loc5_37.1: (type, type) = tuple_literal (i32, i32)
@@ -64,6 +59,15 @@ var b: (((i32,), i32), (i32, i32)) = b_ref;
 // CHECK:STDOUT:   %.loc5_38.2: type = converted %.loc5_38.1, constants.%.10 [template = constants.%.10]
 // CHECK:STDOUT:   %b_ref.var: ref (((i32,), i32), (i32, i32)) = var b_ref
 // CHECK:STDOUT:   %b_ref: ref (((i32,), i32), (i32, i32)) = bind_name b_ref, %b_ref.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc4_22: i32 = int_literal 0 [template = constants.%.3]
+// CHECK:STDOUT:   %.loc4_24.1: (i32,) = tuple_literal (%.loc4_22)
+// CHECK:STDOUT:   %.loc4_24.2: init (i32,) = tuple_init (%.loc4_22) to file.%a_ref.var [template = constants.%.4]
+// CHECK:STDOUT:   %.loc4_24.3: init (i32,) = converted %.loc4_24.1, %.loc4_24.2 [template = constants.%.4]
+// CHECK:STDOUT:   assign file.%a_ref.var, %.loc4_24.3
 // CHECK:STDOUT:   %.loc5_45: i32 = int_literal 0 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc5_47.1: (i32,) = tuple_literal (%.loc5_45)
 // CHECK:STDOUT:   %.loc5_50: i32 = int_literal 1 [template = constants.%.15]
@@ -72,7 +76,7 @@ var b: (((i32,), i32), (i32, i32)) = b_ref;
 // CHECK:STDOUT:   %.loc5_58: i32 = int_literal 3 [template = constants.%.17]
 // CHECK:STDOUT:   %.loc5_59.1: (i32, i32) = tuple_literal (%.loc5_55, %.loc5_58)
 // CHECK:STDOUT:   %.loc5_60.1: (((i32,), i32), (i32, i32)) = tuple_literal (%.loc5_51.1, %.loc5_59.1)
-// CHECK:STDOUT:   %.loc5_60.2: ref ((i32,), i32) = tuple_access %b_ref.var, element0
+// CHECK:STDOUT:   %.loc5_60.2: ref ((i32,), i32) = tuple_access file.%b_ref.var, element0
 // CHECK:STDOUT:   %.loc5_51.2: ref (i32,) = tuple_access %.loc5_60.2, element0
 // CHECK:STDOUT:   %.loc5_47.2: init (i32,) = tuple_init (%.loc5_45) to %.loc5_51.2 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc5_47.3: init (i32,) = converted %.loc5_47.1, %.loc5_47.2 [template = constants.%.4]
@@ -81,16 +85,17 @@ var b: (((i32,), i32), (i32, i32)) = b_ref;
 // CHECK:STDOUT:   %.loc5_51.5: init i32 = initialize_from %.loc5_50 to %.loc5_51.4 [template = constants.%.15]
 // CHECK:STDOUT:   %.loc5_51.6: init ((i32,), i32) = tuple_init (%.loc5_51.3, %.loc5_51.5) to %.loc5_60.2 [template = constants.%.18]
 // CHECK:STDOUT:   %.loc5_51.7: init ((i32,), i32) = converted %.loc5_51.1, %.loc5_51.6 [template = constants.%.18]
-// CHECK:STDOUT:   %.loc5_60.3: ref (i32, i32) = tuple_access %b_ref.var, element1
+// CHECK:STDOUT:   %.loc5_60.3: ref (i32, i32) = tuple_access file.%b_ref.var, element1
 // CHECK:STDOUT:   %.loc5_59.2: ref i32 = tuple_access %.loc5_60.3, element0
 // CHECK:STDOUT:   %.loc5_59.3: init i32 = initialize_from %.loc5_55 to %.loc5_59.2 [template = constants.%.16]
 // CHECK:STDOUT:   %.loc5_59.4: ref i32 = tuple_access %.loc5_60.3, element1
 // CHECK:STDOUT:   %.loc5_59.5: init i32 = initialize_from %.loc5_58 to %.loc5_59.4 [template = constants.%.17]
 // CHECK:STDOUT:   %.loc5_59.6: init (i32, i32) = tuple_init (%.loc5_59.3, %.loc5_59.5) to %.loc5_60.3 [template = constants.%.19]
 // CHECK:STDOUT:   %.loc5_59.7: init (i32, i32) = converted %.loc5_59.1, %.loc5_59.6 [template = constants.%.19]
-// CHECK:STDOUT:   %.loc5_60.4: init (((i32,), i32), (i32, i32)) = tuple_init (%.loc5_51.7, %.loc5_59.7) to %b_ref.var [template = constants.%.20]
+// CHECK:STDOUT:   %.loc5_60.4: init (((i32,), i32), (i32, i32)) = tuple_init (%.loc5_51.7, %.loc5_59.7) to file.%b_ref.var [template = constants.%.20]
 // CHECK:STDOUT:   %.loc5_60.5: init (((i32,), i32), (i32, i32)) = converted %.loc5_60.1, %.loc5_60.4 [template = constants.%.20]
-// CHECK:STDOUT:   assign %b_ref.var, %.loc5_60.5
+// CHECK:STDOUT:   assign file.%b_ref.var, %.loc5_60.5
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: --- implicit.impl.carbon
@@ -118,12 +123,6 @@ var b: (((i32,), i32), (i32, i32)) = b_ref;
 // CHECK:STDOUT:   %.loc4_13.2: type = converted %.loc4_13.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %a.var: ref (i32,) = var a
 // CHECK:STDOUT:   %a: ref (i32,) = bind_name a, %a.var
-// CHECK:STDOUT:   %a_ref.ref: ref (i32,) = name_ref a_ref, %import_ref.1
-// CHECK:STDOUT:   %.loc4_17.1: ref i32 = tuple_access %a_ref.ref, element0
-// CHECK:STDOUT:   %.loc4_17.2: i32 = bind_value %.loc4_17.1
-// CHECK:STDOUT:   %.loc4_17.3: init (i32,) = tuple_init (%.loc4_17.2) to %a.var
-// CHECK:STDOUT:   %.loc4_17.4: init (i32,) = converted %a_ref.ref, %.loc4_17.3
-// CHECK:STDOUT:   assign %a.var, %.loc4_17.4
 // CHECK:STDOUT:   %.loc5_15.1: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc5_21.1: ((type,), type) = tuple_literal (%.loc5_15.1, i32)
 // CHECK:STDOUT:   %.loc5_33.1: (type, type) = tuple_literal (i32, i32)
@@ -134,12 +133,22 @@ var b: (((i32,), i32), (i32, i32)) = b_ref;
 // CHECK:STDOUT:   %.loc5_34.2: type = converted %.loc5_34.1, constants.%.8 [template = constants.%.8]
 // CHECK:STDOUT:   %b.var: ref (((i32,), i32), (i32, i32)) = var b
 // CHECK:STDOUT:   %b: ref (((i32,), i32), (i32, i32)) = bind_name b, %b.var
-// CHECK:STDOUT:   %b_ref.ref: ref (((i32,), i32), (i32, i32)) = name_ref b_ref, %import_ref.2
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %a_ref.ref: ref (i32,) = name_ref a_ref, file.%import_ref.1
+// CHECK:STDOUT:   %.loc4_17.1: ref i32 = tuple_access %a_ref.ref, element0
+// CHECK:STDOUT:   %.loc4_17.2: i32 = bind_value %.loc4_17.1
+// CHECK:STDOUT:   %.loc4_17.3: init (i32,) = tuple_init (%.loc4_17.2) to file.%a.var
+// CHECK:STDOUT:   %.loc4_17.4: init (i32,) = converted %a_ref.ref, %.loc4_17.3
+// CHECK:STDOUT:   assign file.%a.var, %.loc4_17.4
+// CHECK:STDOUT:   %b_ref.ref: ref (((i32,), i32), (i32, i32)) = name_ref b_ref, file.%import_ref.2
 // CHECK:STDOUT:   %.loc5_38.1: ref ((i32,), i32) = tuple_access %b_ref.ref, element0
 // CHECK:STDOUT:   %.loc5_38.2: ref (i32,) = tuple_access %.loc5_38.1, element0
 // CHECK:STDOUT:   %.loc5_38.3: ref i32 = tuple_access %.loc5_38.2, element0
 // CHECK:STDOUT:   %.loc5_38.4: i32 = bind_value %.loc5_38.3
-// CHECK:STDOUT:   %.loc5_38.5: ref ((i32,), i32) = tuple_access %b.var, element0
+// CHECK:STDOUT:   %.loc5_38.5: ref ((i32,), i32) = tuple_access file.%b.var, element0
 // CHECK:STDOUT:   %.loc5_38.6: ref (i32,) = tuple_access %.loc5_38.5, element0
 // CHECK:STDOUT:   %.loc5_38.7: init (i32,) = tuple_init (%.loc5_38.4) to %.loc5_38.6
 // CHECK:STDOUT:   %.loc5_38.8: init (i32,) = converted %.loc5_38.2, %.loc5_38.7
@@ -153,7 +162,7 @@ var b: (((i32,), i32), (i32, i32)) = b_ref;
 // CHECK:STDOUT:   %.loc5_38.16: ref (i32, i32) = tuple_access %b_ref.ref, element1
 // CHECK:STDOUT:   %.loc5_38.17: ref i32 = tuple_access %.loc5_38.16, element0
 // CHECK:STDOUT:   %.loc5_38.18: i32 = bind_value %.loc5_38.17
-// CHECK:STDOUT:   %.loc5_38.19: ref (i32, i32) = tuple_access %b.var, element1
+// CHECK:STDOUT:   %.loc5_38.19: ref (i32, i32) = tuple_access file.%b.var, element1
 // CHECK:STDOUT:   %.loc5_38.20: ref i32 = tuple_access %.loc5_38.19, element0
 // CHECK:STDOUT:   %.loc5_38.21: init i32 = initialize_from %.loc5_38.18 to %.loc5_38.20
 // CHECK:STDOUT:   %.loc5_38.22: ref i32 = tuple_access %.loc5_38.16, element1
@@ -162,8 +171,9 @@ var b: (((i32,), i32), (i32, i32)) = b_ref;
 // CHECK:STDOUT:   %.loc5_38.25: init i32 = initialize_from %.loc5_38.23 to %.loc5_38.24
 // CHECK:STDOUT:   %.loc5_38.26: init (i32, i32) = tuple_init (%.loc5_38.21, %.loc5_38.25) to %.loc5_38.19
 // CHECK:STDOUT:   %.loc5_38.27: init (i32, i32) = converted %.loc5_38.16, %.loc5_38.26
-// CHECK:STDOUT:   %.loc5_38.28: init (((i32,), i32), (i32, i32)) = tuple_init (%.loc5_38.15, %.loc5_38.27) to %b.var
+// CHECK:STDOUT:   %.loc5_38.28: init (((i32,), i32), (i32, i32)) = tuple_init (%.loc5_38.15, %.loc5_38.27) to file.%b.var
 // CHECK:STDOUT:   %.loc5_38.29: init (((i32,), i32), (i32, i32)) = converted %b_ref.ref, %.loc5_38.28
-// CHECK:STDOUT:   assign %b.var, %.loc5_38.29
+// CHECK:STDOUT:   assign file.%b.var, %.loc5_38.29
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/tuples/nested_tuple.carbon

@@ -31,22 +31,27 @@ var x: ((i32, i32), i32) = ((12, 76), 6);
 // CHECK:STDOUT:   %.loc7_24.2: type = converted %.loc7_24.1, constants.%.4 [template = constants.%.4]
 // CHECK:STDOUT:   %x.var: ref ((i32, i32), i32) = var x
 // CHECK:STDOUT:   %x: ref ((i32, i32), i32) = bind_name x, %x.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_30: i32 = int_literal 12 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc7_34: i32 = int_literal 76 [template = constants.%.9]
 // CHECK:STDOUT:   %.loc7_36.1: (i32, i32) = tuple_literal (%.loc7_30, %.loc7_34)
 // CHECK:STDOUT:   %.loc7_39: i32 = int_literal 6 [template = constants.%.10]
 // CHECK:STDOUT:   %.loc7_40.1: ((i32, i32), i32) = tuple_literal (%.loc7_36.1, %.loc7_39)
-// CHECK:STDOUT:   %.loc7_40.2: ref (i32, i32) = tuple_access %x.var, element0
+// CHECK:STDOUT:   %.loc7_40.2: ref (i32, i32) = tuple_access file.%x.var, element0
 // CHECK:STDOUT:   %.loc7_36.2: ref i32 = tuple_access %.loc7_40.2, element0
 // CHECK:STDOUT:   %.loc7_36.3: init i32 = initialize_from %.loc7_30 to %.loc7_36.2 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc7_36.4: ref i32 = tuple_access %.loc7_40.2, element1
 // CHECK:STDOUT:   %.loc7_36.5: init i32 = initialize_from %.loc7_34 to %.loc7_36.4 [template = constants.%.9]
 // CHECK:STDOUT:   %.loc7_36.6: init (i32, i32) = tuple_init (%.loc7_36.3, %.loc7_36.5) to %.loc7_40.2 [template = constants.%.11]
 // CHECK:STDOUT:   %.loc7_36.7: init (i32, i32) = converted %.loc7_36.1, %.loc7_36.6 [template = constants.%.11]
-// CHECK:STDOUT:   %.loc7_40.3: ref i32 = tuple_access %x.var, element1
+// CHECK:STDOUT:   %.loc7_40.3: ref i32 = tuple_access file.%x.var, element1
 // CHECK:STDOUT:   %.loc7_40.4: init i32 = initialize_from %.loc7_39 to %.loc7_40.3 [template = constants.%.10]
-// CHECK:STDOUT:   %.loc7_40.5: init ((i32, i32), i32) = tuple_init (%.loc7_36.7, %.loc7_40.4) to %x.var [template = constants.%.12]
+// CHECK:STDOUT:   %.loc7_40.5: init ((i32, i32), i32) = tuple_init (%.loc7_36.7, %.loc7_40.4) to file.%x.var [template = constants.%.12]
 // CHECK:STDOUT:   %.loc7_40.6: init ((i32, i32), i32) = converted %.loc7_40.1, %.loc7_40.5 [template = constants.%.12]
-// CHECK:STDOUT:   assign %x.var, %.loc7_40.6
+// CHECK:STDOUT:   assign file.%x.var, %.loc7_40.6
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/tuples/one_element.carbon

@@ -22,20 +22,25 @@ var y: (i32,) = x;
 // CHECK:STDOUT:   %.loc7_13.2: type = converted %.loc7_13.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %x.var: ref (i32,) = var x
 // CHECK:STDOUT:   %x: ref (i32,) = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc7_18: i32 = int_literal 4 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc7_20.1: (i32,) = tuple_literal (%.loc7_18)
-// CHECK:STDOUT:   %.loc7_20.2: init (i32,) = tuple_init (%.loc7_18) to %x.var [template = constants.%.4]
-// CHECK:STDOUT:   %.loc7_20.3: init (i32,) = converted %.loc7_20.1, %.loc7_20.2 [template = constants.%.4]
-// CHECK:STDOUT:   assign %x.var, %.loc7_20.3
 // CHECK:STDOUT:   %.loc8_13.1: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc8_13.2: type = converted %.loc8_13.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %y.var: ref (i32,) = var y
 // CHECK:STDOUT:   %y: ref (i32,) = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref (i32,) = name_ref x, %x
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc7_18: i32 = int_literal 4 [template = constants.%.3]
+// CHECK:STDOUT:   %.loc7_20.1: (i32,) = tuple_literal (%.loc7_18)
+// CHECK:STDOUT:   %.loc7_20.2: init (i32,) = tuple_init (%.loc7_18) to file.%x.var [template = constants.%.4]
+// CHECK:STDOUT:   %.loc7_20.3: init (i32,) = converted %.loc7_20.1, %.loc7_20.2 [template = constants.%.4]
+// CHECK:STDOUT:   assign file.%x.var, %.loc7_20.3
+// CHECK:STDOUT:   %x.ref: ref (i32,) = name_ref x, file.%x
 // CHECK:STDOUT:   %.loc8_17.1: ref i32 = tuple_access %x.ref, element0
 // CHECK:STDOUT:   %.loc8_17.2: i32 = bind_value %.loc8_17.1
-// CHECK:STDOUT:   %.loc8_17.3: init (i32,) = tuple_init (%.loc8_17.2) to %y.var
+// CHECK:STDOUT:   %.loc8_17.3: init (i32,) = tuple_init (%.loc8_17.2) to file.%y.var
 // CHECK:STDOUT:   %.loc8_17.4: init (i32,) = converted %x.ref, %.loc8_17.3
-// CHECK:STDOUT:   assign %y.var, %.loc8_17.4
+// CHECK:STDOUT:   assign file.%y.var, %.loc8_17.4
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/tuples/two_elements.carbon

@@ -39,31 +39,36 @@ var y: (i32, i32) = x;
 // CHECK:STDOUT:   %.loc10_17.2: type = converted %.loc10_17.1, constants.%.2 [template = constants.%.2]
 // CHECK:STDOUT:   %x.var: ref (i32, i32) = var x
 // CHECK:STDOUT:   %x: ref (i32, i32) = bind_name x, %x.var
+// CHECK:STDOUT:   %.loc11_17.1: (type, type) = tuple_literal (i32, i32)
+// CHECK:STDOUT:   %.loc11_17.2: type = converted %.loc11_17.1, constants.%.2 [template = constants.%.2]
+// CHECK:STDOUT:   %y.var: ref (i32, i32) = var y
+// CHECK:STDOUT:   %y: ref (i32, i32) = bind_name y, %y.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_22: i32 = int_literal 4 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc10_25: i32 = int_literal 102 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc10_28.1: (i32, i32) = tuple_literal (%.loc10_22, %.loc10_25)
-// CHECK:STDOUT:   %.loc10_28.2: ref i32 = tuple_access %x.var, element0
+// CHECK:STDOUT:   %.loc10_28.2: ref i32 = tuple_access file.%x.var, element0
 // CHECK:STDOUT:   %.loc10_28.3: init i32 = initialize_from %.loc10_22 to %.loc10_28.2 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc10_28.4: ref i32 = tuple_access %x.var, element1
+// CHECK:STDOUT:   %.loc10_28.4: ref i32 = tuple_access file.%x.var, element1
 // CHECK:STDOUT:   %.loc10_28.5: init i32 = initialize_from %.loc10_25 to %.loc10_28.4 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc10_28.6: init (i32, i32) = tuple_init (%.loc10_28.3, %.loc10_28.5) to %x.var [template = constants.%.6]
+// CHECK:STDOUT:   %.loc10_28.6: init (i32, i32) = tuple_init (%.loc10_28.3, %.loc10_28.5) to file.%x.var [template = constants.%.6]
 // CHECK:STDOUT:   %.loc10_28.7: init (i32, i32) = converted %.loc10_28.1, %.loc10_28.6 [template = constants.%.6]
-// CHECK:STDOUT:   assign %x.var, %.loc10_28.7
-// CHECK:STDOUT:   %.loc11_17.1: (type, type) = tuple_literal (i32, i32)
-// CHECK:STDOUT:   %.loc11_17.2: type = converted %.loc11_17.1, constants.%.2 [template = constants.%.2]
-// CHECK:STDOUT:   %y.var: ref (i32, i32) = var y
-// CHECK:STDOUT:   %y: ref (i32, i32) = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref (i32, i32) = name_ref x, %x
+// CHECK:STDOUT:   assign file.%x.var, %.loc10_28.7
+// CHECK:STDOUT:   %x.ref: ref (i32, i32) = name_ref x, file.%x
 // CHECK:STDOUT:   %.loc11_21.1: ref i32 = tuple_access %x.ref, element0
 // CHECK:STDOUT:   %.loc11_21.2: i32 = bind_value %.loc11_21.1
-// CHECK:STDOUT:   %.loc11_21.3: ref i32 = tuple_access %y.var, element0
+// CHECK:STDOUT:   %.loc11_21.3: ref i32 = tuple_access file.%y.var, element0
 // CHECK:STDOUT:   %.loc11_21.4: init i32 = initialize_from %.loc11_21.2 to %.loc11_21.3
 // CHECK:STDOUT:   %.loc11_21.5: ref i32 = tuple_access %x.ref, element1
 // CHECK:STDOUT:   %.loc11_21.6: i32 = bind_value %.loc11_21.5
-// CHECK:STDOUT:   %.loc11_21.7: ref i32 = tuple_access %y.var, element1
+// CHECK:STDOUT:   %.loc11_21.7: ref i32 = tuple_access file.%y.var, element1
 // CHECK:STDOUT:   %.loc11_21.8: init i32 = initialize_from %.loc11_21.6 to %.loc11_21.7
-// CHECK:STDOUT:   %.loc11_21.9: init (i32, i32) = tuple_init (%.loc11_21.4, %.loc11_21.8) to %y.var
+// CHECK:STDOUT:   %.loc11_21.9: init (i32, i32) = tuple_init (%.loc11_21.4, %.loc11_21.8) to file.%y.var
 // CHECK:STDOUT:   %.loc11_21.10: init (i32, i32) = converted %x.ref, %.loc11_21.9
-// CHECK:STDOUT:   assign %y.var, %.loc11_21.10
+// CHECK:STDOUT:   assign file.%y.var, %.loc11_21.10
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/var/fail_lookup_outside_scope.carbon

@@ -20,8 +20,6 @@ var y: i32 = x;
 // CHECK:STDOUT:   %Main: <function> = fn_decl @Main [template]
 // CHECK:STDOUT:   %y.var: ref i32 = var y
 // CHECK:STDOUT:   %y: ref i32 = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: <error> = name_ref x, <error> [template = <error>]
-// CHECK:STDOUT:   assign %y.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
@@ -31,3 +29,10 @@ var y: i32 = x;
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %x.ref: <error> = name_ref x, <error> [template = <error>]
+// CHECK:STDOUT:   assign file.%y.var, <error>
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/var/global_decl_with_init.carbon

@@ -16,7 +16,12 @@ var x: i32 = 0;
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x} [template]
 // CHECK:STDOUT:   %x.var: ref i32 = var x
 // CHECK:STDOUT:   %x: ref i32 = bind_name x, %x.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7: i32 = int_literal 0 [template = constants.%.1]
-// CHECK:STDOUT:   assign %x.var, %.loc7
+// CHECK:STDOUT:   assign file.%x.var, %.loc7
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/var/global_lookup.carbon

@@ -17,12 +17,17 @@ var y: i32 = x;
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x, .y = %y} [template]
 // CHECK:STDOUT:   %x.var: ref i32 = var x
 // CHECK:STDOUT:   %x: ref i32 = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc7: i32 = int_literal 0 [template = constants.%.1]
-// CHECK:STDOUT:   assign %x.var, %.loc7
 // CHECK:STDOUT:   %y.var: ref i32 = var y
 // CHECK:STDOUT:   %y: ref i32 = bind_name y, %y.var
-// CHECK:STDOUT:   %x.ref: ref i32 = name_ref x, %x
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc7: i32 = int_literal 0 [template = constants.%.1]
+// CHECK:STDOUT:   assign file.%x.var, %.loc7
+// CHECK:STDOUT:   %x.ref: ref i32 = name_ref x, file.%x
 // CHECK:STDOUT:   %.loc8: i32 = bind_value %x.ref
-// CHECK:STDOUT:   assign %y.var, %.loc8
+// CHECK:STDOUT:   assign file.%y.var, %.loc8
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/var/global_lookup_in_scope.carbon

@@ -20,8 +20,6 @@ fn Main() {
 // CHECK:STDOUT:   package: <namespace> = namespace {.x = %x, .Main = %Main} [template]
 // CHECK:STDOUT:   %x.var: ref i32 = var x
 // CHECK:STDOUT:   %x: ref i32 = bind_name x, %x.var
-// CHECK:STDOUT:   %.loc7: i32 = int_literal 0 [template = constants.%.1]
-// CHECK:STDOUT:   assign %x.var, %.loc7
 // CHECK:STDOUT:   %Main: <function> = fn_decl @Main [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -35,3 +33,10 @@ fn Main() {
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %.loc7: i32 = int_literal 0 [template = constants.%.1]
+// CHECK:STDOUT:   assign file.%x.var, %.loc7
+// CHECK:STDOUT:   return
+// CHECK:STDOUT: }
+// CHECK:STDOUT:

toolchain/check/testdata/var/import.carbon

@@ -26,8 +26,13 @@ var a: i32 = a_ref;
 // CHECK:STDOUT:   package: <namespace> = namespace {.a_ref = %a_ref} [template]
 // CHECK:STDOUT:   %a_ref.var: ref i32 = var a_ref
 // CHECK:STDOUT:   %a_ref: ref i32 = bind_name a_ref, %a_ref.var
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc4: i32 = int_literal 0 [template = constants.%.1]
-// CHECK:STDOUT:   assign %a_ref.var, %.loc4
+// CHECK:STDOUT:   assign file.%a_ref.var, %.loc4
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: --- implicit.impl.carbon
@@ -37,8 +42,13 @@ var a: i32 = a_ref;
 // CHECK:STDOUT:   %import_ref: ref i32 = import_ref ir1, inst+2, used
 // CHECK:STDOUT:   %a.var: ref i32 = var a
 // CHECK:STDOUT:   %a: ref i32 = bind_name a, %a.var
-// CHECK:STDOUT:   %a_ref.ref: ref i32 = name_ref a_ref, %import_ref
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @__global_init() {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %a_ref.ref: ref i32 = name_ref a_ref, file.%import_ref
 // CHECK:STDOUT:   %.loc4: i32 = bind_value %a_ref.ref
-// CHECK:STDOUT:   assign %a.var, %.loc4
+// CHECK:STDOUT:   assign file.%a.var, %.loc4
+// CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/sem_ir/ids.h

@@ -379,6 +379,11 @@ struct InstBlockId : public IdBase, public Printable<InstBlockId> {
   // fully checked; intermediate state is in the Check::Context.
   static const InstBlockId Exports;
 
+  // Global declaration initialization instructions. Empty if none are present.
+  // Otherwise, __global_init function will be generated and this block will
+  // be inserted into it.
+  static const InstBlockId GlobalInit;
+
   // An explicitly invalid ID.
   static const InstBlockId Invalid;
 
@@ -393,6 +398,8 @@ struct InstBlockId : public IdBase, public Printable<InstBlockId> {
       out << "empty";
     } else if (*this == Exports) {
       out << "exports";
+    } else if (*this == GlobalInit) {
+      out << "global_init";
     } else {
       out << "block";
       IdBase::Print(out);
@@ -404,6 +411,7 @@ constexpr InstBlockId InstBlockId::Empty = InstBlockId(0);
 constexpr InstBlockId InstBlockId::Exports = InstBlockId(1);
 constexpr InstBlockId InstBlockId::Invalid = InstBlockId(InvalidIndex);
 constexpr InstBlockId InstBlockId::Unreachable = InstBlockId(InvalidIndex - 1);
+constexpr InstBlockId InstBlockId::GlobalInit = InstBlockId(2);
 
 // The ID of a type.
 struct TypeId : public IdBase, public Printable<TypeId> {

toolchain/sem_ir/value_stores.h

@@ -479,6 +479,8 @@ class InstBlockStore : public BlockValueStore<InstBlockId> {
     CARBON_CHECK(empty_id == InstBlockId::Empty);
     auto exports_id = AddDefaultValue();
     CARBON_CHECK(exports_id == InstBlockId::Exports);
+    auto global_init_id = AddDefaultValue();
+    CARBON_CHECK(global_init_id == InstBlockId::GlobalInit);
   }
 
   auto Set(InstBlockId block_id, llvm::ArrayRef<InstId> content) -> void {

toolchain/sem_ir/yaml_test.cpp

@@ -83,8 +83,9 @@ TEST(SemIRTest, YAML) {
            Yaml::Mapping(ElementsAre(
                Pair("empty", Yaml::Mapping(IsEmpty())),
                Pair("exports", Yaml::Mapping(Each(Pair(_, inst_id)))),
-               Pair("block2", Yaml::Mapping(Each(Pair(_, inst_id)))),
-               Pair("block3", Yaml::Mapping(Each(Pair(_, inst_id)))))))));
+               Pair("global_init", Yaml::Mapping(IsEmpty())),
+               Pair("block3", Yaml::Mapping(Each(Pair(_, inst_id)))),
+               Pair("block4", Yaml::Mapping(Each(Pair(_, inst_id)))))))));
 
   auto root = Yaml::Sequence(ElementsAre(Yaml::Mapping(
       ElementsAre(Pair("filename", "test.carbon"), Pair("sem_ir", file)))));