github.com/google/syzkaller@v0.0.0-20251211124644-a066d2bc4b02/pkg/compiler/testdata/errors.txt

# Copyright 2017 syzkaller project authors. All rights reserved.
# Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.

# Errors that happen during type checking phase.

meta foobar			### unknown type foobar
meta noextract["foo"]		### wrong number of arguments for type noextract, expect no arguments
meta "foobar"			### unexpected string "foobar", expect type
meta arches["z80"]		### unknown arch z80

#include "something"		### confusing comment faking a directive (rephrase if it's intentional)
#define FOO BAR			### confusing comment faking a directive (rephrase if it's intentional)
# include "something"		### confusing comment faking a directive (rephrase if it's intentional)
#	incdir "dir"		### confusing comment faking a directive (rephrase if it's intentional)

foo$0(x fileoff, y int8, z buffer[in])
foo$1(x "bar")			### unexpected string "bar", expect type
foo$2(x 123, y "bar")		### unexpected int 123, expect type	### unexpected string "bar", expect type
foo$3(x string)			### string can't be syscall argument

resource r0[int32]: 0, 0x1
resource r1[string["foo"]]	### string can't be resource base (int types can)
resource r1[int32]		### type r1 redeclared, previously declared as resource at LOCATION
resource int32[int32]		### resource name int32 conflicts with builtin type
resource fileoff[intptr]	### type fileoff redeclared, previously declared as type alias at builtins

s1 {
	f1	int32
}

s1 {				### type s1 redeclared, previously declared as struct at LOCATION
	f1	int32
	f1	intptr		### duplicate field f1 in struct s1
	parent	int8		### reserved field name parent in struct s1
}

s2 {				### struct s2 has no fields, need at least 1 field
}

int32 {				### struct name int32 conflicts with builtin type
	f1	int32
}

r0 {				### type r0 redeclared, previously declared as resource at LOCATION
	f1	int32
}

u0 [
	f1	int32
	f2	fileoff[int32]
]

u1 [				### union u1 has no fields, need at least 1 field
]

u2 [
	f1	int8
	f1	int16		### duplicate field f1 in union u2
	parent	int32		### reserved field name parent in union u2
]

foo$4(a int8, a int16)		### duplicate argument a in syscall foo$4
foo$4()				### syscall foo$4 redeclared, previously declared at LOCATION
foo()
foo()				### syscall foo redeclared, previously declared at LOCATION
foo$5(a0 int8, a1 int8, a2 int8, a3 int8, a4 int8, a5 int8, a6 int8, a7 int8, a8 int8, a9 int8)	### syscall foo$5 has 10 arguments, allowed maximum is 9
foo$6(parent int8)		### reserved argument name parent in syscall foo$6

f1 = 1
f2 = 1, 2
f2 = 1, 2			### flags f2 redeclared, previously declared at LOCATION
sf1 = "a"
sf2 = "a", "b"
sf2 = "c"			### string flags sf2 redeclared, previously declared at LOCATION

f110 = 1, 2, 3, 4, f120		### flags f110 used twice or circular dependency on f110
f120 = 10, 11, 12, f130		### flags f120 used twice or circular dependency on f120
f130 = 100, 110, f110		### flags f130 used twice or circular dependency on f130

loop_flags(a flags[f110])

f200 = f300, 200, 201		### flags identifier not at the end in f200 definition
f300 = 300, 301

f210 = "1", "2", "3", f220	### flags f210 used twice or circular dependency on f210
f220 = "10", "11", f230		### flags f220 used twice or circular dependency on f220
f230 = "100", "110", f210	### flags f230 used twice or circular dependency on f230

resource r2[r0]: 2
resource r3[int32:1]		### unexpected ':', only struct fields can be bitfields
resource r4[int32[opt]]		### resource base can't be marked as opt
resource r5[non_existent]	### unknown type non_existent
resource r6[int64be]		### int64be can't be resource base (int types can)
resource r9["foo"]		### unexpected string "foo", expect type

foo$7(a r0, a1 r2[opt])
foo$8(a fileoff[a, b, int8])	### template fileoff needs 0 arguments instead of 3
foo$9(a buffer[inout])
foo$10(a buffer[intout])	### unexpected value intout for direction argument of ptr type, expect [in out inout]
foo$11(a buffer["in"])		### unexpected string "in" for direction argument of ptr type, expect [in out inout]
foo$12(a buffer[10])		### unexpected int 10 for direction argument of ptr type, expect [in out inout]
foo$13(a int32[2:3])
foo$14(a int32[2:2])
foo$17(a ptr[in, int32])
foo$18(a ptr[in, int32[2:3]])
foo$19(a ptr[in, int32[opt]])
foo$20(a ptr)			### wrong number of arguments for type ptr, expect direction, type, [opt]
foo$21(a ptr["foo"])		### wrong number of arguments for type ptr, expect direction, type, [opt]
foo$22(a ptr[in])		### wrong number of arguments for type ptr, expect direction, type, [opt]
foo$23(a ptr[in, s3[in]])	### wrong number of arguments for type s3, expect no arguments
foo$25(a proc[0, "foo"])	### unexpected string "foo" for per-proc values argument of proc type, expect int
foo$26(a flags[no])		### unknown flags no
foo$27(a flags["foo"])		### unexpected string "foo" for flags argument of flags type, expect identifier
foo$28(a ptr[in, string["foo"]], b ptr[in, string["foo", 4]])
foo$30(a ptr[in, string[no]])	### unknown string flags no
foo$31(a int8, b ptr[in, csum[a, inet]])		### wrong number of arguments for type csum, expect csum target, kind, [proto], base type
foo$32(a int8, b ptr[in, csum[a, inet, 1, int32]])	### only pseudo csum can have proto
foo$33(a int8, b ptr[in, csum[a, pseudo, 1, int32]])
foo$34(a int32["foo"])		### unexpected string "foo" for value argument of int32 type, expect identifier or int
foo$35(a ptr[in, s3[opt]])	### s3 can't be marked as opt
foo$36(a const[1:2])		### unexpected ':'
foo$39(a fileoff:1)		### type alias fileoff with ':'
foo$40(a len["a"])		### unexpected string "a" for len target argument of len type, expect identifier
foo$41(a vma[C1:C2])
foo$43(a ptr[in, string[1]])	### unexpected int 1 for literal or flags argument of string type, expect string or identifier
foo$44(a int32) len[a]		### len can't be syscall return
foo$45(a int32) len[b]		### len can't be syscall return
foo$46(a ptr[in, in])		### unknown type in
foo$47(a int32:2)		### unexpected ':', only struct fields can be bitfields
foo$48(a ptr[in, int32:7])	### unexpected ':', only struct fields can be bitfields
foo$49(a ptr[in, array[int32, 0:1]])
foo$52(a intptr, b bitsize[a])
foo$53(a proc[20, 10, opt])
# This must not error yet (consts are not patched).
foo$54(a ptr[in, string["foo", C1]])
foo$55(a int8[opt[int8]])	### opt can't have arguments
foo$56(a void)			### void can't be syscall argument
foo$57(a ptr[in, stringnoz["foo", 10]])	### fixed-size string can't be non-zero-terminated
foo$58(a ptr[in, stringnoz[sf2, 10]])	### fixed-size string can't be non-zero-terminated
foo$59(a s1)			### s1 can't be syscall argument
foo$60() s1			### s1 can't be syscall return
foo$61(a u6)			### u6 can't be syscall argument
foo$62() u6			### u6 can't be syscall return
foo$63(a int32[1[2]])		### value argument has subargs
foo$64(a ptr[in, flags[f1[int32], int32]])	### flags argument has subargs
foo$65(a int32, b len[1])	### unexpected int 1 for len target argument of len type, expect identifier
foo$66(a int32, b len[a:1])	### unexpected int 1 after colon, expect identifier
foo$67(x int32[1:2:3, opt])	### unexpected ':'
foo$68(a int32[15, 2])		### align argument of int32 is not supported unless first argument is a range
foo$69() (foo)			### unknown syscall foo$69 attribute foo
foo$70() ("foo")		### unexpected string "foo", expect attribute
foo$71() (42)			### unexpected int 42, expect attribute
foo$72() (disabled, disabled)	### duplicate syscall foo$72 attribute disabled
foo$73(a int32[int_flags, 2])	### align argument of int32 is not supported unless first argument is a range
foo$74() (int8:1)		### unexpected ':'

opt {				### struct uses reserved name opt
	f1	int32
}

in = 1, 2			### flags uses reserved name in
out = "1", "2"			### string flags uses reserved name out
int_flags = 0, 1, 0xabc, 'x', -11

out [				### union uses reserved name out
	f1	int32
	f2	int8
]

resource inout[int32]		### resource uses reserved name inout

bar()

s3 {
	f1	int8:0		### bitfields of size 0 are not supported
	f2	int8:1
	f3	int8:7
	f4	int8:8
	f5	int8:9		### bitfield of size 9 is too large for base type of size 8
	f6	int32:32
	f7	int32:33	### bitfield of size 33 is too large for base type of size 32
	f8	const[0, int32:C1]	### literal const bitfield sizes are not supported
	f9	const[0]	### wrong number of arguments for type const, expect value, base type
	f10	int8:1:1	### unexpected ':'
} [packed, align[4]]

s5 {
	f1	int8
} [varlen]			### unknown struct s5 attribute varlen

s7 {
	f1	ptr64[in, int32]
}

s8 {
	f1	int8
} [unknown]			### unknown struct s8 attribute unknown

s9 {
	f1	int8
} ["foo"[0]]			### unexpected string "foo", expect attribute

s10 {
	f1	int8
} [packed[0]]			### packed attribute has args

s11 {
	f1	int8
} [size["foo"]]			### unexpected string "foo", expect int

s12 {
	f1	int8
} [size[0:1]]			### size attribute has colon or args

s13 {
	f1	int8
} [size[0[0]]]			### size attribute has colon or args

s14 {
	f1	int8
} [size[1, 2]]			### size attribute is expected to have 1 argument

u3 [
	f1	int8
	f2	int32
] [varlen]

u4 [
	f1	int8
	f2	int32
] [packed]			### unknown union u4 attribute packed

u5 [
	f1	int8:1		### unexpected ':', only struct fields can be bitfields
	f2	int8:2		### unexpected ':', only struct fields can be bitfields
]

u6 [
	f1	int8
	f2	int64
	f3	array[int8]
]

define d0 SOMETHING
define d1 `some C expression`
define d2 some C expression
define d2 SOMETHING		### duplicate define d2
define d3 1

# Type aliases.

type mybool8 int8[0:1]
type mybool16 int16[0:1]
type net_port proc[100, 1, int16be]
resource typeres0[mybool8]
typestruct {
	f1	mybool8
	f2	mybool16
}

type type0 int8
type type0 int8			### type type0 redeclared, previously declared as type alias at LOCATION
resource type0[int32]		### type type0 redeclared, previously declared as type alias at LOCATION
type0 = 0, 1
type type1 type1		### type instantiation loop: type1 -> type1
type type2 int8:4		### unexpected ':', only struct fields can be bitfields
type type3 type2		### unknown type type2
type type4 const[0]		### wrong number of arguments for type const, expect value, base type
type type6 len[foo, int32]	### len can't be type alias target
type type7 len[foo]		### len can't be type alias target
resource typeres1[int32]
type type8 typeres1		### typeres1 can't be type alias target
type int8 int8			### type name int8 conflicts with builtin type
type opt int8			### type uses reserved name opt
type type9 const[0, int8]
type type12 proc[123, 2, int16, opt]
type type13 ptr[in, typestruct13]
type type14 flags[type0, int32]
type type15 const[0, type0]	### unexpected value type0 for base type argument of const type, expect [int8 int16 int32 int64 int16be int32be int64be intptr]
type type16 type17		### type instantiation loop: type16 -> type16
type type17 type18		### unknown type type16
type type18 type16		### unknown type type16
type bool8 int8[0:1]		### type bool8 redeclared, previously declared as type alias at builtins

typestruct11 {
	f	type11		### unknown type type11
}

typestruct12 {
	f	type11		### unknown type type11
}

typestruct13 {
	f1	type9
	f2	type12
}

foo$100(a mybool8, b mybool16)
foo$102(a type2)		### unknown type type2
foo$103(a type0:4)		### type alias type0 with ':'
foo$104(a type0[opt])		### type type0 is not a template
foo$105() type0			### int8 can't be syscall return
foo$106() type6			### unknown type type6
foo$107(a type9, b type12)
foo$108(a flags[type0])
foo$109(a ptr[in, type0])

# Type templates.

type templ0[A, B] const[A, B]
type templ2[A] A[0]
type templ3[A] ptr[in, A]
type templ4[A, A] ptr[in, A]	### duplicate type argument A
type templ5[abc] ptr[in, abc]	### type argument abc must be ALL_CAPS
type templ6[T] ptr[in, T]
type templ7 templ0[templ6, int8]
type templ8[BASE, A] BASE[A]	### type argument BASE must be the last argument
type templ9[BASE] BASE
type templ10[A] templ9[A]
type templ11[VAL, BASE] const[VAL, BASE]

# Note: here 42 is stripped as base type, so const ends up without arguments.
foo$201(a templ1[42])		### wrong number of arguments for type const, expect value
type templ1[A] const[A]

type templ_struct0[A, B] {
	len	len[parent, int16]
	typ	const[A, int16]
	data	B
} [align[4]]

type templ_struct1[STR] {
	f	string[STR, 40]
	f	int32		### duplicate field f in template struct templ_struct1
}

type templ_struct2[A] {
	f	B
}

type templ_base0[TYPE] {
	f1	TYPE
}

type templ_templ0[B] {
	f1	B
}

type templ_templ1[B] {
	f1	B[int16]			### both template parameter B and its usage have sub-arguments
}

templ_templ_use0 {
	f1	templ_templ0[templ_base0]	### template templ_base0 needs 1 arguments instead of 0
	f2	templ_templ1[templ_base0[int32]]
}

foo$200(a templ0[42, int8])
foo$202(a templ0)		### template templ0 needs 2 arguments instead of 0
foo$203(a type0[42])		### type type0 is not a template
foo$204(a ptr[in, templ_struct0[42, int8]])
foo$205(a ptr[in, templ_struct0[int8, int8]])
foo$207(a ptr[in, templ_struct2[1]])		### template argument A is not used
foo$208(a ptr[in, templ9[string["foo"]]])	### unexpected value string for base type argument of templ9 type, expect [int8 int16 int32 int64 int16be int32be int64be intptr]
foo$209(a ptr[in, templ10[templ0[42, int8]]])	### unexpected value templ0 for base type argument of templ9 type, expect [int8 int16 int32 int64 int16be int32be int64be intptr]
foo$210(a ptr[in, templ11[0, 1, int8]])		### template templ11 needs 2 arguments instead of 3
foo$211(a ptr[in, templ9])			### template templ9 needs 1 arguments instead of 0
foo$212(a ptr[in, templ11[1]])			### template templ11 needs 2 arguments instead of 1

type TR[A, B] {
	f TR[A, A[B]]		### type instantiation recursion: TR[X, Y] -> TR[X, X[Y]] -> TR[X, X[X[Y]]] -> TR[X, X[X[X[Y]]]] -> TR[X, X[X[X[X[Y]]]]] -> TR[X, X[X[X[X[X[Y]]]]]] -> TR[X, X[X[X[X[X[X[Y]]]]]]] -> TR[X, X[X[X[X[X[X[X[Y]]]]]]]] -> TR[X, X[X[X[X[X[X[X[X[Y]]]]]]]]] -> TR[X, X[X[X[X[X[X[X[X[X[Y]]]]]]]]]] -> TR[X, X[X[X[X[X[X[X[X[X[X[Y]]]]]]]]]]] -> TR[X, X[X[X[X[X[X[X[X[X[X[X[Y]]]]]]]]]]]]
}
type TU TR[X, Y]

type TT1[A] {
	f0 templ_base0[A]
	f1 TT2[A]
}

type TT2[A] {
	f1 templ_base0[A]
	f2 TT3[A]
}

type TT3[A] {
	f1 templ_base0[A]
	f2 TT1[A]				### type instantiation loop: TT1[int8] -> TT2[int8] -> TT3[int8] -> TT1[int8]
}

foo$213(a ptr[in, TT1[int8]])

foo$glob001(a ptr[in, glob[1]])			### unexpected int 1 for literal or flags argument of glob type, expect string or identifier
foo$glob002(a ptr[in, glob])			### glob only accepts 1 arg, provided 0
foo$glob003(a ptr[in, glob["/sys", 5]])		### glob only accepts 1 arg, provided 2
foo$glob004(a ptr[in, glob["/sys", 5, 2]])	### wrong number of arguments for type glob, expect [literal or flags], [size], [opt]

# fmt

foo$fmt0(a ptr[in, fmt])			### wrong number of arguments for type fmt, expect format, value
foo$fmt1(a fmt[dec, int8])			### fmt can't be syscall argument
foo$fmt2(a ptr[in, fmt[dec, ptr[in, int8]]])	### bad fmt value ptr, expect an integer
foo$fmt3(a ptr[in, fmt[foo, int8]])		### unexpected value foo for format argument of fmt type, expect [dec hex oct]
foo$fmt4(a ptr[in, fmt[dec, int8:3]])		### unexpected ':', only struct fields can be bitfields

struct$fmt0 {
	f0	fmt[dec, int8:3]		### unexpected ':', only struct fields can be bitfields
	f1	int32:-1			### bitfield of size 18446744073709551615 is too large for base type of size 32
}

struct$perfielddir {
	f0	int32	(in, in)	### duplicate arg/field f0 attribute in
	f1	int32	(out, out)	### duplicate arg/field f1 attribute out
	f2	int32	(inout, inout)	### duplicate arg/field f2 attribute inout
	f3	int32	(in, out)	### arg/field has multiple direction attributes
	f4	int32	(in, inout)	### arg/field has multiple direction attributes
	f5	int32	(out, inout)	### arg/field has multiple direction attributes
	f6	int32	(in, out, inout)	### arg/field has multiple direction attributes
}

struct$overlay0 {
	f0	int32	(out_overlay)	### out_overlay attribute must not be specified on the first field
	f1	int32	(out_overlay)	### multiple out_overlay attributes
}

struct$overlay1 {
	f0	int32
	f1	int32	(out_overlay, out_overlay)	### duplicate arg/field f1 attribute out_overlay
	f2	int32	(out_overlay)	### multiple out_overlay attributes
}

struct$overlay2 {
	f0	int32	(in)
	f1	int32	(out_overlay)	### mix of direction and out_overlay attributes is not supported
}

union$overlay0 [
	f0	int32
	f1	int32	(out_overlay)	### unknown arg/field f1 attribute out_overlay
]

union$directions [
	f1	int32	(in)
	f2	int32	(out)	### unknown arg/field f2 attribute out
	f3	int32	(inout)	### unknown arg/field f3 attribute inout
]


compressed$test(a int32) compressed_image	### compressed_image can't be syscall return

define FLAG1 = 1
define FLAG2 = 2

some_nested_flags {
	f1	int32
}

conditional_fields {
	f1	int32
	f2      some_nested_flags (if[value[f1] & FLAG1])
	f3      some_nested_flags (if[value[f1] & FLAG1], if[value[f1] & FLAG1]) ### duplicate arg/field f3 attribute if
	f4      some_nested_flags (if[value & FLAG1]) ### value reference must have only one argument
	f5      some_nested_flags (if[value[f1] & FLAG1, FLAG2]) ### if attribute is expected to have only one argument
	f6      some_nested_flags (if[value[f1, FLAG2] & FLAG1]) ### value reference must have only one argument
	f7      some_nested_flags (if[5])
	f8      some_nested_flags
	f9      some_nested_flags (if[value[f8:f1] & FLAG1])
	f10     some_nested_flags (if[value[f8:f1, A] & FLAG1]) ### value reference must have only one argument
	f11     some_nested_flags (if[value[f8:f1[A]] & FLAG1]) ### value aguments must not have any further arguments
	f12     some_nested_flags (if[f1 == "A"]) ### the token must be either an integer or an identifier
	f13     some_nested_flags (if["ABCD"]) ### if argument must be an expression
	f14     some_nested_flags (if[X[Y]]) ### consts in expressions must not have any arguments
	f15	conditional_fields_union1
	f16	conditional_fields_union2
}

conditional_fields_union1 [
	u1	int32 (if [value[parent:f1] & FLAG1])
	u2	int32 (if [value[parent:f1] & FLAG2]) ### unions must not have if conditions on the last field
]

conditional_fields_union2 [
	u1	int32 (if [value[parent:f1] & FLAG1])
	u2	int32 ### either no fields have conditions or all except the last
	u3	int32
]

invalid_string_attr() (invalid["string"])	### unknown syscall invalid_string_attr attribute invalid