| # 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. |
| |
| 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] ### resource name fileoff conflicts with builtin type |
| |
| 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 |
| |
| 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 r9["foo"] ### unexpected string "foo", expect type |
| |
| foo$7(a r0, a1 r2[opt]) |
| foo$8(a fileoff[a, b, c]) ### wrong number of arguments for type fileoff, expect no arguments |
| foo$9(a buffer[inout]) |
| foo$10(a buffer[intout]) ### unexpected value intout for direction argument of buffer type, expect [in out inout] |
| foo$11(a buffer["in"]) ### unexpected string "in" for direction argument of buffer type, expect [in out inout] |
| foo$12(a buffer[10]) ### unexpected int 10 for direction argument of buffer type, expect [in out inout] |
| foo$13(a int32[2:3]) |
| foo$14(a int32[2:2]) |
| foo$16(a int32[3]) |
| 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 range argument of int32 type, expect 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) ### unexpected ':' |
| 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, string arg must be a string literal or string flags |
| 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]]) ### range argument has subargs |
| foo$64(a ptr[in, flags[f1[int32], int32]]) ### flags argument has subargs |
| |
| 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 |
| |
| 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 |
| } [packed, align_4] |
| |
| s4 { |
| f1 int8 |
| } [align_7] ### bad struct s4 alignment 7 (must be a sane power of 2) |
| |
| s5 { |
| f1 int8 |
| } [varlen] ### unknown struct s5 attribute varlen |
| |
| s6 { |
| f1 int8 |
| } [align_foo] ### bad struct s6 alignment foo |
| |
| 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 |
| |
| 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 bool8 int8[0:1] ### type name bool8 conflicts with builtin type |
| |
| 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] |
| |
| # 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 ### unknown type B |
| } |
| |
| type templ_base0[TYPE] { |
| f1 TYPE |
| } |
| |
| type templ_templ0[BASE] { |
| f1 BASE |
| } |
| |
| type templ_templ1[BASE] { |
| f1 BASE[int16] ### both template parameter BASE 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]]) |
| |
| # 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 |
| } |
