copy elision: if-optional with aggregate

```zig
export fn entry() void {
    var x: ?Foo = foo();
    var y = if (x) |a| a.y else bar();
}
```

```llvm
define void @entry() #2 !dbg !41 {
Entry:
  %x = alloca { %Foo, i1 }, align 4
  %y = alloca %Bar, align 4
  %0 = getelementptr inbounds { %Foo, i1 }, { %Foo, i1 }* %x, i32 0, i32 1, !dbg !64
  store i1 true, i1* %0, align 1, !dbg !64
  %1 = getelementptr inbounds { %Foo, i1 }, { %Foo, i1 }* %x, i32 0, i32 0, !dbg !64
  call fastcc void @foo(%Foo* sret %1), !dbg !65
  call void @llvm.dbg.declare(metadata { %Foo, i1 }* %x, metadata !45, metadata !DIExpression()), !dbg !64
  %2 = getelementptr inbounds { %Foo, i1 }, { %Foo, i1 }* %x, i32 0, i32 1, !dbg !66
  %3 = load i1, i1* %2, align 1, !dbg !66
  br i1 %3, label %OptionalThen, label %OptionalElse, !dbg !66

OptionalThen:                                     ; preds = %Entry
  %4 = getelementptr inbounds { %Foo, i1 }, { %Foo, i1 }* %x, i32 0, i32 0, !dbg !66
  call void @llvm.dbg.declare(metadata %Foo* %4, metadata !61, metadata !DIExpression()), !dbg !66
  %5 = getelementptr inbounds %Foo, %Foo* %4, i32 0, i32 1, !dbg !67
  %6 = bitcast %Bar* %5 to i8*, !dbg !67
  %7 = bitcast %Bar* %y to i8*, !dbg !67
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %7, i8* align 4 %6, i64 8, i1 false), !dbg !67
  br label %OptionalEndIf, !dbg !66

OptionalElse:                                     ; preds = %Entry
  call fastcc void @bar(%Bar* sret %y), !dbg !69
  br label %OptionalEndIf, !dbg !66

OptionalEndIf:                                    ; preds = %OptionalElse, %OptionalThen
  call void @llvm.dbg.declare(metadata %Bar* %y, metadata !63, metadata !DIExpression()), !dbg !70
  ret void, !dbg !71
}
```

Author: andrewrk

src/ir.cpp

@@ -3832,7 +3832,9 @@ static IrInstruction *ir_gen_array_access(IrBuilder *irb, Scope *scope, AstNode
     return ir_build_load_result(irb, scope, node, ptr_instruction, result_loc);
 }
 
-static IrInstruction *ir_gen_field_access(IrBuilder *irb, Scope *scope, AstNode *node) {
+static IrInstruction *ir_gen_field_access(IrBuilder *irb, Scope *scope, AstNode *node, LVal lval,
+        IrInstruction *result_loc)
+{
     assert(node->type == NodeTypeFieldAccessExpr);
 
     AstNode *container_ref_node = node->data.field_access_expr.struct_expr;
@@ -3842,7 +3844,8 @@ static IrInstruction *ir_gen_field_access(IrBuilder *irb, Scope *scope, AstNode
     if (container_ref_instruction == irb->codegen->invalid_instruction)
         return container_ref_instruction;
 
-    return ir_build_field_ptr(irb, scope, node, container_ref_instruction, nullptr, field_name);
+    IrInstruction *field_ptr = ir_build_field_ptr(irb, scope, node, container_ref_instruction, nullptr, field_name);
+    return ir_gen_ptr(irb, scope, node, lval, result_loc, field_ptr);
 }
 
 static IrInstruction *ir_gen_overflow_op(IrBuilder *irb, Scope *scope, AstNode *node, IrOverflowOp op) {
@@ -5856,7 +5859,7 @@ static IrInstruction *ir_gen_asm_expr(IrBuilder *irb, Scope *scope, AstNode *nod
     return ir_build_asm(irb, scope, node, input_list, output_types, output_vars, return_count, is_volatile);
 }
 
-static IrInstruction *ir_gen_if_optional_expr(IrBuilder *irb, Scope *scope, AstNode *node,
+static IrInstruction *ir_gen_if_optional_expr(IrBuilder *irb, Scope *scope, AstNode *node, LVal lval,
         IrInstruction *result_loc)
 {
     assert(node->type == NodeTypeIfOptional);
@@ -5897,20 +5900,17 @@ static IrInstruction *ir_gen_if_optional_expr(IrBuilder *irb, Scope *scope, AstN
         ZigVar *var = ir_create_var(irb, node, subexpr_scope,
                 var_symbol, is_const, is_const, is_shadowable, is_comptime);
 
-        IrInstruction *payload_alloca = ir_build_alloca_src(irb, scope, node, nullptr, nullptr, "optional_payload");
-        IrInstruction *var_ptr_value = ir_build_unwrap_maybe(irb, subexpr_scope, node, maybe_val_ptr, false);
-        IrInstruction *var_value = var_is_ptr ? var_ptr_value : ir_build_load_result(irb, subexpr_scope, node,
-                var_ptr_value, payload_alloca);
-        ir_build_store_result(irb, subexpr_scope, node, payload_alloca, var_value);
-        ir_build_var_decl_src(irb, subexpr_scope, node, var, var_type, nullptr, payload_alloca);
+        IrInstruction *payload_ptr = ir_build_unwrap_maybe(irb, subexpr_scope, node, maybe_val_ptr, false);
+        IrInstruction *var_ptr = var_is_ptr ?
+            ir_build_ref(irb, subexpr_scope, node, payload_ptr, true, false) : payload_ptr;
+        ir_build_var_decl_src(irb, subexpr_scope, node, var, var_type, nullptr, var_ptr);
         var_scope = var->child_scope;
     } else {
         var_scope = subexpr_scope;
     }
     IrInstruction *then_expr_result = ir_gen_node(irb, then_node, var_scope, LValNone, result_loc);
     if (then_expr_result == irb->codegen->invalid_instruction)
         return then_expr_result;
-    IrBasicBlock *after_then_block = irb->current_basic_block;
     if (!instr_is_unreachable(then_expr_result))
         ir_mark_gen(ir_build_br(irb, scope, node, endif_block, is_comptime));
 
@@ -5923,19 +5923,11 @@ static IrInstruction *ir_gen_if_optional_expr(IrBuilder *irb, Scope *scope, AstN
     } else {
         else_expr_result = ir_build_const_void(irb, scope, node);
     }
-    IrBasicBlock *after_else_block = irb->current_basic_block;
     if (!instr_is_unreachable(else_expr_result))
         ir_mark_gen(ir_build_br(irb, scope, node, endif_block, is_comptime));
 
     ir_set_cursor_at_end_and_append_block(irb, endif_block);
-    IrInstruction **incoming_values = allocate<IrInstruction *>(2);
-    incoming_values[0] = then_expr_result;
-    incoming_values[1] = else_expr_result;
-    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2);
-    incoming_blocks[0] = after_then_block;
-    incoming_blocks[1] = after_else_block;
-
-    return ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values);
+    return ir_gen_lval_ptr(irb, scope, node, lval, result_loc);
 }
 
 static IrInstruction *ir_gen_if_err_expr(IrBuilder *irb, Scope *scope, AstNode *node, IrInstruction *result_loc) {
@@ -7276,15 +7268,7 @@ static IrInstruction *ir_gen_node_raw(IrBuilder *irb, AstNode *node, Scope *scop
         case NodeTypeReturnExpr:
             return ir_gen_return(irb, scope, node, lval, result_loc);
         case NodeTypeFieldAccessExpr:
-            {
-                IrInstruction *ptr_instruction = ir_gen_field_access(irb, scope, node);
-                if (ptr_instruction == irb->codegen->invalid_instruction)
-                    return ptr_instruction;
-                if (lval == LValPtr)
-                    return ptr_instruction;
-
-                return ir_build_load_ptr(irb, scope, node, ptr_instruction, nullptr);
-            }
+            return ir_gen_field_access(irb, scope, node, lval, result_loc);
         case NodeTypePtrDeref: {
             AstNode *expr_node = node->data.ptr_deref_expr.target;
             IrInstruction *value = ir_gen_node(irb, expr_node, scope, lval, nullptr);
@@ -7325,7 +7309,7 @@ static IrInstruction *ir_gen_node_raw(IrBuilder *irb, AstNode *node, Scope *scop
         case NodeTypeIfErrorExpr:
             return ir_lval_wrap(irb, scope, ir_gen_if_err_expr(irb, scope, node, result_loc), lval);
         case NodeTypeIfOptional:
-            return ir_lval_wrap(irb, scope, ir_gen_if_optional_expr(irb, scope, node, result_loc), lval);
+            return ir_gen_if_optional_expr(irb, scope, node, lval, result_loc);
         case NodeTypeSwitchExpr:
             return ir_lval_wrap(irb, scope, ir_gen_switch_expr(irb, scope, node, result_loc), lval);
         case NodeTypeCompTime:

src/ir_print.cpp

@@ -491,8 +491,9 @@ static void ir_print_test_null(IrPrint *irp, IrInstructionTestNonNull *instructi
 }
 
 static void ir_print_unwrap_maybe(IrPrint *irp, IrInstructionUnwrapOptional *instruction) {
-    fprintf(irp->f, "&??*");
+    fprintf(irp->f, "UnwrapOptional(");
     ir_print_other_instruction(irp, instruction->value);
+    fprintf(irp->f, ")");
     if (!instruction->safety_check_on) {
         fprintf(irp->f, " // no safety");
     }