Sema: catch invalid asm input operands

Fixes #7843

Author: wooster0

lib/std/zig.zig

@@ -518,6 +518,17 @@ pub const LazySrcLoc = union(enum) {
     /// to the return type expression.
     /// The Decl is determined contextually.
     node_offset_asm_ret_ty: i32,
+    /// The source location points to the operand of an input of an inline assembly
+    /// expression, found by taking this AST node index offset from the containing
+    /// Decl AST node, which points to inline assembly AST node. Next, navigate
+    /// to the input operand expression.
+    /// The Decl is determined contextually.
+    asm_input_op: struct {
+        /// Points to the asm AST node.
+        asm_node_offset: i32,
+        /// Picks one of the inputs from the asm.
+        input_index: u32,
+    },
     /// The source location points to the condition expression of an if
     /// expression, found by taking this AST node index offset from the containing
     /// Decl AST node, which points to an if expression AST node. Next, navigate

src/Module.zig

@@ -673,6 +673,7 @@ pub const Decl = struct {
             .node_offset_deref_ptr,
             .node_offset_asm_source,
             .node_offset_asm_ret_ty,
+            .asm_input_op,
             .node_offset_if_cond,
             .node_offset_bin_op,
             .node_offset_bin_lhs,
@@ -1452,6 +1453,14 @@ pub const SrcLoc = struct {
                 const node_datas = tree.nodes.items(.data);
                 return tree.nodeToSpan(node_datas[asm_output].lhs);
             },
+            .asm_input_op => |asm_input_op| {
+                const tree = try src_loc.file_scope.getTree(gpa);
+                const node = src_loc.declRelativeToNodeIndex(asm_input_op.asm_node_offset);
+                const full = tree.fullAsm(node).?;
+                const asm_input = full.inputs[asm_input_op.input_index];
+                const node_datas = tree.nodes.items(.data);
+                return tree.nodeToSpan(node_datas[asm_input].lhs);
+            },
 
             .node_offset_if_cond => |node_off| {
                 const tree = try src_loc.file_scope.getTree(gpa);

src/Sema.zig

@@ -16854,6 +16854,36 @@ fn zirAsm(
             .ComptimeInt => arg.* = try sema.coerce(block, Type.usize, uncasted_arg, src),
             .ComptimeFloat => arg.* = try sema.coerce(block, Type.f64, uncasted_arg, src),
             else => {
+                const input_op_src: LazySrcLoc = .{
+                    .asm_input_op = .{
+                        .asm_node_offset = extra.data.src_node,
+                        .input_index = @intCast(arg_i),
+                    },
+                };
+                if (try sema.typeRequiresComptime(uncasted_arg_ty)) {
+                    return sema.fail(
+                        block,
+                        input_op_src,
+                        "type '{}' is comptime-only and cannot be used for an asm input operand",
+                        .{uncasted_arg_ty.fmt(mod)},
+                    );
+                }
+                if (!uncasted_arg_ty.hasRuntimeBitsIgnoreComptime(mod)) {
+                    return sema.fail(
+                        block,
+                        input_op_src,
+                        "type '{}' does not have runtime bits and cannot be used for an asm input operand",
+                        .{uncasted_arg_ty.fmt(mod)},
+                    );
+                }
+                if (!uncasted_arg_ty.hasWellDefinedLayout(mod)) {
+                    return sema.fail(
+                        block,
+                        input_op_src,
+                        "type '{}' does not have a well-defined memory layout and cannot be used for an asm input operand",
+                        .{uncasted_arg_ty.fmt(mod)},
+                    );
+                }
                 arg.* = uncasted_arg;
                 try sema.queueFullTypeResolution(uncasted_arg_ty);
             },

test/behavior/asm.zig

@@ -146,11 +146,19 @@ test "struct/array/union types as input values" {
     ); // fails
     asm volatile (""
         :
-        : [_] "m" (@as(struct { x: u32, y: u8 }, undefined)),
+        : [_] "m" (@as(packed struct { x: u32, y: u8 }, undefined)),
     ); // fails
     asm volatile (""
         :
-        : [_] "m" (@as(union { x: u32, y: u8 }, undefined)),
+        : [_] "m" (@as(packed union { x: u32, y: u8 }, undefined)),
+    ); // fails
+    asm volatile (""
+        :
+        : [_] "m" (@as(extern struct { x: u32, y: u8 }, undefined)),
+    ); // fails
+    asm volatile (""
+        :
+        : [_] "m" (@as(extern union { x: u32, y: u8 }, undefined)),
     ); // fails
 }
 

test/cases/compile_errors/bad_asm_input_operands.zig

@@ -0,0 +1,70 @@
+export fn a() void {
+    asm volatile (""
+        :
+        : [_] "{al}" (u8),
+    );
+}
+export fn b() void {
+    asm volatile (""
+        :
+        : [_] "{a}" (0),
+          [_] "{x}" (&&void),
+    );
+}
+export fn c() void {
+    const A = struct {};
+    asm volatile (""
+        :
+        : [_] "{x}" (1),
+          [_] "{x}" (A{}),
+    );
+}
+export fn d() void {
+    const A = struct { x: u8 };
+    asm volatile (""
+        :
+        : [_] "{x}" (((packed struct { x: u8 }){ .x = 1 })),
+          [_] "{x}" (extern struct { x: u8 }{ .x = 1 }),
+          [_] "{x}" (A{ .x = 1 }),
+    );
+}
+export fn e() void {
+    asm volatile (""
+        :
+        : [_] "{x}" (@Vector(3, u8){ 1, 2, 3 }),
+          [_] "{x}" ([2]*const type{ &u8, &u8 }),
+    );
+}
+export fn f() void {
+    asm volatile (""
+        :
+        : [_] "{x}" (undefined),
+    );
+}
+export fn g() void {
+    asm volatile (""
+        :
+        : [_] "{x}" ({}),
+    );
+}
+export fn h() void {
+    asm volatile (""
+        :
+        : [_] "{x}" (@as([]const u8, "hello")),
+    );
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :4:23: error: type 'type' is comptime-only and cannot be used for an asm input operand
+// :11:22: error: type '*const *const type' is comptime-only and cannot be used for an asm input operand
+// :19:23: error: type 'tmp.c.A' does not have runtime bits and cannot be used for an asm input operand
+// :15:15: note: struct declared here
+// :28:23: error: type 'tmp.d.A' does not have a well-defined memory layout and cannot be used for an asm input operand
+// :23:15: note: struct declared here
+// :35:36: error: type '[2]*const type' is comptime-only and cannot be used for an asm input operand
+// :41:22: error: type '@TypeOf(undefined)' is comptime-only and cannot be used for an asm input operand
+// :47:22: error: type 'void' does not have runtime bits and cannot be used for an asm input operand
+// :53:22: error: type '[]const u8' does not have a well-defined memory layout and cannot be used for an asm input operand