* [PATCH] add support for GCC's __auto_type
@ 2020-03-24 9:57 Luc Van Oostenryck
2020-03-25 0:37 ` Ramsay Jones
0 siblings, 1 reply; 3+ messages in thread
From: Luc Van Oostenryck @ 2020-03-24 9:57 UTC (permalink / raw)
To: linux-sparse; +Cc: Luc Van Oostenryck
Despite the similarity with typeof, the approach taken here
is relatively different. A specific symbol type (SYM_TYPEOF)
is not used, instead a new flag is added to decl_state, another
one in the declared symbol and a new internal type is used:
'autotype_ctype'. It's this new internal type that will be
resolved to the definitive type at evalution time.
It seems to be working pretty well, maybe because it
hasn't been tested well enough.
Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
parse.c | 38 +++++++++++++++++++++++++++
symbol.c | 19 ++++++++++++++
symbol.h | 2 ++
validation/autotype-ko.c | 45 ++++++++++++++++++++++++++++++++
validation/autotype.c | 55 ++++++++++++++++++++++++++++++++++++++++
5 files changed, 159 insertions(+)
create mode 100644 validation/autotype-ko.c
create mode 100644 validation/autotype.c
diff --git a/parse.c b/parse.c
index 0e6f66a86037..a29c67c8cf41 100644
--- a/parse.c
+++ b/parse.c
@@ -60,6 +60,7 @@ static declarator_t
thread_specifier, const_qualifier, volatile_qualifier;
static declarator_t restrict_qualifier;
static declarator_t atomic_qualifier;
+static declarator_t autotype_specifier;
static struct token *parse_if_statement(struct token *token, struct statement *stmt);
static struct token *parse_return_statement(struct token *token, struct statement *stmt);
@@ -213,6 +214,13 @@ static struct symbol_op typeof_op = {
.set = Set_S|Set_T,
};
+static struct symbol_op autotype_op = {
+ .type = KW_SPECIFIER,
+ .declarator = autotype_specifier,
+ .test = Set_Any,
+ .set = Set_S|Set_T,
+};
+
static struct symbol_op attribute_op = {
.type = KW_ATTRIBUTE,
.declarator = attribute_specifier,
@@ -505,6 +513,7 @@ static struct init_keyword {
{ "typeof", NS_TYPEDEF, .op = &typeof_op },
{ "__typeof", NS_TYPEDEF, .op = &typeof_op },
{ "__typeof__", NS_TYPEDEF, .op = &typeof_op },
+ { "__auto_type",NS_TYPEDEF, .op = &autotype_op },
{ "__attribute", NS_TYPEDEF, .op = &attribute_op },
{ "__attribute__", NS_TYPEDEF, .op = &attribute_op },
@@ -1078,6 +1087,13 @@ static struct token *typeof_specifier(struct token *token, struct decl_state *ct
return expect(token, ')', "after typeof");
}
+static struct token *autotype_specifier(struct token *token, struct decl_state *ctx)
+{
+ ctx->ctype.base_type = &autotype_ctype;
+ ctx->autotype = 1;
+ return token;
+}
+
static struct token *ignore_attribute(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
struct expression *expr = NULL;
@@ -2985,6 +3001,11 @@ struct token *external_declaration(struct token *token, struct symbol_list **lis
}
}
} else if (base_type && base_type->type == SYM_FN) {
+ if (base_type->ctype.base_type == &autotype_ctype) {
+ sparse_error(decl->pos, "'%s()' has __auto_type return type",
+ show_ident(decl->ident));
+ base_type->ctype.base_type = &int_ctype;
+ }
if (base_type->ctype.base_type == &incomplete_ctype) {
warning(decl->pos, "'%s()' has implicit return type",
show_ident(decl->ident));
@@ -3037,6 +3058,23 @@ struct token *external_declaration(struct token *token, struct symbol_list **lis
}
}
+ if (ctx.autotype) {
+ const char *msg = NULL;
+ if (decl->ctype.base_type != &autotype_ctype)
+ msg = "on non-identifier";
+ else if (match_op(token, ','))
+ msg = "on declaration list";
+ else if (!decl->initializer)
+ msg = "without initializer";
+ else if (decl->initializer->type == EXPR_SYMBOL &&
+ decl->initializer->symbol == decl)
+ msg = "on self-init var";
+ if (msg) {
+ sparse_error(decl->pos, "__auto_type %s", msg);
+ decl->ctype.base_type = &bad_ctype;
+ }
+ }
+
if (!match_op(token, ','))
break;
diff --git a/symbol.c b/symbol.c
index ab6e9841696f..c2e6f0b426b3 100644
--- a/symbol.c
+++ b/symbol.c
@@ -192,6 +192,10 @@ static struct symbol * examine_struct_union_type(struct symbol *sym, int advance
fn = advance ? lay_out_struct : lay_out_union;
FOR_EACH_PTR(sym->symbol_list, member) {
+ if (member->ctype.base_type == &autotype_ctype) {
+ sparse_error(member->pos, "member '%s' has __auto_type", show_ident(member->ident));
+ member->ctype.base_type = &incomplete_ctype;
+ }
fn(member, &info);
} END_FOR_EACH_PTR(member);
@@ -210,6 +214,19 @@ static struct symbol *examine_base_type(struct symbol *sym)
{
struct symbol *base_type;
+ if (sym->ctype.base_type == &autotype_ctype) {
+ struct symbol *type = evaluate_expression(sym->initializer);
+ if (!type)
+ type = &bad_ctype;
+ if (is_bitfield_type(type)) {
+ warning(sym->pos, "__auto_type on bitfield");
+ if (type->type == SYM_NODE)
+ type = type->ctype.base_type;
+ type = type->ctype.base_type;
+ }
+ sym->ctype.base_type = type;
+ }
+
/* Check the base type */
base_type = examine_symbol_type(sym->ctype.base_type);
if (!base_type || base_type->type == SYM_PTR)
@@ -734,6 +751,7 @@ struct symbol bool_ctype, void_ctype, type_ctype,
string_ctype, ptr_ctype, lazy_ptr_ctype,
incomplete_ctype, label_ctype, bad_ctype,
null_ctype;
+struct symbol autotype_ctype;
struct symbol int_ptr_ctype, uint_ptr_ctype;
struct symbol long_ptr_ctype, ulong_ptr_ctype;
struct symbol llong_ptr_ctype, ullong_ptr_ctype;
@@ -792,6 +810,7 @@ static const struct ctype_declare {
{ &void_ctype, T_BASETYPE },
{ &type_ctype, T_BASETYPE },
{ &incomplete_ctype, T_BASETYPE },
+ { &autotype_ctype, T_BASETYPE },
{ &bad_ctype, T_BASETYPE },
{ &char_ctype, T__INT(-2, char) },
diff --git a/symbol.h b/symbol.h
index 270ae098cacf..c86dfb335e29 100644
--- a/symbol.h
+++ b/symbol.h
@@ -110,6 +110,7 @@ struct decl_state {
unsigned long f_modifiers; // function attributes
unsigned char prefer_abstract, is_inline, storage_class, is_tls;
unsigned char is_ext_visible;
+ unsigned char autotype;
};
struct pseudo;
@@ -281,6 +282,7 @@ extern struct symbol bool_ctype, void_ctype, type_ctype,
string_ctype, ptr_ctype, lazy_ptr_ctype,
incomplete_ctype, label_ctype, bad_ctype,
null_ctype;
+extern struct symbol autotype_ctype;
extern struct symbol int_ptr_ctype, uint_ptr_ctype;
extern struct symbol long_ptr_ctype, ulong_ptr_ctype;
extern struct symbol llong_ptr_ctype, ullong_ptr_ctype;
diff --git a/validation/autotype-ko.c b/validation/autotype-ko.c
new file mode 100644
index 000000000000..5b6cd708ade7
--- /dev/null
+++ b/validation/autotype-ko.c
@@ -0,0 +1,45 @@
+__auto_type u; // KO: no initializer
+__auto_type r[2] = { 0, 1 }; // KO: not a plain identifier
+__auto_type foo(void) { } // KO: not a plain identifier
+__auto_type v = 0, w = 1; // KO: in list
+struct { __auto_type x; } s; // KO: not valid for struct/union
+__auto_type self = self; // KO: self-declared
+__auto_type undc = this; // KO: undeclared
+
+int i = 1;
+double f = 1.0;
+__auto_type i = 2; // KO: redecl, same type
+__auto_type f = 2.0f; // KO: redecl, diff type
+
+
+static int foo(int a, const int *ptr)
+{
+ __auto_type i = a;
+ __auto_type c = *ptr;
+
+ c += 1;
+ return i;
+}
+
+/*
+ * check-name: autotype-ko
+ * check-command: sparse -Wno-decl $file
+ *
+ * check-error-start
+autotype-ko.c:1:13: error: __auto_type without initializer
+autotype-ko.c:2:13: error: __auto_type on non-identifier
+autotype-ko.c:3:13: error: 'foo()' has __auto_type return type
+autotype-ko.c:4:13: error: __auto_type on declaration list
+autotype-ko.c:6:13: error: __auto_type on self-init var
+autotype-ko.c:2:20: error: invalid initializer
+autotype-ko.c:5:22: error: member 'x' has __auto_type
+autotype-ko.c:7:20: error: undefined identifier 'this'
+autotype-ko.c:11:13: error: symbol 'i' has multiple initializers (originally initialized at autotype-ko.c:9)
+autotype-ko.c:12:13: error: symbol 'f' has multiple initializers (originally initialized at autotype-ko.c:10)
+autotype-ko.c:12:13: error: symbol 'f' redeclared with different type (different type sizes):
+autotype-ko.c:12:13: float [addressable] [toplevel] f
+autotype-ko.c:10:8: note: previously declared as:
+autotype-ko.c:10:8: double [addressable] [toplevel] f
+autotype-ko.c:20:9: error: assignment to const expression
+ * check-error-end
+ */
diff --git a/validation/autotype.c b/validation/autotype.c
new file mode 100644
index 000000000000..98683c93d2e8
--- /dev/null
+++ b/validation/autotype.c
@@ -0,0 +1,55 @@
+#ifdef __CHECKER__
+#define is_type(X, T) _Static_assert([typeof(X)] == [T], "")
+#else
+#define is_type(X, T) _Static_assert(1, "")
+#endif
+
+struct s {
+ int x;
+ int bf:3;
+};
+
+extern char ch;
+extern const int ci;
+
+__auto_type i = 0; is_type(i, int);
+__auto_type m = 1UL; is_type(m, unsigned long);
+__auto_type l = (int)0L; is_type(l, int);
+__auto_type c = (char)'\n'; is_type(c, char);
+__auto_type p = &i; is_type(p, int *);
+__auto_type f = 0.0; is_type(f, double);
+__auto_type s = (struct s){0}; is_type(s, struct s);
+__auto_type pci = &ci; is_type(pci, const int *);
+
+// ~~: not valid for bitfield
+__auto_type b = (struct s){0}.bf; is_type(b, int);
+
+static __auto_type si = 0; is_type(si, int);
+const __auto_type ci = 0; is_type(ci, const int);
+__auto_type ch = (char) '\n'; is_type(ch, char);
+
+static int foo(int a)
+{
+ __auto_type i = a; is_type(i, int);
+ __auto_type c = ch; is_type(c, char);
+ __auto_type ct = ci; is_type(&ct, const int *);
+
+ return ct += i + c;
+}
+
+
+
+#define __as __attribute__((address_space(42)))
+extern int __as aa;
+
+__auto_type pa = &aa; is_type(pa, int __as *);
+
+/*
+ * check-name: autotype
+ * check-command: sparse -Wno-decl $file
+ *
+ * check-error-start
+autotype.c:25:13: warning: __auto_type on bitfield
+autotype.c:37:16: error: assignment to const expression
+ * check-error-end
+ */
--
2.25.1
^ permalink raw reply related [flat|nested] 3+ messages in thread
* Re: [PATCH] add support for GCC's __auto_type
2020-03-24 9:57 [PATCH] add support for GCC's __auto_type Luc Van Oostenryck
@ 2020-03-25 0:37 ` Ramsay Jones
2020-03-25 1:39 ` Luc Van Oostenryck
0 siblings, 1 reply; 3+ messages in thread
From: Ramsay Jones @ 2020-03-25 0:37 UTC (permalink / raw)
To: Luc Van Oostenryck, linux-sparse
On 24/03/2020 09:57, Luc Van Oostenryck wrote:
> Despite the similarity with typeof, the approach taken here
> is relatively different. A specific symbol type (SYM_TYPEOF)
> is not used, instead a new flag is added to decl_state, another
> one in the declared symbol and a new internal type is used:
> 'autotype_ctype'. It's this new internal type that will be
> resolved to the definitive type at evalution time.
>
> It seems to be working pretty well, maybe because it
> hasn't been tested well enough.
I haven't tested this (yet) either, but it looks good from what I see
in my email client! ;-) (I deleted my Linux repo many years ago, because
I was always over 90+% used on my disk - and I was only using it as a
'large' repo to test git!).
BTW, I recently upgraded an 32-bit Linux Mint 18.3 to 19.2 using a
'nuke and pave' procedure, rather than the 'upgrade path' provided
by Linux Mint. As part of that, I backed up my $HOME directory from
18.3 and 'restored' it to the new 19.2 (so far, so good). When I built
sparse (before installing llvm), the test-suite failed all of the
'backend/' tests. Given that these tests should have been SKIPed, since
sparse-llvm was disabled, I was a little surprised.
I am sure that you will have guessed by now, that I had an sparse-llvm
executable from 18.3 laying around, ... :-D
I thought about sending a patch to the Makefile to always include the
sparse-llvm program in the clean target (it wouldn't hurt being in the
'rm' invocation twice), but decided that this is unlikely to happen very
often, so ...
BTW, I noticed that we don't install 'sparse-llvm-dis' or 'sparsei' as
part of the 'llvm programs' - should we?
ATB,
Ramsay Jones
>
> Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
> ---
> parse.c | 38 +++++++++++++++++++++++++++
> symbol.c | 19 ++++++++++++++
> symbol.h | 2 ++
> validation/autotype-ko.c | 45 ++++++++++++++++++++++++++++++++
> validation/autotype.c | 55 ++++++++++++++++++++++++++++++++++++++++
> 5 files changed, 159 insertions(+)
> create mode 100644 validation/autotype-ko.c
> create mode 100644 validation/autotype.c
>
> diff --git a/parse.c b/parse.c
> index 0e6f66a86037..a29c67c8cf41 100644
> --- a/parse.c
> +++ b/parse.c
> @@ -60,6 +60,7 @@ static declarator_t
> thread_specifier, const_qualifier, volatile_qualifier;
> static declarator_t restrict_qualifier;
> static declarator_t atomic_qualifier;
> +static declarator_t autotype_specifier;
>
> static struct token *parse_if_statement(struct token *token, struct statement *stmt);
> static struct token *parse_return_statement(struct token *token, struct statement *stmt);
> @@ -213,6 +214,13 @@ static struct symbol_op typeof_op = {
> .set = Set_S|Set_T,
> };
>
> +static struct symbol_op autotype_op = {
> + .type = KW_SPECIFIER,
> + .declarator = autotype_specifier,
> + .test = Set_Any,
> + .set = Set_S|Set_T,
> +};
> +
> static struct symbol_op attribute_op = {
> .type = KW_ATTRIBUTE,
> .declarator = attribute_specifier,
> @@ -505,6 +513,7 @@ static struct init_keyword {
> { "typeof", NS_TYPEDEF, .op = &typeof_op },
> { "__typeof", NS_TYPEDEF, .op = &typeof_op },
> { "__typeof__", NS_TYPEDEF, .op = &typeof_op },
> + { "__auto_type",NS_TYPEDEF, .op = &autotype_op },
>
> { "__attribute", NS_TYPEDEF, .op = &attribute_op },
> { "__attribute__", NS_TYPEDEF, .op = &attribute_op },
> @@ -1078,6 +1087,13 @@ static struct token *typeof_specifier(struct token *token, struct decl_state *ct
> return expect(token, ')', "after typeof");
> }
>
> +static struct token *autotype_specifier(struct token *token, struct decl_state *ctx)
> +{
> + ctx->ctype.base_type = &autotype_ctype;
> + ctx->autotype = 1;
> + return token;
> +}
> +
> static struct token *ignore_attribute(struct token *token, struct symbol *attr, struct decl_state *ctx)
> {
> struct expression *expr = NULL;
> @@ -2985,6 +3001,11 @@ struct token *external_declaration(struct token *token, struct symbol_list **lis
> }
> }
> } else if (base_type && base_type->type == SYM_FN) {
> + if (base_type->ctype.base_type == &autotype_ctype) {
> + sparse_error(decl->pos, "'%s()' has __auto_type return type",
> + show_ident(decl->ident));
> + base_type->ctype.base_type = &int_ctype;
> + }
> if (base_type->ctype.base_type == &incomplete_ctype) {
> warning(decl->pos, "'%s()' has implicit return type",
> show_ident(decl->ident));
> @@ -3037,6 +3058,23 @@ struct token *external_declaration(struct token *token, struct symbol_list **lis
> }
> }
>
> + if (ctx.autotype) {
> + const char *msg = NULL;
> + if (decl->ctype.base_type != &autotype_ctype)
> + msg = "on non-identifier";
> + else if (match_op(token, ','))
> + msg = "on declaration list";
> + else if (!decl->initializer)
> + msg = "without initializer";
> + else if (decl->initializer->type == EXPR_SYMBOL &&
> + decl->initializer->symbol == decl)
> + msg = "on self-init var";
> + if (msg) {
> + sparse_error(decl->pos, "__auto_type %s", msg);
> + decl->ctype.base_type = &bad_ctype;
> + }
> + }
> +
> if (!match_op(token, ','))
> break;
>
> diff --git a/symbol.c b/symbol.c
> index ab6e9841696f..c2e6f0b426b3 100644
> --- a/symbol.c
> +++ b/symbol.c
> @@ -192,6 +192,10 @@ static struct symbol * examine_struct_union_type(struct symbol *sym, int advance
>
> fn = advance ? lay_out_struct : lay_out_union;
> FOR_EACH_PTR(sym->symbol_list, member) {
> + if (member->ctype.base_type == &autotype_ctype) {
> + sparse_error(member->pos, "member '%s' has __auto_type", show_ident(member->ident));
> + member->ctype.base_type = &incomplete_ctype;
> + }
> fn(member, &info);
> } END_FOR_EACH_PTR(member);
>
> @@ -210,6 +214,19 @@ static struct symbol *examine_base_type(struct symbol *sym)
> {
> struct symbol *base_type;
>
> + if (sym->ctype.base_type == &autotype_ctype) {
> + struct symbol *type = evaluate_expression(sym->initializer);
> + if (!type)
> + type = &bad_ctype;
> + if (is_bitfield_type(type)) {
> + warning(sym->pos, "__auto_type on bitfield");
> + if (type->type == SYM_NODE)
> + type = type->ctype.base_type;
> + type = type->ctype.base_type;
> + }
> + sym->ctype.base_type = type;
> + }
> +
> /* Check the base type */
> base_type = examine_symbol_type(sym->ctype.base_type);
> if (!base_type || base_type->type == SYM_PTR)
> @@ -734,6 +751,7 @@ struct symbol bool_ctype, void_ctype, type_ctype,
> string_ctype, ptr_ctype, lazy_ptr_ctype,
> incomplete_ctype, label_ctype, bad_ctype,
> null_ctype;
> +struct symbol autotype_ctype;
> struct symbol int_ptr_ctype, uint_ptr_ctype;
> struct symbol long_ptr_ctype, ulong_ptr_ctype;
> struct symbol llong_ptr_ctype, ullong_ptr_ctype;
> @@ -792,6 +810,7 @@ static const struct ctype_declare {
> { &void_ctype, T_BASETYPE },
> { &type_ctype, T_BASETYPE },
> { &incomplete_ctype, T_BASETYPE },
> + { &autotype_ctype, T_BASETYPE },
> { &bad_ctype, T_BASETYPE },
>
> { &char_ctype, T__INT(-2, char) },
> diff --git a/symbol.h b/symbol.h
> index 270ae098cacf..c86dfb335e29 100644
> --- a/symbol.h
> +++ b/symbol.h
> @@ -110,6 +110,7 @@ struct decl_state {
> unsigned long f_modifiers; // function attributes
> unsigned char prefer_abstract, is_inline, storage_class, is_tls;
> unsigned char is_ext_visible;
> + unsigned char autotype;
> };
>
> struct pseudo;
> @@ -281,6 +282,7 @@ extern struct symbol bool_ctype, void_ctype, type_ctype,
> string_ctype, ptr_ctype, lazy_ptr_ctype,
> incomplete_ctype, label_ctype, bad_ctype,
> null_ctype;
> +extern struct symbol autotype_ctype;
> extern struct symbol int_ptr_ctype, uint_ptr_ctype;
> extern struct symbol long_ptr_ctype, ulong_ptr_ctype;
> extern struct symbol llong_ptr_ctype, ullong_ptr_ctype;
> diff --git a/validation/autotype-ko.c b/validation/autotype-ko.c
> new file mode 100644
> index 000000000000..5b6cd708ade7
> --- /dev/null
> +++ b/validation/autotype-ko.c
> @@ -0,0 +1,45 @@
> +__auto_type u; // KO: no initializer
> +__auto_type r[2] = { 0, 1 }; // KO: not a plain identifier
> +__auto_type foo(void) { } // KO: not a plain identifier
> +__auto_type v = 0, w = 1; // KO: in list
> +struct { __auto_type x; } s; // KO: not valid for struct/union
> +__auto_type self = self; // KO: self-declared
> +__auto_type undc = this; // KO: undeclared
> +
> +int i = 1;
> +double f = 1.0;
> +__auto_type i = 2; // KO: redecl, same type
> +__auto_type f = 2.0f; // KO: redecl, diff type
> +
> +
> +static int foo(int a, const int *ptr)
> +{
> + __auto_type i = a;
> + __auto_type c = *ptr;
> +
> + c += 1;
> + return i;
> +}
> +
> +/*
> + * check-name: autotype-ko
> + * check-command: sparse -Wno-decl $file
> + *
> + * check-error-start
> +autotype-ko.c:1:13: error: __auto_type without initializer
> +autotype-ko.c:2:13: error: __auto_type on non-identifier
> +autotype-ko.c:3:13: error: 'foo()' has __auto_type return type
> +autotype-ko.c:4:13: error: __auto_type on declaration list
> +autotype-ko.c:6:13: error: __auto_type on self-init var
> +autotype-ko.c:2:20: error: invalid initializer
> +autotype-ko.c:5:22: error: member 'x' has __auto_type
> +autotype-ko.c:7:20: error: undefined identifier 'this'
> +autotype-ko.c:11:13: error: symbol 'i' has multiple initializers (originally initialized at autotype-ko.c:9)
> +autotype-ko.c:12:13: error: symbol 'f' has multiple initializers (originally initialized at autotype-ko.c:10)
> +autotype-ko.c:12:13: error: symbol 'f' redeclared with different type (different type sizes):
> +autotype-ko.c:12:13: float [addressable] [toplevel] f
> +autotype-ko.c:10:8: note: previously declared as:
> +autotype-ko.c:10:8: double [addressable] [toplevel] f
> +autotype-ko.c:20:9: error: assignment to const expression
> + * check-error-end
> + */
> diff --git a/validation/autotype.c b/validation/autotype.c
> new file mode 100644
> index 000000000000..98683c93d2e8
> --- /dev/null
> +++ b/validation/autotype.c
> @@ -0,0 +1,55 @@
> +#ifdef __CHECKER__
> +#define is_type(X, T) _Static_assert([typeof(X)] == [T], "")
> +#else
> +#define is_type(X, T) _Static_assert(1, "")
> +#endif
> +
> +struct s {
> + int x;
> + int bf:3;
> +};
> +
> +extern char ch;
> +extern const int ci;
> +
> +__auto_type i = 0; is_type(i, int);
> +__auto_type m = 1UL; is_type(m, unsigned long);
> +__auto_type l = (int)0L; is_type(l, int);
> +__auto_type c = (char)'\n'; is_type(c, char);
> +__auto_type p = &i; is_type(p, int *);
> +__auto_type f = 0.0; is_type(f, double);
> +__auto_type s = (struct s){0}; is_type(s, struct s);
> +__auto_type pci = &ci; is_type(pci, const int *);
> +
> +// ~~: not valid for bitfield
> +__auto_type b = (struct s){0}.bf; is_type(b, int);
> +
> +static __auto_type si = 0; is_type(si, int);
> +const __auto_type ci = 0; is_type(ci, const int);
> +__auto_type ch = (char) '\n'; is_type(ch, char);
> +
> +static int foo(int a)
> +{
> + __auto_type i = a; is_type(i, int);
> + __auto_type c = ch; is_type(c, char);
> + __auto_type ct = ci; is_type(&ct, const int *);
> +
> + return ct += i + c;
> +}
> +
> +
> +
> +#define __as __attribute__((address_space(42)))
> +extern int __as aa;
> +
> +__auto_type pa = &aa; is_type(pa, int __as *);
> +
> +/*
> + * check-name: autotype
> + * check-command: sparse -Wno-decl $file
> + *
> + * check-error-start
> +autotype.c:25:13: warning: __auto_type on bitfield
> +autotype.c:37:16: error: assignment to const expression
> + * check-error-end
> + */
>
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: [PATCH] add support for GCC's __auto_type
2020-03-25 0:37 ` Ramsay Jones
@ 2020-03-25 1:39 ` Luc Van Oostenryck
0 siblings, 0 replies; 3+ messages in thread
From: Luc Van Oostenryck @ 2020-03-25 1:39 UTC (permalink / raw)
To: Ramsay Jones; +Cc: linux-sparse
On Wed, Mar 25, 2020 at 12:37:22AM +0000, Ramsay Jones wrote:
> On 24/03/2020 09:57, Luc Van Oostenryck wrote:
> > Despite the similarity with typeof, the approach taken here
> > is relatively different. A specific symbol type (SYM_TYPEOF)
> > is not used, instead a new flag is added to decl_state, another
> > one in the declared symbol and a new internal type is used:
> > 'autotype_ctype'. It's this new internal type that will be
> > resolved to the definitive type at evalution time.
> >
> > It seems to be working pretty well, maybe because it
> > hasn't been tested well enough.
>
> I haven't tested this (yet) either, but it looks good from what I see
> in my email client! ;-) (I deleted my Linux repo many years ago, because
> I was always over 90+% used on my disk - and I was only using it as a
> 'large' repo to test git!).
Yes, its size become interesting ;)
But it shouldn't contain (yet) an occurence of __auto_type so
it wouldn't help here.
> BTW, I recently upgraded an 32-bit Linux Mint 18.3 to 19.2 using a
> 'nuke and pave' procedure, rather than the 'upgrade path' provided
> by Linux Mint. As part of that, I backed up my $HOME directory from
> 18.3 and 'restored' it to the new 19.2 (so far, so good). When I built
> sparse (before installing llvm), the test-suite failed all of the
> 'backend/' tests. Given that these tests should have been SKIPed, since
> sparse-llvm was disabled, I was a little surprised.
>
> I am sure that you will have guessed by now, that I had an sparse-llvm
> executable from 18.3 laying around, ... :-D
For a moment you worried because I understood it as if it was
one in your PATH or so and this shouldn't be called from the
testsuite. But yes, it could happen if it comes from an old build
in the current directory.
> I thought about sending a patch to the Makefile to always include the
> sparse-llvm program in the clean target (it wouldn't hurt being in the
> 'rm' invocation twice), but decided that this is unlikely to happen very
> often, so ...
Mmmm, yes, it wouldn't hurt.
We could also do something like:
ifeq ($(HAVE_LLVM),yes)
... stuff ...
else
CLEAN += sparse-llvm
endif
which has the advantage to not have to keep elsewhere the list
of extra targets for cleaning and keeping these things together.
> BTW, I noticed that we don't install 'sparse-llvm-dis' or 'sparsei' as
> part of the 'llvm programs' - should we?
I don't think so.
I only added sparse-llvm-dis to debug sparse-llvm and when sparsei
was added it also wasn't installed, for the same reason I think,
they're just dev tools. Now, if sparse-llvm would be more complete
and would more commonly used then yes, maybe.
In my opinion, none of the tools that depends on an external library
should be installed by default. Each of them should be, for the
distros, a separate package (like some distros do/did for inspect).
Keep safe,
-- Luc
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2020-03-25 1:39 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2020-03-24 9:57 [PATCH] add support for GCC's __auto_type Luc Van Oostenryck
2020-03-25 0:37 ` Ramsay Jones
2020-03-25 1:39 ` Luc Van Oostenryck
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox