aboutsummaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--builtin.c60
-rw-r--r--evaluate.c43
-rw-r--r--evaluate.h7
-rw-r--r--expand.c18
-rw-r--r--lib.c2
-rw-r--r--linearize.c44
-rw-r--r--simplify.c20
-rw-r--r--symbol.c25
-rw-r--r--symbol.h7
-rw-r--r--tokenize.c5
-rw-r--r--validation/builtin-sync-cas.c25
-rw-r--r--validation/expand/bad-shift.c8
-rw-r--r--validation/init-wstring.c40
-rw-r--r--validation/init_cstring.c2
-rw-r--r--validation/linear/bug-assign-op0.c1
-rw-r--r--validation/linear/shift-assign1.c319
-rw-r--r--validation/linear/shift-assign2.c53
-rw-r--r--validation/optim/shift-big.c12
-rw-r--r--validation/preprocessor/bad-cmdline-include.c11
-rw-r--r--validation/shift-negative.c4
-rw-r--r--validation/shift-undef-long.c7
-rw-r--r--validation/shift-undef.c52
22 files changed, 661 insertions, 104 deletions
diff --git a/builtin.c b/builtin.c
index f29b4a8d..2e9be8be 100644
--- a/builtin.c
+++ b/builtin.c
@@ -355,6 +355,62 @@ static struct symbol_op overflow_p_op = {
};
+static int eval_sync_compare_and_swap(struct expression *expr)
+{
+ struct symbol_list *types = NULL;
+ struct symbol *ctype = NULL;
+ struct expression *arg;
+ int n = 0;
+
+ /* the first arg is a pointer type; we'd already verified that */
+ FOR_EACH_PTR(expr->args, arg) {
+ struct symbol *t = arg->ctype;
+
+ if (!t)
+ return 0;
+
+ // 2nd & 3rd args must be a basic integer type or a pointer
+ // 1st arg must be a pointer to such a type.
+ if (++n == 1) {
+ if (t->type == SYM_NODE)
+ t = t->ctype.base_type;
+ if (!t)
+ return 0;
+ if (t->type != SYM_PTR)
+ goto err;
+ t = t->ctype.base_type;
+ if (!t)
+ return 0;
+ if (t->type == SYM_NODE)
+ t = t->ctype.base_type;
+ if (!t)
+ return 0;
+ if (t->type != SYM_PTR && t->ctype.base_type != &int_type)
+ goto err;
+ ctype = t;
+ add_ptr_list(&types, arg->ctype);
+ } else {
+ add_ptr_list(&types, ctype);
+ }
+ } END_FOR_EACH_PTR(arg);
+
+ if (!expr->ctype) // __sync_val_compare_and_swap()
+ expr->ctype = ctype;
+ return evaluate_arguments(types, expr->args);
+
+err:
+ sparse_error(arg->pos, "invalid type for argument %d:", n);
+ info(arg->pos, " %s", show_typename(arg->ctype));
+ expr->ctype = &bad_ctype;
+ return 0;
+}
+
+static struct symbol_op sync_compare_and_swap_op = {
+ .args = args_triadic,
+ .evaluate = eval_sync_compare_and_swap,
+};
+
+
/*
* Builtin functions
*/
@@ -548,7 +604,7 @@ static const struct builtin_fn builtins_common[] = {
{ "__sync_add_and_fetch", &int_ctype, 1, { &ptr_ctype }},
{ "__sync_and_and_fetch", &int_ctype, 1, { &ptr_ctype }},
- { "__sync_bool_compare_and_swap", &int_ctype, 1, { &ptr_ctype }},
+ { "__sync_bool_compare_and_swap", &bool_ctype, 1, { &ptr_ctype }, .op = &sync_compare_and_swap_op},
{ "__sync_fetch_and_add", &int_ctype, 1, { &ptr_ctype }},
{ "__sync_fetch_and_and", &int_ctype, 1, { &ptr_ctype }},
{ "__sync_fetch_and_nand", &int_ctype, 1, { &ptr_ctype }},
@@ -561,7 +617,7 @@ static const struct builtin_fn builtins_common[] = {
{ "__sync_or_and_fetch", &int_ctype, 1, { &ptr_ctype }},
{ "__sync_sub_and_fetch", &int_ctype, 1, { &ptr_ctype }},
{ "__sync_synchronize", &void_ctype, 0 },
- { "__sync_val_compare_and_swap", &int_ctype, 1, { &ptr_ctype }},
+ { "__sync_val_compare_and_swap", NULL, 1, { &ptr_ctype }, .op = &sync_compare_and_swap_op },
{ "__sync_xor_and_fetch", &int_ctype, 1, { &ptr_ctype }},
{ }
diff --git a/evaluate.c b/evaluate.c
index 6d5bbca5..63a9390b 100644
--- a/evaluate.c
+++ b/evaluate.c
@@ -102,9 +102,10 @@ static struct symbol *evaluate_string(struct expression *expr)
struct expression *addr = alloc_expression(expr->pos, EXPR_SYMBOL);
struct expression *initstr = alloc_expression(expr->pos, EXPR_STRING);
unsigned int length = expr->string->length;
+ struct symbol *char_type = expr->wide ? wchar_ctype : &char_ctype;
sym->array_size = alloc_const_expression(expr->pos, length);
- sym->bit_size = bytes_to_bits(length);
+ sym->bit_size = length * char_type->bit_size;
sym->ctype.alignment = 1;
sym->string = 1;
sym->ctype.modifiers = MOD_STATIC;
@@ -117,10 +118,10 @@ static struct symbol *evaluate_string(struct expression *expr)
initstr->string = expr->string;
array->array_size = sym->array_size;
- array->bit_size = bytes_to_bits(length);
- array->ctype.alignment = 1;
+ array->bit_size = sym->bit_size;
+ array->ctype.alignment = char_type->ctype.alignment;
array->ctype.modifiers = MOD_STATIC;
- array->ctype.base_type = &char_ctype;
+ array->ctype.base_type = char_type;
array->examined = 1;
array->evaluated = 1;
@@ -405,7 +406,10 @@ static inline int is_string_type(struct symbol *type)
{
if (type->type == SYM_NODE)
type = type->ctype.base_type;
- return type->type == SYM_ARRAY && is_byte_type(type->ctype.base_type);
+ if (type->type != SYM_ARRAY)
+ return 0;
+ type = type->ctype.base_type;
+ return is_byte_type(type) || is_wchar_type(type);
}
static struct symbol *bad_expr_type(struct expression *expr)
@@ -1342,8 +1346,17 @@ static int evaluate_assign_op(struct expression *expr)
return 1;
} else if (op == SPECIAL_SHR_ASSIGN || op == SPECIAL_SHL_ASSIGN) {
// shifts do integer promotions, but that's it.
+ unrestrict(expr->left, tclass, &t);
+ target = integer_promotion(t);
+
unrestrict(expr->right, sclass, &s);
- target = integer_promotion(s);
+ source = integer_promotion(s);
+ expr->right = cast_to(expr->right, source);
+
+ // both gcc & clang seems to do this, so ...
+ if (target->bit_size > source->bit_size)
+ expr->right = cast_to(expr->right, &uint_ctype);
+
goto Cast;
} else if (!(sclass & TYPE_RESTRICT))
goto usual;
@@ -2333,14 +2346,13 @@ static struct symbol *evaluate_alignof(struct expression *expr)
return size_t_ctype;
}
-static int evaluate_arguments(struct symbol *fn, struct expression_list *head)
+int evaluate_arguments(struct symbol_list *argtypes, struct expression_list *head)
{
struct expression *expr;
- struct symbol_list *argument_types = fn->arguments;
struct symbol *argtype;
int i = 1;
- PREPARE_PTR_LIST(argument_types, argtype);
+ PREPARE_PTR_LIST(argtypes, argtype);
FOR_EACH_PTR (head, expr) {
struct expression **p = THIS_ADDRESS(expr);
struct symbol *ctype, *target;
@@ -2760,7 +2772,6 @@ static struct expression *handle_scalar(struct expression *e, int nested)
static int handle_initializer(struct expression **ep, int nested,
int class, struct symbol *ctype, unsigned long mods)
{
- int is_string = is_string_type(ctype);
struct expression *e = *ep, *p;
struct symbol *type;
@@ -2794,7 +2805,7 @@ static int handle_initializer(struct expression **ep, int nested,
* pathologies, so we don't need anything fancy here.
*/
if (e->type == EXPR_INITIALIZER) {
- if (is_string) {
+ if (is_string_type(ctype)) {
struct expression *v = NULL;
int count = 0;
@@ -2815,7 +2826,7 @@ static int handle_initializer(struct expression **ep, int nested,
/* string */
if (is_string_literal(&e)) {
/* either we are doing array of char, or we'll have to dig in */
- if (is_string) {
+ if (is_string_type(ctype)) {
*ep = e;
goto String;
}
@@ -2840,10 +2851,12 @@ String:
*p = *e;
type = evaluate_expression(p);
if (ctype->bit_size != -1) {
- if (ctype->bit_size + bits_in_char < type->bit_size)
+ struct symbol *char_type = e->wide ? wchar_ctype : &char_ctype;
+ unsigned int size_with_null = ctype->bit_size + char_type->bit_size;
+ if (size_with_null < type->bit_size)
warning(e->pos,
"too long initializer-string for array of char");
- else if (Winit_cstring && ctype->bit_size + bits_in_char == type->bit_size) {
+ else if (Winit_cstring && size_with_null == type->bit_size) {
warning(e->pos,
"too long initializer-string for array of char(no space for nul char)");
}
@@ -3149,7 +3162,7 @@ static struct symbol *evaluate_call(struct expression *expr)
if (!sym->op->args(expr))
return NULL;
} else {
- if (!evaluate_arguments(ctype, arglist))
+ if (!evaluate_arguments(ctype->arguments, arglist))
return NULL;
args = expression_list_size(expr->args);
fnargs = symbol_list_size(ctype->arguments);
diff --git a/evaluate.h b/evaluate.h
index f68f7fb7..a16e9703 100644
--- a/evaluate.h
+++ b/evaluate.h
@@ -2,6 +2,7 @@
#define EVALUATE_H
struct expression;
+struct expression_list;
struct statement;
struct symbol;
struct symbol_list;
@@ -25,4 +26,10 @@ struct symbol *evaluate_statement(struct statement *stmt);
// @list: the list of the symbol to be evaluated
void evaluate_symbol_list(struct symbol_list *list);
+///
+// evaluate the arguments of a function
+// @argtypes: the list of the types in the prototype
+// @args: the list of the effective arguments
+int evaluate_arguments(struct symbol_list *argtypes, struct expression_list *args);
+
#endif
diff --git a/expand.c b/expand.c
index b0789331..623b1800 100644
--- a/expand.c
+++ b/expand.c
@@ -170,22 +170,6 @@ Float:
expr->type = EXPR_FVALUE;
}
-static void warn_shift_count(struct expression *expr, struct symbol *ctype, long long count)
-{
- if (count < 0) {
- if (!Wshift_count_negative)
- return;
- warning(expr->pos, "shift count is negative (%lld)", count);
- return;
- }
- if (ctype->type == SYM_NODE)
- ctype = ctype->ctype.base_type;
-
- if (!Wshift_count_overflow)
- return;
- warning(expr->pos, "shift too big (%llu) for type %s", count, show_typename(ctype));
-}
-
/* Return true if constant shift size is valid */
static bool check_shift_count(struct expression *expr, struct expression *right)
{
@@ -194,8 +178,6 @@ static bool check_shift_count(struct expression *expr, struct expression *right)
if (count >= 0 && count < ctype->bit_size)
return true;
- if (!conservative)
- warn_shift_count(expr, ctype, count);
return false;
}
diff --git a/lib.c b/lib.c
index 2b600fee..4bc5cd02 100644
--- a/lib.c
+++ b/lib.c
@@ -383,6 +383,8 @@ struct symbol_list *sparse_initialize(int argc, char **argv, struct string_list
char **args;
struct symbol_list *list;
+ base_filename = "command-line";
+
// Initialize symbol stream first, so that we can add defines etc
init_symbols();
diff --git a/linearize.c b/linearize.c
index 49274681..5a8e7497 100644
--- a/linearize.c
+++ b/linearize.c
@@ -2468,6 +2468,49 @@ static pseudo_t linearize_statement(struct entrypoint *ep, struct statement *stm
return VOID;
}
+static void check_tainted_insn(struct instruction *insn)
+{
+ unsigned long long uval;
+ long long sval;
+ pseudo_t src2;
+
+ switch (insn->opcode) {
+ case OP_DIVU: case OP_DIVS:
+ case OP_MODU: case OP_MODS:
+ if (insn->src2 == value_pseudo(0))
+ warning(insn->pos, "divide by zero");
+ break;
+ case OP_SHL: case OP_LSR: case OP_ASR:
+ src2 = insn->src2;
+ if (src2->type != PSEUDO_VAL)
+ break;
+ uval = src2->value;
+ if (uval < insn->size)
+ break;
+ sval = sign_extend(uval, insn->size);
+ if (Wshift_count_negative && sval < 0)
+ warning(insn->pos, "shift count is negative (%lld)", sval);
+ else if (Wshift_count_overflow)
+ warning(insn->pos, "shift too big (%llu) for type %s", uval, show_typename(insn->type));
+ }
+}
+
+///
+// issue warnings after all possible DCE
+static void late_warnings(struct entrypoint *ep)
+{
+ struct basic_block *bb;
+ FOR_EACH_PTR(ep->bbs, bb) {
+ struct instruction *insn;
+ FOR_EACH_PTR(bb->insns, insn) {
+ if (!insn->bb)
+ continue;
+ if (insn->tainted)
+ check_tainted_insn(insn);
+ } END_FOR_EACH_PTR(insn);
+ } END_FOR_EACH_PTR(bb);
+}
+
static struct entrypoint *linearize_fn(struct symbol *sym, struct symbol *base_type)
{
struct statement *stmt = base_type->stmt;
@@ -2514,6 +2557,7 @@ static struct entrypoint *linearize_fn(struct symbol *sym, struct symbol *base_t
add_one_insn(ep, ret);
optimize(ep);
+ late_warnings(ep);
return ep;
}
diff --git a/simplify.c b/simplify.c
index 7850bcdc..f6b79685 100644
--- a/simplify.c
+++ b/simplify.c
@@ -754,28 +754,18 @@ static long long check_shift_count(struct instruction *insn, unsigned long long
unsigned int size = insn->size;
long long sval = uval;
+ if (insn->tainted)
+ return -1;
+
if (uval < size)
return uval;
+ insn->tainted = 1;
sval = sign_extend_safe(sval, size);
sval = sign_extend_safe(sval, bits_in_int);
if (sval < 0)
insn->src2 = value_pseudo(sval);
- if (insn->tainted)
- return sval;
-
- if (sval < 0 && Wshift_count_negative)
- warning(insn->pos, "shift count is negative (%lld)", sval);
- if (sval > 0 && Wshift_count_overflow) {
- struct symbol *ctype = insn->type;
- const char *tname;
- if (ctype->type == SYM_NODE)
- ctype = ctype->ctype.base_type;
- tname = show_typename(ctype);
- warning(insn->pos, "shift too big (%llu) for type %s", sval, tname);
- }
- insn->tainted = 1;
- return sval;
+ return -1;
}
static int simplify_shift(struct instruction *insn, pseudo_t pseudo, long long value)
diff --git a/symbol.c b/symbol.c
index 6fcb1b15..7f0c8558 100644
--- a/symbol.c
+++ b/symbol.c
@@ -307,6 +307,29 @@ void merge_type(struct symbol *sym, struct symbol *base_type)
merge_type(sym, sym->ctype.base_type);
}
+static bool is_wstring_expr(struct expression *expr)
+{
+ while (expr) {
+ switch (expr->type) {
+ case EXPR_STRING:
+ return 1;
+ case EXPR_INITIALIZER:
+ if (expression_list_size(expr->expr_list) != 1)
+ return 0;
+ expr = first_expression(expr->expr_list);
+ break;
+ case EXPR_PREOP:
+ if (expr->op == '(') {
+ expr = expr->unop;
+ break;
+ }
+ default:
+ return 0;
+ }
+ }
+ return 0;
+}
+
static int count_array_initializer(struct symbol *t, struct expression *expr)
{
int nr = 0;
@@ -321,6 +344,8 @@ static int count_array_initializer(struct symbol *t, struct expression *expr)
*/
if (t->ctype.base_type == &int_type && t->rank == -2)
is_char = 1;
+ else if (t == wchar_ctype && is_wstring_expr(expr))
+ is_char = 1;
switch (expr->type) {
case EXPR_INITIALIZER: {
diff --git a/symbol.h b/symbol.h
index 8e7a2860..0e15f7bf 100644
--- a/symbol.h
+++ b/symbol.h
@@ -430,6 +430,13 @@ static inline int is_byte_type(struct symbol *type)
return type->bit_size == bits_in_char && type->type != SYM_BITFIELD;
}
+static inline int is_wchar_type(struct symbol *type)
+{
+ if (type->type == SYM_NODE)
+ type = type->ctype.base_type;
+ return type == wchar_ctype;
+}
+
static inline int is_void_type(struct symbol *type)
{
if (type->type == SYM_NODE)
diff --git a/tokenize.c b/tokenize.c
index d68fbcd8..ca842f52 100644
--- a/tokenize.c
+++ b/tokenize.c
@@ -66,7 +66,10 @@ int stream_prev(int stream)
{
if (stream < 0 || stream > input_stream_nr)
return -1;
- return input_streams[stream].pos.stream;
+ stream = input_streams[stream].pos.stream;
+ if (stream > input_stream_nr)
+ return -1;
+ return stream;
}
static struct position stream_pos(stream_t *stream)
diff --git a/validation/builtin-sync-cas.c b/validation/builtin-sync-cas.c
new file mode 100644
index 00000000..846e21bb
--- /dev/null
+++ b/validation/builtin-sync-cas.c
@@ -0,0 +1,25 @@
+static int *foo(int *ptr)
+{
+ __sync_val_compare_and_swap(ptr, 123, 0L);
+ return __sync_val_compare_and_swap(&ptr, ptr, ptr);
+}
+
+static long bar(long *ptr)
+{
+ return __sync_val_compare_and_swap(ptr, ptr, 1);
+}
+
+static _Bool boz(_Bool *ptr)
+{
+ return __sync_bool_compare_and_swap(ptr, 0, ptr);
+}
+
+/*
+ * check-name: builtin-sync-cas
+ *
+ * check-error-start
+builtin-sync-cas.c:9:49: warning: incorrect type in argument 2 (different base types)
+builtin-sync-cas.c:9:49: expected long
+builtin-sync-cas.c:9:49: got long *ptr
+ * check-error-end
+ */
diff --git a/validation/expand/bad-shift.c b/validation/expand/bad-shift.c
index 22c4341f..b68866c2 100644
--- a/validation/expand/bad-shift.c
+++ b/validation/expand/bad-shift.c
@@ -56,9 +56,9 @@ rneg:
* check-output-end
*
* check-error-start
-expand/bad-shift.c:5:18: warning: shift too big (32) for type int
-expand/bad-shift.c:10:18: warning: shift count is negative (-1)
-expand/bad-shift.c:15:18: warning: shift too big (32) for type int
-expand/bad-shift.c:20:18: warning: shift count is negative (-1)
+expand/bad-shift.c:5:21: warning: shift too big (32) for type int
+expand/bad-shift.c:10:21: warning: shift count is negative (-1)
+expand/bad-shift.c:15:21: warning: shift too big (32) for type int
+expand/bad-shift.c:20:21: warning: shift count is negative (-1)
* check-error-end
*/
diff --git a/validation/init-wstring.c b/validation/init-wstring.c
new file mode 100644
index 00000000..d9ce3b3c
--- /dev/null
+++ b/validation/init-wstring.c
@@ -0,0 +1,40 @@
+static const __WCHAR_TYPE__ ok0[] = L"abc";
+_Static_assert(sizeof(ok0) == 4 * sizeof(__WCHAR_TYPE__));
+static const __WCHAR_TYPE__ ok1[] = (L"abc");
+_Static_assert(sizeof(ok1) == 4 * sizeof(__WCHAR_TYPE__));
+static const __WCHAR_TYPE__ ok2[] = { L"abc" };
+_Static_assert(sizeof(ok2) == 4 * sizeof(__WCHAR_TYPE__));
+
+static const __WCHAR_TYPE__ ok3[4] = L"abc";
+_Static_assert(sizeof(ok3) == 4 * sizeof(__WCHAR_TYPE__));
+static const __WCHAR_TYPE__ ok4[4] = (L"abc");
+_Static_assert(sizeof(ok4) == 4 * sizeof(__WCHAR_TYPE__));
+static const __WCHAR_TYPE__ ok5[4] = { (L"abc") };
+_Static_assert(sizeof(ok5) == 4 * sizeof(__WCHAR_TYPE__));
+
+static const __WCHAR_TYPE__ ok6[7] = L"abc";
+_Static_assert(sizeof(ok6) == 7 * sizeof(__WCHAR_TYPE__));
+static const __WCHAR_TYPE__ ok7[7] = (L"abc");
+_Static_assert(sizeof(ok7) == 7 * sizeof(__WCHAR_TYPE__));
+static const __WCHAR_TYPE__ ok8[7] = { (L"abc") };
+_Static_assert(sizeof(ok8) == 7 * sizeof(__WCHAR_TYPE__));
+
+static const __WCHAR_TYPE__ *ptr[] = { L"abc" };
+_Static_assert(sizeof(ptr) == sizeof(void *));
+
+static struct s {
+ const __WCHAR_TYPE__ str[4];
+} str = { L"xyz" };
+
+static const __WCHAR_TYPE__ ko3[3] = L"abc";
+static const __WCHAR_TYPE__ ko2[2] = L"abc";
+
+/*
+ * check-name: init-wstring
+ * check-command: sparse -Winit-cstring $file
+ *
+ * check-error-start
+init-wstring.c:29:38: warning: too long initializer-string for array of char(no space for nul char)
+init-wstring.c:30:38: warning: too long initializer-string for array of char
+ * check-error-end
+ */
diff --git a/validation/init_cstring.c b/validation/init_cstring.c
index 00eca20a..bac814e4 100644
--- a/validation/init_cstring.c
+++ b/validation/init_cstring.c
@@ -1,11 +1,13 @@
static struct alpha {
char a[2];
} x = { .a = "ab" };
+static const char str[2] = "abc";
/*
* check-name: -Winit-cstring option
*
* check-command: sparse -Winit-cstring $file
* check-error-start
init_cstring.c:3:14: warning: too long initializer-string for array of char(no space for nul char)
+init_cstring.c:4:28: warning: too long initializer-string for array of char
* check-error-end
*/
diff --git a/validation/linear/bug-assign-op0.c b/validation/linear/bug-assign-op0.c
index 0cabc622..b351bb51 100644
--- a/validation/linear/bug-assign-op0.c
+++ b/validation/linear/bug-assign-op0.c
@@ -46,7 +46,6 @@ unsigned int sldivu(unsigned int u, long s)
/*
* check-name: bug-assign-op0
* check-command: test-linearize -Wno-decl $file
- * check-known-to-fail
*
* check-output-start
asr:
diff --git a/validation/linear/shift-assign1.c b/validation/linear/shift-assign1.c
new file mode 100644
index 00000000..4c96fc28
--- /dev/null
+++ b/validation/linear/shift-assign1.c
@@ -0,0 +1,319 @@
+typedef __INT16_TYPE__ s16;
+typedef __INT32_TYPE__ s32;
+typedef __INT64_TYPE__ s64;
+typedef __UINT16_TYPE__ u16;
+typedef __UINT32_TYPE__ u32;
+typedef __UINT64_TYPE__ u64;
+
+s16 s16s16(s16 a, s16 b) { a >>= b; return a; }
+s16 s16s32(s16 a, s32 b) { a >>= b; return a; }
+s16 s16s64(s16 a, s64 b) { a >>= b; return a; }
+s16 s16u16(s16 a, u16 b) { a >>= b; return a; }
+s16 s16u32(s16 a, u32 b) { a >>= b; return a; }
+s16 s16u64(s16 a, u64 b) { a >>= b; return a; }
+s32 s32s16(s32 a, s16 b) { a >>= b; return a; }
+s32 s32s32(s32 a, s32 b) { a >>= b; return a; }
+s32 s32s64(s32 a, s64 b) { a >>= b; return a; }
+s32 s32u16(s32 a, u16 b) { a >>= b; return a; }
+s32 s32u32(s32 a, u32 b) { a >>= b; return a; }
+s32 s32u64(s32 a, u64 b) { a >>= b; return a; }
+s64 s64s16(s64 a, s16 b);
+s64 s64s32(s64 a, s32 b);
+s64 s64s64(s64 a, s64 b) { a >>= b; return a; }
+s64 s64u16(s64 a, u16 b) { a >>= b; return a; }
+s64 s64u32(s64 a, u32 b) { a >>= b; return a; }
+s64 s64u64(s64 a, u64 b) { a >>= b; return a; }
+u16 u16s16(u16 a, s16 b) { a >>= b; return a; }
+u16 u16s32(u16 a, s32 b) { a >>= b; return a; }
+u16 u16s64(u16 a, s64 b) { a >>= b; return a; }
+u16 u16u16(u16 a, u16 b) { a >>= b; return a; }
+u16 u16u32(u16 a, u32 b) { a >>= b; return a; }
+u16 u16u64(u16 a, u64 b) { a >>= b; return a; }
+u32 u32s16(u32 a, s16 b) { a >>= b; return a; }
+u32 u32s32(u32 a, s32 b) { a >>= b; return a; }
+u32 u32s64(u32 a, s64 b) { a >>= b; return a; }
+u32 u32u16(u32 a, u16 b) { a >>= b; return a; }
+u32 u32u32(u32 a, u32 b) { a >>= b; return a; }
+u32 u32u64(u32 a, u64 b) { a >>= b; return a; }
+u64 u64s16(u64 a, s16 b);
+u64 u64s32(u64 a, s32 b);
+u64 u64s64(u64 a, s64 b) { a >>= b; return a; }
+u64 u64u16(u64 a, u16 b) { a >>= b; return a; }
+u64 u64u32(u64 a, u32 b) { a >>= b; return a; }
+u64 u64u64(u64 a, u64 b) { a >>= b; return a; }
+
+/*
+ * check-name: shift-assign1
+ * check-command: test-linearize -Wno-decl $file
+ *
+ * check-output-start
+s16s16:
+.L0:
+ <entry-point>
+ sext.32 %r2 <- (16) %arg2
+ sext.32 %r4 <- (16) %arg1
+ asr.32 %r5 <- %r4, %r2
+ trunc.16 %r6 <- (32) %r5
+ ret.16 %r6
+
+
+s16s32:
+.L2:
+ <entry-point>
+ sext.32 %r11 <- (16) %arg1
+ asr.32 %r12 <- %r11, %arg2
+ trunc.16 %r13 <- (32) %r12
+ ret.16 %r13
+
+
+s16s64:
+.L4:
+ <entry-point>
+ trunc.32 %r17 <- (64) %arg2
+ sext.32 %r19 <- (16) %arg1
+ asr.32 %r20 <- %r19, %r17
+ trunc.16 %r21 <- (32) %r20
+ ret.16 %r21
+
+
+s16u16:
+.L6:
+ <entry-point>
+ zext.32 %r25 <- (16) %arg2
+ sext.32 %r27 <- (16) %arg1
+ asr.32 %r28 <- %r27, %r25
+ trunc.16 %r29 <- (32) %r28
+ ret.16 %r29
+
+
+s16u32:
+.L8:
+ <entry-point>
+ sext.32 %r34 <- (16) %arg1
+ asr.32 %r35 <- %r34, %arg2
+ trunc.16 %r36 <- (32) %r35
+ ret.16 %r36
+
+
+s16u64:
+.L10:
+ <entry-point>
+ trunc.32 %r40 <- (64) %arg2
+ sext.32 %r42 <- (16) %arg1
+ asr.32 %r43 <- %r42, %r40
+ trunc.16 %r44 <- (32) %r43
+ ret.16 %r44
+
+
+s32s16:
+.L12:
+ <entry-point>
+ sext.32 %r48 <- (16) %arg2
+ asr.32 %r50 <- %arg1, %r48
+ ret.32 %r50
+
+
+s32s32:
+.L14:
+ <entry-point>
+ asr.32 %r55 <- %arg1, %arg2
+ ret.32 %r55
+
+
+s32s64:
+.L16:
+ <entry-point>
+ trunc.32 %r59 <- (64) %arg2
+ asr.32 %r61 <- %arg1, %r59
+ ret.32 %r61
+
+
+s32u16:
+.L18:
+ <entry-point>
+ zext.32 %r65 <- (16) %arg2
+ asr.32 %r67 <- %arg1, %r65
+ ret.32 %r67
+
+
+s32u32:
+.L20:
+ <entry-point>
+ asr.32 %r72 <- %arg1, %arg2
+ ret.32 %r72
+
+
+s32u64:
+.L22:
+ <entry-point>
+ trunc.32 %r76 <- (64) %arg2
+ asr.32 %r78 <- %arg1, %r76
+ ret.32 %r78
+
+
+s64s64:
+.L24:
+ <entry-point>
+ asr.64 %r83 <- %arg1, %arg2
+ ret.64 %r83
+
+
+s64u16:
+.L26:
+ <entry-point>
+ zext.64 %r88 <- (16) %arg2
+ asr.64 %r90 <- %arg1, %r88
+ ret.64 %r90
+
+
+s64u32:
+.L28:
+ <entry-point>
+ zext.64 %r94 <- (32) %arg2
+ asr.64 %r96 <- %arg1, %r94
+ ret.64 %r96
+
+
+s64u64:
+.L30:
+ <entry-point>
+ asr.64 %r101 <- %arg1, %arg2
+ ret.64 %r101
+
+
+u16s16:
+.L32:
+ <entry-point>
+ sext.32 %r105 <- (16) %arg2
+ zext.32 %r107 <- (16) %arg1
+ asr.32 %r108 <- %r107, %r105
+ trunc.16 %r109 <- (32) %r108
+ ret.16 %r109
+
+
+u16s32:
+.L34:
+ <entry-point>
+ zext.32 %r114 <- (16) %arg1
+ asr.32 %r115 <- %r114, %arg2
+ trunc.16 %r116 <- (32) %r115
+ ret.16 %r116
+
+
+u16s64:
+.L36:
+ <entry-point>
+ trunc.32 %r120 <- (64) %arg2
+ zext.32 %r122 <- (16) %arg1
+ asr.32 %r123 <- %r122, %r120
+ trunc.16 %r124 <- (32) %r123
+ ret.16 %r124
+
+
+u16u16:
+.L38:
+ <entry-point>
+ zext.32 %r128 <- (16) %arg2
+ zext.32 %r130 <- (16) %arg1
+ asr.32 %r131 <- %r130, %r128
+ trunc.16 %r132 <- (32) %r131
+ ret.16 %r132
+
+
+u16u32:
+.L40:
+ <entry-point>
+ zext.32 %r137 <- (16) %arg1
+ asr.32 %r138 <- %r137, %arg2
+ trunc.16 %r139 <- (32) %r138
+ ret.16 %r139
+
+
+u16u64:
+.L42:
+ <entry-point>
+ trunc.32 %r143 <- (64) %arg2
+ zext.32 %r145 <- (16) %arg1
+ asr.32 %r146 <- %r145, %r143
+ trunc.16 %r147 <- (32) %r146
+ ret.16 %r147
+
+
+u32s16:
+.L44:
+ <entry-point>
+ sext.32 %r151 <- (16) %arg2
+ lsr.32 %r153 <- %arg1, %r151
+ ret.32 %r153
+
+
+u32s32:
+.L46:
+ <entry-point>
+ lsr.32 %r158 <- %arg1, %arg2
+ ret.32 %r158
+
+
+u32s64:
+.L48:
+ <entry-point>
+ trunc.32 %r162 <- (64) %arg2
+ lsr.32 %r164 <- %arg1, %r162
+ ret.32 %r164
+
+
+u32u16:
+.L50:
+ <entry-point>
+ zext.32 %r168 <- (16) %arg2
+ lsr.32 %r170 <- %arg1, %r168
+ ret.32 %r170
+
+
+u32u32:
+.L52:
+ <entry-point>
+ lsr.32 %r175 <- %arg1, %arg2
+ ret.32 %r175
+
+
+u32u64:
+.L54:
+ <entry-point>
+ trunc.32 %r179 <- (64) %arg2
+ lsr.32 %r181 <- %arg1, %r179
+ ret.32 %r181
+
+
+u64s64:
+.L56:
+ <entry-point>
+ lsr.64 %r186 <- %arg1, %arg2
+ ret.64 %r186
+
+
+u64u16:
+.L58:
+ <entry-point>
+ zext.64 %r191 <- (16) %arg2
+ lsr.64 %r193 <- %arg1, %r191
+ ret.64 %r193
+
+
+u64u32:
+.L60:
+ <entry-point>
+ zext.64 %r197 <- (32) %arg2
+ lsr.64 %r199 <- %arg1, %r197
+ ret.64 %r199
+
+
+u64u64:
+.L62:
+ <entry-point>
+ lsr.64 %r204 <- %arg1, %arg2
+ ret.64 %r204
+
+
+ * check-output-end
+ */
diff --git a/validation/linear/shift-assign2.c b/validation/linear/shift-assign2.c
new file mode 100644
index 00000000..9990ac38
--- /dev/null
+++ b/validation/linear/shift-assign2.c
@@ -0,0 +1,53 @@
+typedef __INT16_TYPE__ s16;
+typedef __INT32_TYPE__ s32;
+typedef __INT64_TYPE__ s64;
+typedef __UINT16_TYPE__ u16;
+typedef __UINT32_TYPE__ u32;
+typedef __UINT64_TYPE__ u64;
+
+s64 s64s16(s64 a, s16 b) { a >>= b; return a; }
+s64 s64s32(s64 a, s32 b) { a >>= b; return a; }
+u64 u64s16(u64 a, s16 b) { a >>= b; return a; }
+u64 u64s32(u64 a, s32 b) { a >>= b; return a; }
+
+/*
+ * check-name: shift-assign2
+ * check-command: test-linearize -Wno-decl $file
+ *
+ * check-output-start
+s64s16:
+.L0:
+ <entry-point>
+ sext.32 %r2 <- (16) %arg2
+ zext.64 %r3 <- (32) %r2
+ asr.64 %r5 <- %arg1, %r3
+ ret.64 %r5
+
+
+s64s32:
+.L2:
+ <entry-point>
+ zext.64 %r9 <- (32) %arg2
+ asr.64 %r11 <- %arg1, %r9
+ ret.64 %r11
+
+
+u64s16:
+.L4:
+ <entry-point>
+ sext.32 %r15 <- (16) %arg2
+ zext.64 %r16 <- (32) %r15
+ lsr.64 %r18 <- %arg1, %r16
+ ret.64 %r18
+
+
+u64s32:
+.L6:
+ <entry-point>
+ zext.64 %r22 <- (32) %arg2
+ lsr.64 %r24 <- %arg1, %r22
+ ret.64 %r24
+
+
+ * check-output-end
+ */
diff --git a/validation/optim/shift-big.c b/validation/optim/shift-big.c
index 84bcd2ce..e7bf22fe 100644
--- a/validation/optim/shift-big.c
+++ b/validation/optim/shift-big.c
@@ -50,13 +50,15 @@ lsr31:
lsr32:
.L8:
<entry-point>
- ret.32 $0
+ lsr.32 %r14 <- %arg1, $32
+ ret.32 %r14
lsr33:
.L10:
<entry-point>
- ret.32 $0
+ lsr.32 %r17 <- %arg1, $33
+ ret.32 %r17
shl31:
@@ -69,13 +71,15 @@ shl31:
shl32:
.L14:
<entry-point>
- ret.32 $0
+ shl.32 %r23 <- %arg1, $32
+ ret.32 %r23
shl33:
.L16:
<entry-point>
- ret.32 $0
+ shl.32 %r26 <- %arg1, $33
+ ret.32 %r26
* check-output-end
diff --git a/validation/preprocessor/bad-cmdline-include.c b/validation/preprocessor/bad-cmdline-include.c
new file mode 100644
index 00000000..e4ee03f4
--- /dev/null
+++ b/validation/preprocessor/bad-cmdline-include.c
@@ -0,0 +1,11 @@
+#error some random error
+
+/*
+ * check-name: bad-cmdline-include
+ * check-command: sparse -include $file
+ *
+ * check-error-start
+command-line: note: in included file (through builtin):
+preprocessor/bad-cmdline-include.c:1:2: error: some random error
+ * check-error-end
+ */
diff --git a/validation/shift-negative.c b/validation/shift-negative.c
index fff5cf12..6df02b18 100644
--- a/validation/shift-negative.c
+++ b/validation/shift-negative.c
@@ -9,8 +9,8 @@ unsigned int fo2(unsigned int a) { return a >> ((a & 0) ^ ~0); }
* check-command: sparse -Wno-decl $file
*
* check-error-start
-shift-negative.c:1:45: warning: shift count is negative (-1)
-shift-negative.c:2:45: warning: shift count is negative (-1)
+shift-negative.c:1:48: warning: shift count is negative (-1)
+shift-negative.c:2:48: warning: shift count is negative (-1)
shift-negative.c:4:59: warning: shift count is negative (-1)
shift-negative.c:5:59: warning: shift count is negative (-1)
* check-error-end
diff --git a/validation/shift-undef-long.c b/validation/shift-undef-long.c
index 32626743..985fe4c4 100644
--- a/validation/shift-undef-long.c
+++ b/validation/shift-undef-long.c
@@ -13,9 +13,8 @@ static unsigned very_big_shift(unsigned int a)
* check-command: sparse -m64 $file
*
* check-error-start
-shift-undef-long.c:4:16: warning: shift too big (4294967295) for type unsigned int
-shift-undef-long.c:5:16: warning: shift too big (4294967296) for type unsigned int
-shift-undef-long.c:6:16: warning: shift too big (4294967296) for type unsigned int
-shift-undef-long.c:7:16: warning: shift count is negative (-4294967296)
+shift-undef-long.c:4:25: warning: shift count is negative (-1)
+shift-undef-long.c:5:47: warning: shift too big (4294967296) for type unsigned int
+shift-undef-long.c:7:20: warning: shift count is negative (-4294967296)
* check-error-end
*/
diff --git a/validation/shift-undef.c b/validation/shift-undef.c
index 4e94fa23..0c7541e9 100644
--- a/validation/shift-undef.c
+++ b/validation/shift-undef.c
@@ -112,51 +112,27 @@ void hw_write(u32 val)
* check-command: sparse -Wno-decl $file
*
* check-error-start
-shift-undef.c:3:15: warning: shift too big (100) for type int
-shift-undef.c:4:15: warning: shift too big (101) for type unsigned int
-shift-undef.c:5:15: warning: shift too big (102) for type unsigned int
-shift-undef.c:6:15: warning: shift count is negative (-1)
-shift-undef.c:7:15: warning: shift count is negative (-2)
-shift-undef.c:8:15: warning: shift count is negative (-3)
-shift-undef.c:9:25: warning: shift too big (103) for type int
-shift-undef.c:10:25: warning: shift too big (104) for type unsigned int
-shift-undef.c:11:25: warning: shift too big (105) for type unsigned int
-shift-undef.c:12:25: warning: shift count is negative (-4)
-shift-undef.c:13:25: warning: shift count is negative (-5)
-shift-undef.c:14:25: warning: shift count is negative (-6)
-shift-undef.c:15:30: warning: shift too big (106) for type int
-shift-undef.c:16:30: warning: shift too big (107) for type unsigned int
-shift-undef.c:17:30: warning: shift too big (108) for type unsigned int
-shift-undef.c:18:30: warning: shift count is negative (-7)
-shift-undef.c:19:30: warning: shift count is negative (-8)
-shift-undef.c:20:30: warning: shift count is negative (-9)
+shift-undef.c:3:18: warning: shift too big (100) for type int
+shift-undef.c:4:18: warning: shift too big (101) for type unsigned int
+shift-undef.c:5:18: warning: shift too big (102) for type unsigned int
+shift-undef.c:6:19: warning: shift count is negative (-1)
+shift-undef.c:7:19: warning: shift count is negative (-2)
+shift-undef.c:8:19: warning: shift count is negative (-3)
shift-undef.c:21:29: warning: shift too big (109) for type int
shift-undef.c:22:29: warning: shift too big (110) for type unsigned int
shift-undef.c:23:29: warning: shift too big (111) for type unsigned int
shift-undef.c:24:29: warning: shift count is negative (-10)
shift-undef.c:25:29: warning: shift count is negative (-11)
shift-undef.c:26:29: warning: shift count is negative (-12)
-shift-undef.c:32:11: warning: shift too big (100) for type int
-shift-undef.c:33:11: warning: shift too big (101) for type unsigned int
-shift-undef.c:34:11: warning: shift too big (102) for type unsigned int
-shift-undef.c:35:11: warning: shift count is negative (-1)
-shift-undef.c:36:11: warning: shift count is negative (-2)
-shift-undef.c:37:11: warning: shift count is negative (-3)
-shift-undef.c:38:25: warning: shift too big (103) for type int
-shift-undef.c:39:25: warning: shift too big (104) for type unsigned int
-shift-undef.c:40:25: warning: shift too big (105) for type unsigned int
-shift-undef.c:41:25: warning: shift count is negative (-4)
-shift-undef.c:42:25: warning: shift count is negative (-5)
-shift-undef.c:43:25: warning: shift count is negative (-6)
-shift-undef.c:44:30: warning: shift too big (106) for type int
-shift-undef.c:45:30: warning: shift too big (107) for type unsigned int
-shift-undef.c:46:30: warning: shift too big (108) for type unsigned int
-shift-undef.c:47:30: warning: shift count is negative (-7)
-shift-undef.c:48:30: warning: shift count is negative (-8)
-shift-undef.c:49:30: warning: shift count is negative (-9)
+shift-undef.c:32:15: warning: shift too big (100) for type int
+shift-undef.c:33:15: warning: shift too big (101) for type unsigned int
+shift-undef.c:34:15: warning: shift too big (102) for type unsigned int
+shift-undef.c:35:16: warning: shift count is negative (-1)
+shift-undef.c:36:16: warning: shift count is negative (-2)
+shift-undef.c:37:16: warning: shift count is negative (-3)
shift-undef.c:50:26: warning: shift too big (109) for type int
-shift-undef.c:51:26: warning: shift too big (110) for type int
-shift-undef.c:52:26: warning: shift too big (111) for type int
+shift-undef.c:51:26: warning: shift too big (110) for type unsigned int
+shift-undef.c:52:26: warning: shift too big (111) for type unsigned int
shift-undef.c:53:26: warning: shift count is negative (-10)
shift-undef.c:54:26: warning: shift count is negative (-11)
shift-undef.c:55:26: warning: shift count is negative (-12)
generated by cgit 1.2.3-korg (git 2.39.0) at 2024-05-30 00:08:53 +0000