diff --git a/src/codegen.zig b/src/codegen.zig
index d4828f4fc73027aa4e854bf55e002f855ccfe9b0..cf2018a5c0d2eea2cc08fe347defcd77ce53f0bb 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -617,6 +617,7 @@ pub fn generateSymbol(
             else => unreachable,
         },
         .un => |un| {
+            const union_begin = w.end;
             const layout = ty.unionGetLayout(zcu);
 
             if (layout.payload_size == 0) {
@@ -648,11 +649,10 @@ pub fn generateSymbol(
 
             if (layout.tag_size > 0 and layout.tag_align.compare(.lt, layout.payload_align)) {
                 try generateSymbol(bin_file, pt, Value.fromInterned(un.tag), w, reloc_parent);
-
-                if (layout.padding > 0) {
-                    try w.splatByteAll(0, layout.padding);
-                }
             }
+
+            const padding: usize = @intCast(union_begin + layout.abi_size - w.end);
+            if (padding > 0) try w.splatByteAll(0, padding);
         },
         .bitpack => |bitpack| try generateSymbol(bin_file, pt, .fromInterned(bitpack.backing_int_val), w, reloc_parent),
         .memoized_call => unreachable,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 0fd9224c206fb95e709d91b0e02aef2e894818d5..1ec1cec89a47a171d4f5e33abd6885d6914bcd01 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -2982,13 +2982,13 @@ pub const Object = struct {
                     } else .normal;
 
                     const payload_ty = ty: {
-                        if (layout.most_aligned_field_size == layout.payload_size) {
-                            break :ty aligned_field_llvm_ty;
-                        }
                         const padding_len = if (layout.tag_size == 0)
                             layout.abi_size - layout.most_aligned_field_size
                         else
                             layout.payload_size - layout.most_aligned_field_size;
+                        if (padding_len == 0) {
+                            break :ty aligned_field_llvm_ty;
+                        }
                         break :ty try o.builder.structType(.@"packed", &.{
                             aligned_field_llvm_ty,
                             try o.builder.arrayType(padding_len, .i8),
@@ -3582,6 +3582,11 @@ pub const Object = struct {
                 const payload = if (un.tag != .none) p: {
                     const field_index = zcu.unionTagFieldIndex(union_obj, Value.fromInterned(un.tag)).?;
                     const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
+                    const field_size = field_ty.abiSize(zcu);
+                    const padding_len = if (layout.tag_size == 0)
+                        layout.abi_size - field_size
+                    else
+                        layout.payload_size - field_size;
 
                     // Sometimes we must make an unnamed struct because LLVM does
                     // not support bitcasting our payload struct to the true union payload type.
@@ -3590,7 +3595,6 @@ pub const Object = struct {
                     need_unnamed = layout.most_aligned_field != field_index;
 
                     if (!field_ty.hasRuntimeBits(zcu)) {
-                        const padding_len = layout.payload_size;
                         break :p try o.builder.undefConst(try o.builder.arrayType(padding_len, .i8));
                     }
                     const payload = try o.lowerValue(un.val, repr);
@@ -3598,9 +3602,7 @@ pub const Object = struct {
                     if (payload_ty != union_ty.structFields(&o.builder)[
                         @intFromBool(layout.tag_size > 0 and layout.tag_align.compare(.gte, layout.payload_align))
                     ]) need_unnamed = true;
-                    const field_size = field_ty.abiSize(zcu);
-                    if (field_size == layout.payload_size) break :p payload;
-                    const padding_len = layout.payload_size - field_size;
+                    if (padding_len == 0) break :p payload;
                     const padding_ty = try o.builder.arrayType(padding_len, .i8);
                     break :p try o.builder.structConst(
                         try o.builder.structType(.@"packed", &.{ payload_ty, padding_ty }),
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index e0f294557def1e340f6ffc2d7f1f9e8cfbec2856..879cbe418596939a8cb8c0d8afaa3d4e4d000e50 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1162,6 +1162,22 @@ test "extern union most-aligned field is smaller" {
     try expect(a != null);
 }
 
+test "union constant trailing padding" {
+    const S = struct {
+        fn doTheTest() !void {
+            const U = extern union { x: u32, y: [5]u8 };
+            var u = [2]U{ .{ .x = 0 }, .{ .y = @splat(0xff) } };
+            _ = &u;
+            try expect(u[0].x == 0);
+            try expect(u[1].y[0] == 0xff);
+            try expect(u[1].y[4] == 0xff);
+        }
+    };
+
+    try S.doTheTest();
+    try comptime S.doTheTest();
+}
+
 test "return an extern union from C calling convention" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO