The idea being, of course, to be able for some functions to return
a bool, making clear what's their possible returned values.
Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@xxxxxxxxx>
---
compile-i386.c | 18 +++++++++---------
evaluate.c | 24 ++++++++++++------------
expand.c | 18 +++++++++---------
flow.c | 15 +++++++--------
inline.c | 26 +++++++++++++-------------
lib.h | 1 +
linearize.c | 12 ++++++------
pre-process.c | 4 ++--
show-parse.c | 6 +++---
simplify.c | 14 ++++++--------
10 files changed, 68 insertions(+), 70 deletions(-)
diff --git a/compile-i386.c b/compile-i386.c
index 9c6c18603..2ee7b35ec 100644
--- a/compile-i386.c
+++ b/compile-i386.c
@@ -1554,7 +1554,7 @@ static struct storage *emit_return_stmt(struct statement *stmt)
static struct storage *emit_conditional_expr(struct expression *expr)
{
- struct storage *cond, *true = NULL, *false = NULL;
+ struct storage *cond, *stot = NULL, *stof = NULL;
struct storage *new = stack_alloc(expr->ctype->bit_size / 8);
int target_false, cond_end;
@@ -1563,16 +1563,16 @@ static struct storage *emit_conditional_expr(struct expression *expr)
target_false = emit_conditional_test(cond);
/* handle if-true part of the expression */
- true = x86_expression(expr->cond_true);
+ stot = x86_expression(expr->cond_true);
- emit_copy(new, true, expr->ctype);
+ emit_copy(new, stot, expr->ctype);
cond_end = emit_conditional_end(target_false);
/* handle if-false part of the expression */
- false = x86_expression(expr->cond_false);
+ stof = x86_expression(expr->cond_false);
- emit_copy(new, false, expr->ctype);
+ emit_copy(new, stof, expr->ctype);
/* end of conditional; jump target for if-true branch */
emit_label(cond_end, "end conditional");
@@ -1583,15 +1583,15 @@ static struct storage *emit_conditional_expr(struct expression *expr)
static struct storage *emit_select_expr(struct expression *expr)
{
struct storage *cond = x86_expression(expr->conditional);
- struct storage *true = x86_expression(expr->cond_true);
- struct storage *false = x86_expression(expr->cond_false);
+ struct storage *stot = x86_expression(expr->cond_true);
+ struct storage *stof = x86_expression(expr->cond_false);
struct storage *reg_cond, *reg_true, *reg_false;
struct storage *new = stack_alloc(4);
emit_comment("begin SELECT");
reg_cond = get_reg_value(cond, get_regclass(expr->conditional));
- reg_true = get_reg_value(true, get_regclass(expr));
- reg_false = get_reg_value(false, get_regclass(expr));
+ reg_true = get_reg_value(stot, get_regclass(expr));
+ reg_false = get_reg_value(stof, get_regclass(expr));
/*
* Do the actual select: check the conditional for zero,
diff --git a/evaluate.c b/evaluate.c
index bd10c6d9b..4e1dffe9c 100644
--- a/evaluate.c
+++ b/evaluate.c
@@ -1140,7 +1140,7 @@ OK:
*/
static struct symbol *evaluate_conditional_expression(struct expression *expr)
{
- struct expression **true;
+ struct expression **cond;
struct symbol *ctype, *ltype, *rtype, *lbase, *rbase;
int lclass, rclass;
const char * typediff;
@@ -1154,16 +1154,16 @@ static struct symbol *evaluate_conditional_expression(struct expression *expr)
ctype = degenerate(expr->conditional);
rtype = degenerate(expr->cond_false);
- true = &expr->conditional;
+ cond = &expr->conditional;
ltype = ctype;
if (expr->cond_true) {
if (!evaluate_expression(expr->cond_true))
return NULL;
ltype = degenerate(expr->cond_true);
- true = &expr->cond_true;
+ cond = &expr->cond_true;
}
- expr->flags = (expr->conditional->flags & (*true)->flags &
+ expr->flags = (expr->conditional->flags & (*cond)->flags &
expr->cond_false->flags & ~CEF_CONST_MASK);
/*
* A conditional operator yields a particular constant
@@ -1179,32 +1179,32 @@ static struct symbol *evaluate_conditional_expression(struct expression *expr)
* address constants, mark the result as an address constant.
*/
if (expr->conditional->flags & (CEF_ACE | CEF_ADDR))
- expr->flags = (*true)->flags & expr->cond_false->flags & ~CEF_CONST_MASK;
+ expr->flags = (*cond)->flags & expr->cond_false->flags & ~CEF_CONST_MASK;
lclass = classify_type(ltype, <ype);
rclass = classify_type(rtype, &rtype);
if (lclass & rclass & TYPE_NUM) {
- ctype = usual_conversions('?', *true, expr->cond_false,
+ ctype = usual_conversions('?', *cond, expr->cond_false,
lclass, rclass, ltype, rtype);
- *true = cast_to(*true, ctype);
+ *cond = cast_to(*cond, ctype);
expr->cond_false = cast_to(expr->cond_false, ctype);
goto out;
}
if ((lclass | rclass) & TYPE_PTR) {
- int is_null1 = is_null_pointer_constant(*true);
+ int is_null1 = is_null_pointer_constant(*cond);
int is_null2 = is_null_pointer_constant(expr->cond_false);
if (is_null1 && is_null2) {
- *true = cast_to(*true, &ptr_ctype);
+ *cond = cast_to(*cond, &ptr_ctype);
expr->cond_false = cast_to(expr->cond_false, &ptr_ctype);
ctype = &ptr_ctype;
goto out;
}
if (is_null1 && (rclass & TYPE_PTR)) {
if (is_null1 == 2)
- bad_null(*true);
- *true = cast_to(*true, rtype);
+ bad_null(*cond);
+ *cond = cast_to(*cond, rtype);
ctype = rtype;
goto out;
}
@@ -1284,7 +1284,7 @@ Qual:
sym->ctype.modifiers |= qual;
ctype = sym;
}
- *true = cast_to(*true, ctype);
+ *cond = cast_to(*cond, ctype);
expr->cond_false = cast_to(expr->cond_false, ctype);
goto out;
}
diff --git a/expand.c b/expand.c
index d44aec242..4c68c98ca 100644
--- a/expand.c
+++ b/expand.c
@@ -529,27 +529,27 @@ static int expand_compare(struct expression *expr)
static int expand_conditional(struct expression *expr)
{
struct expression *cond = expr->conditional;
- struct expression *true = expr->cond_true;
- struct expression *false = expr->cond_false;
+ struct expression *valt = expr->cond_true;
+ struct expression *valf = expr->cond_false;
int cost, cond_cost;
cond_cost = expand_expression(cond);
if (cond->type == EXPR_VALUE) {
unsigned flags = expr->flags;
if (!cond->value)
- true = false;
- if (!true)
- true = cond;
- cost = expand_expression(true);
- *expr = *true;
+ valt = valf;
+ if (!valt)
+ valt = cond;
+ cost = expand_expression(valt);
+ *expr = *valt;
expr->flags = flags;
if (expr->type == EXPR_VALUE)
expr->taint |= cond->taint;
return cost;
}
- cost = expand_expression(true);
- cost += expand_expression(false);
+ cost = expand_expression(valt);
+ cost += expand_expression(valf);
if (cost < SELECT_COST) {
expr->type = EXPR_SELECT;
diff --git a/flow.c b/flow.c
index 495b118d2..5f7054cdf 100644
--- a/flow.c
+++ b/flow.c
@@ -131,7 +131,7 @@ static int try_to_simplify_bb(struct basic_block *bb, struct instruction *first,
struct basic_block *source, *target;
pseudo_t pseudo;
struct instruction *br;
- int true;
+ int cond;
if (!def)
continue;
@@ -144,10 +144,10 @@ static int try_to_simplify_bb(struct basic_block *bb, struct instruction *first,
continue;
if (br->opcode != OP_CBR && br->opcode != OP_BR)
continue;
- true = pseudo_truth_value(pseudo);
- if (true < 0)
+ cond = pseudo_truth_value(pseudo);
+ if (cond < 0)
continue;
- target = true ? second->bb_true : second->bb_false;
+ target = cond ? second->bb_true : second->bb_false;
if (bb_depends_on(target, bb))
continue;
if (bb_depends_on_phi(target, bb))
@@ -209,7 +209,7 @@ static int simplify_phi_branch(struct basic_block *bb, struct instruction *br)
}
static int simplify_branch_branch(struct basic_block *bb, struct instruction *br,
- struct basic_block **target_p, int true)
+ struct basic_block **target_p, int bb_true)
{
struct basic_block *target = *target_p, *final;
struct instruction *insn;
@@ -225,7 +225,7 @@ static int simplify_branch_branch(struct basic_block *bb, struct instruction *br
* Now we just need to see if we can rewrite the branch..
*/
retval = 0;
- final = true ? insn->bb_true : insn->bb_false;
+ final = bb_true ? insn->bb_true : insn->bb_false;
if (bb_has_side_effects(target))
goto try_to_rewrite_target;
if (bb_depends_on(final, target))
@@ -852,13 +852,12 @@ static struct basic_block * rewrite_branch_bb(struct basic_block *bb, struct ins
{
struct basic_block *parent;
struct basic_block *target = br->bb_true;
- struct basic_block *false = br->bb_false;
if (br->opcode == OP_CBR) {
pseudo_t cond = br->cond;
if (cond->type != PSEUDO_VAL)
return NULL;
- target = cond->value ? target : false;
+ target = cond->value ? target : br->bb_false;
}
/*
diff --git a/inline.c b/inline.c
index b999dbac3..28c3afb1a 100644
--- a/inline.c
+++ b/inline.c
@@ -180,14 +180,14 @@ static struct expression * copy_expression(struct expression *expr)
case EXPR_SELECT:
case EXPR_CONDITIONAL: {
struct expression *cond = copy_expression(expr->conditional);
- struct expression *true = copy_expression(expr->cond_true);
- struct expression *false = copy_expression(expr->cond_false);
- if (cond == expr->conditional && true == expr->cond_true && false == expr->cond_false)
+ struct expression *valt = copy_expression(expr->cond_true);
+ struct expression *valf = copy_expression(expr->cond_false);
+ if (cond == expr->conditional && valt == expr->cond_true && valf == expr->cond_false)
break;
expr = dup_expression(expr);
expr->conditional = cond;
- expr->cond_true = true;
- expr->cond_false = false;
+ expr->cond_true = valt;
+ expr->cond_false = valf;
break;
}
@@ -366,20 +366,20 @@ static struct statement *copy_one_statement(struct statement *stmt)
}
case STMT_IF: {
struct expression *cond = stmt->if_conditional;
- struct statement *true = stmt->if_true;
- struct statement *false = stmt->if_false;
+ struct statement *valt = stmt->if_true;
+ struct statement *valf = stmt->if_false;
cond = copy_expression(cond);
- true = copy_one_statement(true);
- false = copy_one_statement(false);
+ valt = copy_one_statement(valt);
+ valf = copy_one_statement(valf);
if (stmt->if_conditional == cond &&
- stmt->if_true == true &&
- stmt->if_false == false)
+ stmt->if_true == valt &&
+ stmt->if_false == valf)
break;
stmt = dup_statement(stmt);
stmt->if_conditional = cond;
- stmt->if_true = true;
- stmt->if_false = false;
+ stmt->if_true = valt;
+ stmt->if_false = valf;
break;
}
case STMT_RETURN: {
diff --git a/lib.h b/lib.h
index 271b7ae12..25559aaec 100644
--- a/lib.h
+++ b/lib.h
@@ -1,6 +1,7 @@
#ifndef LIB_H
#define LIB_H
+#include <stdbool.h>
#include <stdlib.h>
#include <stddef.h>
diff --git a/linearize.c b/linearize.c
index eb4e68c21..211dabf48 100644
--- a/linearize.c
+++ b/linearize.c
@@ -1367,19 +1367,19 @@ static pseudo_t linearize_cond_branch(struct entrypoint *ep, struct expression *
static pseudo_t linearize_select(struct entrypoint *ep, struct expression *expr)
{
- pseudo_t cond, true, false, res;
+ pseudo_t cond, valt, valf, res;
struct instruction *insn;
- true = linearize_expression(ep, expr->cond_true);
- false = linearize_expression(ep, expr->cond_false);
+ valt = linearize_expression(ep, expr->cond_true);
+ valf = linearize_expression(ep, expr->cond_false);
cond = linearize_expression(ep, expr->conditional);
insn = alloc_typed_instruction(OP_SEL, expr->ctype);
if (!expr->cond_true)
- true = cond;
+ valt = cond;
use_pseudo(insn, cond, &insn->src1);
- use_pseudo(insn, true, &insn->src2);
- use_pseudo(insn, false, &insn->src3);
+ use_pseudo(insn, valt, &insn->src2);
+ use_pseudo(insn, valf, &insn->src3);
res = alloc_pseudo(insn);
insn->target = res;
diff --git a/pre-process.c b/pre-process.c
index 8800dce53..c6c6cdada 100644
--- a/pre-process.c
+++ b/pre-process.c
@@ -1427,13 +1427,13 @@ static int handle_strong_undef(struct stream *stream, struct token **line, struc
return do_handle_undef(stream, line, token, SYM_ATTR_STRONG);
}
-static int preprocessor_if(struct stream *stream, struct token *token, int true)
+static int preprocessor_if(struct stream *stream, struct token *token, int cond)
{
token_type(token) = false_nesting ? TOKEN_SKIP_GROUPS : TOKEN_IF;
free_preprocessor_line(token->next);
token->next = stream->top_if;
stream->top_if = token;
- if (false_nesting || true != 1)
+ if (false_nesting || cond != 1)
false_nesting++;
return 0;
}
diff --git a/show-parse.c b/show-parse.c
index 9b5225da7..72d3f3854 100644
--- a/show-parse.c
+++ b/show-parse.c
@@ -1009,11 +1009,11 @@ static int show_label_expr(struct expression *expr)
static int show_conditional_expr(struct expression *expr)
{
int cond = show_expression(expr->conditional);
- int true = show_expression(expr->cond_true);
- int false = show_expression(expr->cond_false);
+ int valt = show_expression(expr->cond_true);
+ int valf = show_expression(expr->cond_false);
int new = new_pseudo();
- printf("[v%d]\tcmov.%d\t\tv%d,v%d,v%d\n", cond, expr->ctype->bit_size, new, true, false);
+ printf("[v%d]\tcmov.%d\t\tv%d,v%d,v%d\n", cond, expr->ctype->bit_size, new, valt, valf);
return new;
}
diff --git a/simplify.c b/simplify.c
index 72f4da8a1..6cb667c45 100644
--- a/simplify.c
+++ b/simplify.c
@@ -1057,10 +1057,9 @@ static int simplify_cond_branch(struct instruction *br, pseudo_t cond, struct in
use_pseudo(br, *pp, &br->cond);
remove_usage(cond, &br->cond);
if (def->opcode == OP_SET_EQ) {
- struct basic_block *true = br->bb_true;
- struct basic_block *false = br->bb_false;
- br->bb_false = true;
- br->bb_true = false;
+ struct basic_block *tmp = br->bb_true;
+ br->bb_true = br->bb_false;
+ br->bb_false = tmp;
}
return REPEAT_CSE;
}
@@ -1111,10 +1110,9 @@ static int simplify_branch(struct instruction *insn)
return REPEAT_CSE;
}
if (val2) {
- struct basic_block *true = insn->bb_true;
- struct basic_block *false = insn->bb_false;
- insn->bb_false = true;
- insn->bb_true = false;
+ struct basic_block *tmp = insn->bb_true;
+ insn->bb_true = insn->bb_false;
+ insn->bb_false = tmp;
}
use_pseudo(insn, def->src1, &insn->cond);
remove_usage(cond, &insn->cond);
--
2.16.0
--
To unsubscribe from this list: send the line "unsubscribe linux-sparse" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
