+2017-12-19 Jakub Jelinek <jakub@redhat.com>
+
+ * read-rtl.c (parse_reg_note_name): Replace Yoda conditions with
+ typical order conditions.
+ * sel-sched.c (extract_new_fences_from): Likewise.
+ * config/visium/constraints.md (J, K, L): Likewise.
+ * config/visium/predicates.md (const_shift_operand): Likewise.
+ * config/visium/visium.c (visium_legitimize_address,
+ visium_legitimize_reload_address): Likewise.
+ * config/m68k/m68k.c (output_reg_adjust, emit_reg_adjust): Likewise.
+ * config/arm/arm.c (arm_block_move_unaligned_straight): Likewise.
+ * config/avr/constraints.md (Y01, Ym1, Y02, Ym2): Likewise.
+ * config/avr/avr-log.c (avr_vdump, avr_log_set_avr_log,
+ SET_DUMP_DETAIL): Likewise.
+ * config/avr/predicates.md (const_8_16_24_operand): Likewise.
+ * config/avr/avr.c (STR_PREFIX_P, avr_popcount_each_byte,
+ avr_is_casesi_sequence, avr_casei_sequence_check_operands,
+ avr_set_core_architecture, avr_set_current_function,
+ avr_legitimize_reload_address, avr_asm_len, avr_print_operand,
+ output_movqi, output_movsisf, avr_out_plus, avr_out_bitop,
+ avr_out_fract, avr_adjust_insn_length, avr_encode_section_info,
+ avr_2word_insn_p, output_reload_in_const, avr_has_nibble_0xf,
+ avr_map_decompose, avr_fold_builtin): Likewise.
+ * config/avr/driver-avr.c (avr_devicespecs_file): Likewise.
+ * config/avr/gen-avr-mmcu-specs.c (str_prefix_p, print_mcu): Likewise.
+ * config/i386/i386.c (ix86_parse_stringop_strategy_string): Likewise.
+ * config/m32c/m32c-pragma.c (m32c_pragma_memregs): Likewise.
+ * config/m32c/m32c.c (m32c_conditional_register_usage,
+ m32c_address_cost): Likewise.
+ * config/m32c/predicates.md (shiftcount_operand,
+ longshiftcount_operand): Likewise.
+ * config/iq2000/iq2000.c (iq2000_expand_prologue): Likewise.
+ * config/nios2/nios2.c (nios2_handle_custom_fpu_insn_option,
+ can_use_cdx_ldstw): Likewise.
+ * config/nios2/nios2.h (CDX_REG_P): Likewise.
+ * config/cr16/cr16.h (RETURN_ADDR_RTX, REGNO_MODE_OK_FOR_BASE_P):
+ Likewise.
+ * config/cr16/cr16.md (*mov<mode>_double): Likewise.
+ * config/cr16/cr16.c (cr16_create_dwarf_for_multi_push): Likewise.
+ * config/h8300/h8300.c (h8300_rtx_costs, get_shift_alg): Likewise.
+ * config/vax/constraints.md (U06, U08, U16, CN6, S08, S16): Likewise.
+ * config/vax/vax.c (adjacent_operands_p): Likewise.
+ * config/ft32/constraints.md (L, b, KA): Likewise.
+ * config/ft32/ft32.c (ft32_load_immediate, ft32_expand_prologue):
+ Likewise.
+ * cfgexpand.c (expand_stack_alignment): Likewise.
+ * gcse.c (insert_expr_in_table): Likewise.
+ * print-rtl.c (rtx_writer::print_rtx_operand_codes_E_and_V): Likewise.
+ * cgraphunit.c (cgraph_node::expand): Likewise.
+ * ira-build.c (setup_min_max_allocno_live_range_point): Likewise.
+ * emit-rtl.c (add_insn): Likewise.
+ * input.c (dump_location_info): Likewise.
+ * passes.c (NEXT_PASS): Likewise.
+ * read-rtl-function.c (parse_note_insn_name,
+ function_reader::read_rtx_operand_r, function_reader::parse_mem_expr):
+ Likewise.
+ * sched-rgn.c (sched_rgn_init): Likewise.
+ * diagnostic-show-locus.c (layout::show_ruler): Likewise.
+ * combine.c (find_split_point, simplify_if_then_else, force_to_mode,
+ if_then_else_cond, simplify_shift_const_1, simplify_comparison): Likewise.
+ * explow.c (eliminate_constant_term): Likewise.
+ * final.c (leaf_renumber_regs_insn): Likewise.
+ * cfgrtl.c (print_rtl_with_bb): Likewise.
+ * genhooks.c (emit_init_macros): Likewise.
+ * poly-int.h (maybe_ne, maybe_le, maybe_lt): Likewise.
+ * tree-data-ref.c (conflict_fn): Likewise.
+ * selftest.c (assert_streq): Likewise.
+ * expr.c (store_constructor_field, expand_expr_real_1): Likewise.
+ * fold-const.c (fold_range_test, extract_muldiv_1, fold_truth_andor,
+ fold_binary_loc, multiple_of_p): Likewise.
+ * reload.c (push_reload, find_equiv_reg): Likewise.
+ * et-forest.c (et_nca, et_below): Likewise.
+ * dbxout.c (dbxout_symbol_location): Likewise.
+ * reorg.c (relax_delay_slots): Likewise.
+ * dojump.c (do_compare_rtx_and_jump): Likewise.
+ * gengtype-parse.c (type): Likewise.
+ * simplify-rtx.c (simplify_gen_ternary, simplify_gen_relational,
+ simplify_const_relational_operation): Likewise.
+ * reload1.c (do_output_reload): Likewise.
+ * dumpfile.c (get_dump_file_info_by_switch): Likewise.
+ * gengtype.c (type_for_name): Likewise.
+ * gimple-ssa-sprintf.c (format_directive): Likewise.
+
2017-12-19 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
PR target/82975
+2017-12-19 Jakub Jelinek <jakub@redhat.com>
+
+ * gcc-interface/trans.c (Loop_Statement_to_gnu): Replace Yoda
+ conditions with typical order conditions.
+ * gcc-interface/misc.c (gnat_get_array_descr_info,
+ default_pass_by_ref): Likewise.
+ * gcc-interface/decl.c (gnat_to_gnu_entity): Likewise.
+ * adaint.c (__gnat_tmp_name): Likewise.
+
2017-12-19 Arnaud Charlet <charlet@adacore.com>
PR ada/66205
/* Fill up the name buffer from the last position. */
seed++;
- for (t = seed; 0 <= --index; t >>= 3)
+ for (t = seed; --index >= 0; t >>= 3)
*--pos = '0' + (t & 07);
/* Check to see if its unique, if not bump the seed and try again. */
index to the template. */
for (index = (convention_fortran_p ? ndim - 1 : 0),
gnat_index = First_Index (gnat_entity);
- 0 <= index && index < ndim;
+ index >= 0 && index < ndim;
index += (convention_fortran_p ? - 1 : 1),
gnat_index = Next_Index (gnat_index))
{
gnat_index = First_Index (gnat_entity),
gnat_base_index
= First_Index (Implementation_Base_Type (gnat_entity));
- 0 <= index && index < ndim;
+ index >= 0 && index < ndim;
index += (convention_fortran_p ? - 1 : 1),
gnat_index = Next_Index (gnat_index),
gnat_base_index = Next_Index (gnat_base_index))
structure. */
for (i = (convention_fortran_p ? info->ndimensions - 1 : 0),
dimen = first_dimen;
- 0 <= i && i < info->ndimensions;
+ i >= 0 && i < info->ndimensions;
i += (convention_fortran_p ? -1 : 1),
dimen = TREE_TYPE (dimen))
{
if (AGGREGATE_TYPE_P (gnu_type)
&& (!valid_constant_size_p (TYPE_SIZE_UNIT (gnu_type))
- || 0 < compare_tree_int (TYPE_SIZE_UNIT (gnu_type),
- TYPE_ALIGN (gnu_type))))
+ || compare_tree_int (TYPE_SIZE_UNIT (gnu_type),
+ TYPE_ALIGN (gnu_type)) > 0))
return true;
if (pass_by_reference (NULL, TYPE_MODE (gnu_type), gnu_type, true))
/* Note that loop unswitching can only be applied a small number of
times to a given loop (PARAM_MAX_UNSWITCH_LEVEL default to 3). */
- if (0 < n_remaining_checks && n_remaining_checks <= 3
+ if (n_remaining_checks > 0 && n_remaining_checks <= 3
&& optimize > 1 && !optimize_size)
FOR_EACH_VEC_ELT (*gnu_loop_info->checks, i, rci)
if (rci->invariant_cond != boolean_false_node)
+2017-12-19 Jakub Jelinek <jakub@redhat.com>
+
+ * known-headers.cc (get_stdlib_header_for_name): Replace Yoda
+ conditions with typical order conditions.
+
2017-12-18 Marek Polacek <polacek@redhat.com>
* c-warn.c (warn_logical_operator): Return early if -Wlogical-op is
};
const size_t num_hints = sizeof (hints) / sizeof (hints[0]);
for (size_t i = 0; i < num_hints; i++)
- if (0 == strcmp (name, hints[i].name))
+ if (strcmp (name, hints[i].name) == 0)
return hints[i].header[lib];
return NULL;
}
+2017-12-19 Jakub Jelinek <jakub@redhat.com>
+
+ * c-typeck.c (comptypes_internal, function_types_compatible_p,
+ perform_integral_promotions, digest_init): Replace Yoda conditions
+ with typical order conditions.
+ * c-decl.c (check_bitfield_type_and_width): Likewise.
+
2017-12-14 Bernd Edlinger <bernd.edlinger@hotmail.de>
* c-typeck.c (c_safe_arg_type_equiv_p,
max_width = TYPE_PRECISION (*type);
- if (0 < compare_tree_int (*width, max_width))
+ if (compare_tree_int (*width, max_width) > 0)
{
error_at (loc, "width of %qs exceeds its type", name);
w = max_width;
/* Target types must match incl. qualifiers. */
if (TREE_TYPE (t1) != TREE_TYPE (t2)
- && 0 == (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
- enum_and_int_p,
- different_types_p)))
+ && (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
+ enum_and_int_p,
+ different_types_p)) == 0)
return 0;
if (different_types_p != NULL
compare that with the other type's arglist.
If they don't match, ask for a warning (but no error). */
if (TYPE_ACTUAL_ARG_TYPES (f1)
- && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1),
- enum_and_int_p, different_types_p))
+ && type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1),
+ enum_and_int_p, different_types_p) != 1)
val = 2;
return val;
}
if (!self_promoting_args_p (args1))
return 0;
if (TYPE_ACTUAL_ARG_TYPES (f2)
- && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2),
- enum_and_int_p, different_types_p))
+ && type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2),
+ enum_and_int_p, different_types_p) != 1)
val = 2;
return val;
}
&& DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
/* If it's thinner than an int, promote it like a
c_promoting_integer_type_p, otherwise leave it alone. */
- && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
- TYPE_PRECISION (integer_type_node)))
+ && compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
+ TYPE_PRECISION (integer_type_node)) < 0)
return convert (integer_type_node, exp);
if (c_promoting_integer_type_p (type))
/* Subtract the size of a single (possibly wide) character
because it's ok to ignore the terminating null char
that is counted in the length of the constant. */
- if (0 > compare_tree_int (TYPE_SIZE_UNIT (type),
- (len
- - (TYPE_PRECISION (typ1)
- / BITS_PER_UNIT))))
+ if (compare_tree_int (TYPE_SIZE_UNIT (type),
+ (len - (TYPE_PRECISION (typ1)
+ / BITS_PER_UNIT))) < 0)
pedwarn_init (init_loc, 0,
("initializer-string for array of chars "
"is too long"));
else if (warn_cxx_compat
- && 0 > compare_tree_int (TYPE_SIZE_UNIT (type), len))
+ && compare_tree_int (TYPE_SIZE_UNIT (type), len) < 0)
warning_at (init_loc, OPT_Wc___compat,
("initializer-string for array chars "
"is too long for C++"));
gcc_assert ((stack_realign_drap != 0) == (drap_rtx != NULL));
/* Do nothing if NULL is returned, which means DRAP is not needed. */
- if (NULL != drap_rtx)
+ if (drap_rtx != NULL)
{
crtl->args.internal_arg_pointer = drap_rtx;
}
}
- for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx))
+ for (tmp_rtx = rtx_first; tmp_rtx != NULL; tmp_rtx = NEXT_INSN (tmp_rtx))
{
if (flags & TDF_BLOCKS)
{
if (ret_type && TYPE_SIZE_UNIT (ret_type)
&& TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
- && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
- larger_than_size))
+ && compare_tree_int (TYPE_SIZE_UNIT (ret_type),
+ larger_than_size) > 0)
{
unsigned int size_as_int
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
is known to be on, this can be converted into a NEG of a shift. */
if (STORE_FLAG_VALUE == -1 && XEXP (SET_SRC (x), 1) == const0_rtx
&& GET_MODE (SET_SRC (x)) == GET_MODE (XEXP (SET_SRC (x), 0))
- && 1 <= (pos = exact_log2
- (nonzero_bits (XEXP (SET_SRC (x), 0),
- GET_MODE (XEXP (SET_SRC (x), 0))))))
+ && ((pos = exact_log2 (nonzero_bits (XEXP (SET_SRC (x), 0),
+ GET_MODE (XEXP (SET_SRC (x),
+ 0))))) >= 1))
{
machine_mode mode = GET_MODE (XEXP (SET_SRC (x), 0));
&& XEXP (cond, 1) == const0_rtx
&& false_rtx == const0_rtx
&& CONST_INT_P (true_rtx)
- && ((1 == nonzero_bits (XEXP (cond, 0), int_mode)
+ && ((nonzero_bits (XEXP (cond, 0), int_mode) == 1
&& (i = exact_log2 (UINTVAL (true_rtx))) >= 0)
|| ((num_sign_bit_copies (XEXP (cond, 0), int_mode)
== GET_MODE_PRECISION (int_mode))
if (GET_CODE (x) == SUBREG
&& subreg_lowpart_p (x)
&& (partial_subreg_p (x)
- || (0 == (mask
- & GET_MODE_MASK (GET_MODE (x))
- & ~GET_MODE_MASK (GET_MODE (SUBREG_REG (x)))))))
+ || (mask
+ & GET_MODE_MASK (GET_MODE (x))
+ & ~GET_MODE_MASK (GET_MODE (SUBREG_REG (x)))) == 0))
return force_to_mode (SUBREG_REG (x), mode, mask, next_select);
scalar_int_mode int_mode, xmode;
/* If X is a SUBREG, we can narrow both the true and false values
if the inner expression, if there is a condition. */
else if (code == SUBREG
- && 0 != (cond0 = if_then_else_cond (SUBREG_REG (x),
- &true0, &false0)))
+ && (cond0 = if_then_else_cond (SUBREG_REG (x), &true0,
+ &false0)) != 0)
{
true0 = simplify_gen_subreg (mode, true0,
GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
shift_unit_mode wider than result_mode. */
&& !(code == ASHIFTRT && GET_CODE (varop) == XOR
&& int_result_mode != shift_unit_mode
- && 0 > trunc_int_for_mode (INTVAL (XEXP (varop, 1)),
- shift_unit_mode))
+ && trunc_int_for_mode (INTVAL (XEXP (varop, 1)),
+ shift_unit_mode) < 0)
&& (new_rtx = simplify_const_binary_operation
(code, int_result_mode,
gen_int_mode (INTVAL (XEXP (varop, 1)), int_result_mode),
(ashiftrt (xor)) where we've widened the shift and the constant
changes the sign bit. */
if (CONST_INT_P (XEXP (varop, 1))
- && !(code == ASHIFTRT && GET_CODE (varop) == XOR
- && int_result_mode != shift_unit_mode
- && 0 > trunc_int_for_mode (INTVAL (XEXP (varop, 1)),
- shift_unit_mode)))
+ && !(code == ASHIFTRT && GET_CODE (varop) == XOR
+ && int_result_mode != shift_unit_mode
+ && trunc_int_for_mode (INTVAL (XEXP (varop, 1)),
+ shift_unit_mode) < 0))
{
rtx lhs = simplify_shift_const (NULL_RTX, code, shift_unit_mode,
XEXP (varop, 0), count);
else if ((code == ASHIFTRT || code == LSHIFTRT)
&& count < HOST_BITS_PER_WIDE_INT
&& HWI_COMPUTABLE_MODE_P (int_result_mode)
- && 0 == (nonzero_bits (XEXP (varop, 0), int_result_mode)
- >> count)
- && 0 == (nonzero_bits (XEXP (varop, 0), int_result_mode)
- & nonzero_bits (XEXP (varop, 1), int_result_mode)))
+ && (nonzero_bits (XEXP (varop, 0), int_result_mode)
+ >> count) == 0
+ && (nonzero_bits (XEXP (varop, 0), int_result_mode)
+ & nonzero_bits (XEXP (varop, 1), int_result_mode)) == 0)
{
varop = XEXP (varop, 1);
continue;
&& HWI_COMPUTABLE_MODE_P (GET_MODE (SUBREG_REG (inner_op0)))
&& (GET_MODE (SUBREG_REG (inner_op0))
== GET_MODE (SUBREG_REG (inner_op1)))
- && (0 == ((~c0) & nonzero_bits (SUBREG_REG (inner_op0),
- GET_MODE (SUBREG_REG (inner_op0)))))
- && (0 == ((~c1) & nonzero_bits (SUBREG_REG (inner_op1),
- GET_MODE (SUBREG_REG (inner_op1))))))
+ && ((~c0) & nonzero_bits (SUBREG_REG (inner_op0),
+ GET_MODE (SUBREG_REG (inner_op0)))) == 0
+ && ((~c1) & nonzero_bits (SUBREG_REG (inner_op1),
+ GET_MODE (SUBREG_REG (inner_op1)))) == 0)
{
op0 = SUBREG_REG (inner_op0);
op1 = SUBREG_REG (inner_op1);
&& (equality_comparison_p || unsigned_comparison_p)
/* (A - C1) zero-extends if it is positive and sign-extends
if it is negative, C2 both zero- and sign-extends. */
- && ((0 == (nonzero_bits (a, inner_mode)
- & ~GET_MODE_MASK (mode))
+ && (((nonzero_bits (a, inner_mode)
+ & ~GET_MODE_MASK (mode)) == 0
&& const_op >= 0)
/* (A - C1) sign-extends if it is positive and 1-extends
if it is negative, C2 both sign- and 1-extends. */
this for equality comparisons due to pathological cases involving
overflows. */
if (equality_comparison_p
- && 0 != (tem = simplify_binary_operation (MINUS, mode,
- op1, XEXP (op0, 1))))
+ && (tem = simplify_binary_operation (MINUS, mode,
+ op1, XEXP (op0, 1))) != 0)
{
op0 = XEXP (op0, 0);
op1 = tem;
this for equality comparisons due to pathological cases involving
overflows. */
if (equality_comparison_p
- && 0 != (tem = simplify_binary_operation (PLUS, mode,
- XEXP (op0, 1), op1)))
+ && (tem = simplify_binary_operation (PLUS, mode,
+ XEXP (op0, 1), op1)) != 0)
{
op0 = XEXP (op0, 0);
op1 = tem;
}
if (equality_comparison_p
- && 0 != (tem = simplify_binary_operation (MINUS, mode,
- XEXP (op0, 0), op1)))
+ && (tem = simplify_binary_operation (MINUS, mode,
+ XEXP (op0, 0), op1)) != 0)
{
op0 = XEXP (op0, 1);
op1 = tem;
/* (eq (xor A B) C) -> (eq A (xor B C)). This is a simplification
if C is zero or B is a constant. */
if (equality_comparison_p
- && 0 != (tem = simplify_binary_operation (XOR, mode,
- XEXP (op0, 1), op1)))
+ && (tem = simplify_binary_operation (XOR, mode,
+ XEXP (op0, 1), op1)) != 0)
{
op0 = XEXP (op0, 0);
op1 = tem;
HOST_WIDE_INT src_autoinc, dst_autoinc;
rtx mem, addr;
- gcc_assert (1 <= interleave_factor && interleave_factor <= 4);
+ gcc_assert (interleave_factor >= 1 && interleave_factor <= 4);
/* Use hard registers if we have aligned source or destination so we can use
load/store multiple with contiguous registers. */
{
va_list ap;
- if (NULL == stream && dump_file)
+ if (stream == NULL && dump_file)
stream = dump_file;
va_start (ap, caller);
str[0] = ',';
strcat (stpcpy (str+1, avr_log_details), ",");
- all |= NULL != strstr (str, ",all,");
- info = NULL != strstr (str, ",?,");
+ all |= strstr (str, ",all,") != NULL;
+ info = strstr (str, ",?,") != NULL;
if (info)
fprintf (stderr, "\n-mlog=");
#define SET_DUMP_DETAIL(S) \
do { \
- avr_log.S = (all || NULL != strstr (str, "," #S ",")); \
+ avr_log.S = (all || strstr (str, "," #S ",") != NULL); \
if (info) \
fprintf (stderr, #S ","); \
} while (0)
#define MAX_LD_OFFSET(MODE) (64 - (signed)GET_MODE_SIZE (MODE))
/* Return true if STR starts with PREFIX and false, otherwise. */
-#define STR_PREFIX_P(STR,PREFIX) (0 == strncmp (STR, PREFIX, strlen (PREFIX)))
+#define STR_PREFIX_P(STR,PREFIX) (strncmp (STR, PREFIX, strlen (PREFIX)) == 0)
/* The 4 bits starting at SECTION_MACH_DEP are reserved to store the
address space where data is to be located.
rtx xval8 = simplify_gen_subreg (QImode, xval, mode, i);
unsigned int val8 = UINTVAL (xval8) & GET_MODE_MASK (QImode);
- if (0 == (pop_mask & (1 << popcount_hwi (val8))))
+ if ((pop_mask & (1 << popcount_hwi (val8))) == 0)
return false;
}
// Assert on the anatomy of xinsn's operands we are going to work with.
- gcc_assert (11 == recog_data.n_operands);
- gcc_assert (4 == recog_data.n_dups);
+ gcc_assert (recog_data.n_operands == 11);
+ gcc_assert (recog_data.n_dups == 4);
if (dump_file)
{
if (sub_5
&& SUBREG_P (sub_5)
- && 0 == SUBREG_BYTE (sub_5)
+ && SUBREG_BYTE (sub_5) == 0
&& rtx_equal_p (xop[5], SUBREG_REG (sub_5)))
return true;
for (const avr_mcu_t *mcu = avr_mcu_types; ; mcu++)
{
- if (NULL == mcu->name)
+ if (mcu->name == NULL)
{
/* Reached the end of `avr_mcu_types'. This should actually never
happen as options are provided by device-specs. It could be a
avr_inform_core_architectures ();
break;
}
- else if (0 == strcmp (mcu->name, avr_mmcu)
+ else if (strcmp (mcu->name, avr_mmcu) == 0
// Is this a proper architecture ?
- && NULL == mcu->macro)
+ && mcu->macro == NULL)
{
avr_arch = &avr_arch_types[mcu->arch_id];
if (avr_n_flash < 0)
// Common problem is using "ISR" without first including avr/interrupt.h.
const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
name = default_strip_name_encoding (name);
- if (0 == strcmp ("ISR", name)
- || 0 == strcmp ("INTERRUPT", name)
- || 0 == strcmp ("SIGNAL", name))
+ if (strcmp ("ISR", name) == 0
+ || strcmp ("INTERRUPT", name) == 0
+ || strcmp ("SIGNAL", name) == 0)
{
warning_at (loc, OPT_Wmisspelled_isr, "%qs is a reserved identifier"
" in AVR-LibC. Consider %<#include <avr/interrupt.h>%>"
if (GET_CODE (x) == PLUS
&& REG_P (XEXP (x, 0))
- && 0 == reg_equiv_constant (REGNO (XEXP (x, 0)))
+ && reg_equiv_constant (REGNO (XEXP (x, 0))) == 0
&& CONST_INT_P (XEXP (x, 1))
&& INTVAL (XEXP (x, 1)) >= 1)
{
static const char*
avr_asm_len (const char* tpl, rtx* operands, int* plen, int n_words)
{
- if (NULL == plen)
- {
- output_asm_insn (tpl, operands);
- }
+ if (plen == NULL)
+ output_asm_insn (tpl, operands);
else
{
if (n_words < 0)
else if (code == 'x')
{
/* Constant progmem address - like used in jmp or call */
- if (0 == text_segment_operand (x, VOIDmode))
+ if (text_segment_operand (x, VOIDmode) == 0)
if (warning (0, "accessing program memory"
" with data memory address"))
{
return avr_out_lpm (insn, operands, plen);
}
- gcc_assert (1 == GET_MODE_SIZE (GET_MODE (dest)));
+ gcc_assert (GET_MODE_SIZE (GET_MODE (dest)) == 1);
if (REG_P (dest))
{
if (!l)
l = &dummy;
- gcc_assert (4 == GET_MODE_SIZE (GET_MODE (dest)));
+ gcc_assert (GET_MODE_SIZE (GET_MODE (dest)) == 4);
if (REG_P (dest))
{
return "";
}
- if (8 == n_bytes)
+ if (n_bytes == 8)
{
op[0] = gen_rtx_REG (DImode, ACC_A);
op[1] = gen_rtx_REG (DImode, ACC_A);
{
case IOR:
- if (0 == pop8)
+ if (pop8 == 0)
continue;
else if (ld_reg_p)
avr_asm_len ("ori %0,%1", op, plen, 1);
- else if (1 == pop8)
+ else if (pop8 == 1)
{
if (set_t != 1)
avr_asm_len ("set", op, plen, 1);
op[1] = GEN_INT (exact_log2 (val8));
avr_asm_len ("bld %0,%1", op, plen, 1);
}
- else if (8 == pop8)
+ else if (pop8 == 8)
{
if (op[3] != NULL_RTX)
avr_asm_len ("mov %0,%3", op, plen, 1);
case AND:
- if (8 == pop8)
+ if (pop8 == 8)
continue;
- else if (0 == pop8)
+ else if (pop8 == 0)
avr_asm_len ("clr %0", op, plen, 1);
else if (ld_reg_p)
avr_asm_len ("andi %0,%1", op, plen, 1);
- else if (7 == pop8)
+ else if (pop8 == 7)
{
if (set_t != 0)
avr_asm_len ("clt", op, plen, 1);
case XOR:
- if (0 == pop8)
+ if (pop8 == 0)
continue;
- else if (8 == pop8)
+ else if (pop8 == 8)
avr_asm_len ("com %0", op, plen, 1);
else if (ld_reg_p && val8 == (1 << 7))
avr_asm_len ("subi %0,%1", op, plen, 1);
bool sign_extend = src.sbit && sign_bytes;
- if (0 == dest.fbit % 8 && 7 == src.fbit % 8)
+ if (dest.fbit % 8 == 0 && src.fbit % 8 == 7)
shift = ASHIFT;
- else if (7 == dest.fbit % 8 && 0 == src.fbit % 8)
+ else if (dest.fbit % 8 == 7 && src.fbit % 8 == 0)
shift = ASHIFTRT;
else if (dest.fbit % 8 == src.fbit % 8)
shift = UNKNOWN;
It is easier to state this in an insn attribute "adjust_len" than
to clutter up code here... */
- if (!NONDEBUG_INSN_P (insn)
- || -1 == recog_memoized (insn))
+ if (!NONDEBUG_INSN_P (insn) || recog_memoized (insn) == -1)
{
return len;
}
we have also to track .rodata because it is located in RAM then. */
#if defined HAVE_LD_AVR_AVRXMEGA3_RODATA_IN_FLASH
- if (0 == avr_arch->flash_pm_offset)
+ if (avr_arch->flash_pm_offset == 0)
#endif
readonly_data_section->unnamed.callback = avr_output_data_section_asm_op;
data_section->unnamed.callback = avr_output_data_section_asm_op;
if (!avr_need_copy_data_p
#if defined HAVE_LD_AVR_AVRXMEGA3_RODATA_IN_FLASH
- && 0 == avr_arch->flash_pm_offset
+ && avr_arch->flash_pm_offset == 0
#endif
)
avr_need_copy_data_p = (STR_PREFIX_P (name, ".rodata")
/* PSTR strings are in generic space but located in flash:
patch address space. */
- if (!AVR_TINY
- && -1 == avr_progmem_p (decl, attr))
+ if (!AVR_TINY && avr_progmem_p (decl, attr) == -1)
as = ADDR_SPACE_FLASH;
AVR_SYMBOL_SET_ADDR_SPACE (sym, as);
&& SYMBOL_REF_P (XEXP (rtl, 0)))
{
rtx sym = XEXP (rtl, 0);
- bool progmem_p = -1 == avr_progmem_p (decl, DECL_ATTRIBUTES (decl));
+ bool progmem_p = avr_progmem_p (decl, DECL_ATTRIBUTES (decl)) == -1;
if (progmem_p)
{
static bool
avr_2word_insn_p (rtx_insn *insn)
{
- if (TARGET_SKIP_BUG
- || !insn
- || 2 != get_attr_length (insn))
+ if (TARGET_SKIP_BUG || !insn || get_attr_length (insn) != 2)
{
return false;
}
if (INTVAL (lo16) == INTVAL (hi16))
{
- if (0 != INTVAL (lo16)
- || !clear_p)
- {
- avr_asm_len ("movw %C0,%A0", &op[0], len, 1);
- }
+ if (INTVAL (lo16) != 0 || !clear_p)
+ avr_asm_len ("movw %C0,%A0", &op[0], len, 1);
break;
}
/* Need no clobber reg for -1: Use CLR/DEC */
- if (-1 == ival[n])
+ if (ival[n] == -1)
{
if (!clear_p)
avr_asm_len ("clr %0", &xdest[n], len, 1);
avr_asm_len ("dec %0", &xdest[n], len, 1);
continue;
}
- else if (1 == ival[n])
+ else if (ival[n] == 1)
{
if (!clear_p)
avr_asm_len ("clr %0", &xdest[n], len, 1);
avr_has_nibble_0xf (rtx ival)
{
unsigned int map = UINTVAL (ival) & GET_MODE_MASK (SImode);
- return 0 != avr_map_metric (map, MAP_MASK_PREIMAGE_F);
+ return avr_map_metric (map, MAP_MASK_PREIMAGE_F) != 0;
}
static avr_map_op_t
avr_map_decompose (unsigned int f, const avr_map_op_t *g, bool val_const_p)
{
- bool val_used_p = 0 != avr_map_metric (f, MAP_MASK_PREIMAGE_F);
+ bool val_used_p = avr_map_metric (f, MAP_MASK_PREIMAGE_F) != 0;
avr_map_op_t f_ginv = *g;
unsigned int ginv = g->ginv;
/* Step 2a: Compute cost of F o G^-1 */
- if (0 == avr_map_metric (f_ginv.map, MAP_NONFIXED_0_7))
- {
- /* The mapping consists only of fixed points and can be folded
- to AND/OR logic in the remainder. Reasonable cost is 3. */
-
- f_ginv.cost = 2 + (val_used_p && !val_const_p);
- }
+ if (avr_map_metric (f_ginv.map, MAP_NONFIXED_0_7) == 0)
+ /* The mapping consists only of fixed points and can be folded
+ to AND/OR logic in the remainder. Reasonable cost is 3. */
+ f_ginv.cost = 2 + (val_used_p && !val_const_p);
else
{
rtx xop[4];
map = TREE_INT_CST_LOW (tmap);
if (TREE_CODE (tval) != INTEGER_CST
- && 0 == avr_map_metric (map, MAP_MASK_PREIMAGE_F))
+ && avr_map_metric (map, MAP_MASK_PREIMAGE_F) == 0)
{
/* There are no F in the map, i.e. 3rd operand is unused.
Replace that argument with some constant to render
}
if (TREE_CODE (tbits) != INTEGER_CST
- && 0 == avr_map_metric (map, MAP_PREIMAGE_0_7))
+ && avr_map_metric (map, MAP_PREIMAGE_0_7) == 0)
{
/* Similar for the bits to be inserted. If they are unused,
we can just as well pass 0. */
/* If bits don't change their position we can use vanilla logic
to merge the two arguments. */
- if (0 == avr_map_metric (map, MAP_NONFIXED_0_7))
+ if (avr_map_metric (map, MAP_NONFIXED_0_7) == 0)
{
int mask_f = avr_map_metric (map, MAP_MASK_PREIMAGE_F);
tree tres, tmask = build_int_cst (val_type, mask_f ^ 0xff);
(define_constraint "Y01"
"Fixed-point or integer constant with bit representation 0x1"
(ior (and (match_code "const_fixed")
- (match_test "1 == INTVAL (avr_to_int_mode (op))"))
+ (match_test "INTVAL (avr_to_int_mode (op)) == 1"))
(match_test "satisfies_constraint_P (op)")))
(define_constraint "Ym1"
"Fixed-point or integer constant with bit representation -0x1"
(ior (and (match_code "const_fixed")
- (match_test "-1 == INTVAL (avr_to_int_mode (op))"))
+ (match_test "INTVAL (avr_to_int_mode (op)) == -1"))
(match_test "satisfies_constraint_N (op)")))
(define_constraint "Y02"
"Fixed-point or integer constant with bit representation 0x2"
(ior (and (match_code "const_fixed")
- (match_test "2 == INTVAL (avr_to_int_mode (op))"))
+ (match_test "INTVAL (avr_to_int_mode (op)) == 2"))
(match_test "satisfies_constraint_K (op)")))
(define_constraint "Ym2"
"Fixed-point or integer constant with bit representation -0x2"
(ior (and (match_code "const_fixed")
- (match_test "-2 == INTVAL (avr_to_int_mode (op))"))
+ (match_test "INTVAL (avr_to_int_mode (op)) == -2"))
(match_test "satisfies_constraint_Cm2 (op)")))
(define_constraint "Yx2"
return X_NODEVLIB;
case 1:
- if (0 == strcmp ("device-specs", argv[0]))
+ if (strcmp ("device-specs", argv[0]) == 0)
{
/* FIXME: This means "device-specs%s" from avr.h:DRIVER_SELF_SPECS
has not been resolved to a path. That case can occur when the
// Allow specifying the same MCU more than once.
for (int i = 2; i < argc; i++)
- if (0 != strcmp (mmcu, argv[i]))
+ if (strcmp (mmcu, argv[i]) != 0)
{
error ("specified option %qs more than once", "-mmcu");
return X_NODEVLIB;
static bool
str_prefix_p (const char *str, const char *prefix)
{
- return 0 == strncmp (str, prefix, strlen (prefix));
+ return strncmp (str, prefix, strlen (prefix)) == 0;
}
FILE *f = fopen (name ,"w");
- bool absdata = 0 != (mcu->dev_attribute & AVR_ISA_LDS);
- bool errata_skip = 0 != (mcu->dev_attribute & AVR_ERRATA_SKIP);
- bool rmw = 0 != (mcu->dev_attribute & AVR_ISA_RMW);
- bool sp8 = 0 != (mcu->dev_attribute & AVR_SHORT_SP);
+ bool absdata = (mcu->dev_attribute & AVR_ISA_LDS) != 0;
+ bool errata_skip = (mcu->dev_attribute & AVR_ERRATA_SKIP) != 0;
+ bool rmw = (mcu->dev_attribute & AVR_ISA_RMW) != 0;
+ bool sp8 = (mcu->dev_attribute & AVR_SHORT_SP) != 0;
bool rcall = (mcu->dev_attribute & AVR_ISA_RCALL);
- bool is_arch = NULL == mcu->macro;
+ bool is_arch = mcu->macro == NULL;
bool is_device = ! is_arch;
if (is_arch
;; 8 or 16 or 24.
(define_predicate "const_8_16_24_operand"
(and (match_code "const_int")
- (match_test "8 == INTVAL(op) || 16 == INTVAL(op) || 24 == INTVAL(op)")))
+ (match_test "INTVAL(op) == 8 || INTVAL(op) == 16 || INTVAL(op) == 24")))
;; Unsigned CONST_INT that fits in 8 bits, i.e. 0..255.
(define_predicate "u8_operand"
for (i = current_frame_info.last_reg_to_save; i >= 0;)
{
- if (!current_frame_info.save_regs[i] || 0 == i || split_here)
+ if (!current_frame_info.save_regs[i] || i == 0 || split_here)
{
/* This block of regs is pushed in one instruction. */
- if (0 == i && current_frame_info.save_regs[i])
+ if (i == 0 && current_frame_info.save_regs[i])
from = 0;
for (j = to; j >= from; --j)
/* A C expression whose value is RTL representing the value of the return
address for the frame COUNT steps up from the current frame. */
#define RETURN_ADDR_RTX(COUNT, FRAME) \
- (0 == COUNT) ? gen_rtx_PLUS (Pmode, gen_rtx_RA, gen_rtx_RA) \
+ (COUNT == 0) ? gen_rtx_PLUS (Pmode, gen_rtx_RA, gen_rtx_RA) \
: const0_rtx
enum reg_class
(CR16_REGNO_OK_FOR_BASE_P(REGNO) && \
((GET_MODE_SIZE (MODE) > 4 && \
(REGNO) < CR16_FIRST_DWORD_REGISTER) \
- ? (0 == ((REGNO) & 1)) \
+ ? (((REGNO) & 1) == 0) \
: 1))
/* TODO: For now lets not support index addressing mode. */
|| register_operand (operands[1], DImode)
|| register_operand (operands[1], DFmode)"
{
- if (0 == which_alternative) {
- rtx xoperands[2] ;
+ if (which_alternative == 0) {
+ rtx xoperands[2];
int reg0 = REGNO (operands[0]);
int reg1 = REGNO (operands[1]);
output_asm_insn ("movd\t%1, %0", operands);
}}
- else if (1 == which_alternative) {
- rtx lo_operands[2] ;
- rtx hi_operands[2] ;
+ else if (which_alternative == 1) {
+ rtx lo_operands[2];
+ rtx hi_operands[2];
lo_operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]));
hi_operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 2);
output_asm_insn ("movd\t%1, %0", lo_operands);
output_asm_insn ("movd\t%1, %0", hi_operands);}
- else if (2 == which_alternative) {
- rtx xoperands[2] ;
- int reg0 = REGNO (operands[0]), reg1 = -2 ;
- rtx addr ;
+ else if (which_alternative == 2) {
+ rtx xoperands[2];
+ int reg0 = REGNO (operands[0]), reg1 = -2;
+ rtx addr;
if (MEM_P (operands[1]))
addr = XEXP (operands[1], 0);
else
- addr = NULL_RTX ;
+ addr = NULL_RTX;
switch (GET_CODE (addr))
{
case REG:
case SUBREG:
reg1 = REGNO (addr);
- break ;
+ break;
case PLUS:
switch (GET_CODE (XEXP (addr, 0))) {
case REG:
case SUBREG:
reg1 = REGNO (XEXP (addr, 0));
- break ;
+ break;
case PLUS:
reg1 = REGNO (XEXP (XEXP (addr, 0), 0));
- break ;
+ break;
default:
inform (DECL_SOURCE_LOCATION (cfun->decl), "unexpected expression; addr:");
debug_rtx (addr);
inform (DECL_SOURCE_LOCATION (cfun->decl), "operands[1]:");
debug_rtx (operands[1]);
inform (DECL_SOURCE_LOCATION (cfun->decl), "generated code might now work\n");
- break ;}
- break ;
+ break;}
+ break;
default:
- break ;
+ break;
}
xoperands[0] = gen_rtx_REG (SImode, reg0 + 2);
}}
else
{
- rtx xoperands[2] ;
+ rtx xoperands[2];
xoperands[0] = offset_address (operands[0], GEN_INT (4), 2);
xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 2);
output_asm_insn ("stord\t%1, %0", operands);
output_asm_insn ("stord\t%1, %0", xoperands);
}
- return "" ;
+ return "";
}
[(set_attr "length" "4, <lImmArithD>, <lImmArithD>, <lImmArithD>")]
)
(define_constraint "L"
"A 16-bit unsigned constant, multiple of 4 (-65532..0)"
(and (match_code "const_int")
- (match_test "-65532 <= ival && ival <= 0 && (ival & 3) == 0")))
+ (match_test "ival >= -65532 && ival <= 0 && (ival & 3) == 0")))
(define_constraint "S"
"A 20-bit signed constant (-524288..524287)"
(define_constraint "b"
"A constant for a bitfield width (1..16)"
(and (match_code "const_int")
- (match_test "1 <= ival && ival <= 16")))
+ (match_test "ival >= 1 && ival <= 16")))
(define_constraint "KA"
"A 10-bit signed constant (-512..511)"
(and (match_code "const_int")
- (match_test "-512 <= ival && ival <= 511")))
+ (match_test "ival >= -512 && ival <= 511")))
{
char pattern[100];
- if ((-524288 <= i) && (i <= 524287))
+ if (i >= -524288 && i <= 524287)
{
sprintf (pattern, "ldk.l %%0,%d", i);
output_asm_insn (pattern, &dst);
}
- else if ((-536870912 <= i) && (i <= 536870911))
+ else if (i >= -536870912 && i <= 536870911)
{
ft32_load_immediate (dst, i >> 10);
sprintf (pattern, "ldl.l %%0,%%0,%d", i & 1023);
for (rd = 1; rd < 32; rd++)
{
u = ((u >> 31) & 1) | (u << 1);
- if ((-524288 <= (int32_t) u) && ((int32_t) u <= 524287))
+ if ((int32_t) u >= -524288 && (int32_t) u <= 524287)
{
ft32_load_immediate (dst, (int32_t) u);
sprintf (pattern, "ror.l %%0,%%0,%d", rd);
}
}
- if (65536 <= cfun->machine->size_for_adjusting_sp)
+ if (cfun->machine->size_for_adjusting_sp >= 65536)
{
error ("stack frame must be smaller than 64K");
return;
*total = 0;
return true;
}
- if (-4 <= n && n <= 4)
+ if (n >= -4 && n <= 4)
{
switch ((int) n)
{
goto end;
}
}
- else if ((8 <= count && count <= 13)
+ else if ((count >= 8 && count <= 13)
|| (TARGET_H8300S && count == 14))
{
info->remainder = count - 8;
gcc_unreachable ();
case SIshift:
- if (TARGET_H8300 && 8 <= count && count <= 9)
+ if (TARGET_H8300 && count >= 8 && count <= 9)
{
info->remainder = count - 8;
gcc_unreachable ();
}
}
- else if ((TARGET_H8300 && 16 <= count && count <= 20)
- || (TARGET_H8300H && 16 <= count && count <= 19)
- || (TARGET_H8300S && 16 <= count && count <= 21))
+ else if ((TARGET_H8300 && count >= 16 && count <= 20)
+ || (TARGET_H8300H && count >= 16 && count <= 19)
+ || (TARGET_H8300S && count >= 16 && count <= 21))
{
info->remainder = count - 16;
goto end;
}
}
- else if (TARGET_H8300 && 24 <= count && count <= 28)
+ else if (TARGET_H8300 && count >= 24 && count <= 28)
{
info->remainder = count - 24;
}
}
else if ((TARGET_H8300H && count == 24)
- || (TARGET_H8300S && 24 <= count && count <= 25))
+ || (TARGET_H8300S && count >= 24 && count <= 25))
{
info->remainder = count - 24;
if (next_range_str)
*next_range_str++ = '\0';
- if (3 != sscanf (curr_range_str, "%20[^:]:%d:%10s",
- alg_name, &maxs, align))
+ if (sscanf (curr_range_str, "%20[^:]:%d:%10s", alg_name, &maxs,
+ align) != 3)
{
error ("wrong argument %qs to option %qs", curr_range_str, opt);
return;
{
if (next_arg == 0
&& DECL_NAME (cur_arg)
- && ((0 == strcmp (IDENTIFIER_POINTER (DECL_NAME (cur_arg)),
- "__builtin_va_alist"))
- || (0 == strcmp (IDENTIFIER_POINTER (DECL_NAME (cur_arg)),
- "va_alist"))))
+ && (strcmp (IDENTIFIER_POINTER (DECL_NAME (cur_arg)),
+ "__builtin_va_alist") == 0
+ || strcmp (IDENTIFIER_POINTER (DECL_NAME (cur_arg)),
+ "va_alist") == 0))
{
last_arg_is_vararg_marker = 1;
break;
if (type != CPP_EOF)
warning (0, "junk at end of #pragma GCC memregs [0..16]");
- if (0 <= i && i <= 16)
+ if (i >= 0 && i <= 16)
{
if (!ok_to_change_target_memregs)
{
{
int i;
- if (0 <= target_memregs && target_memregs <= 16)
+ if (target_memregs >= 0 && target_memregs <= 16)
{
/* The command line option is bytes, but our "registers" are
16-bit words. */
i = INTVAL (addr);
if (i == 0)
return COSTS_N_INSNS(1);
- if (0 < i && i <= 255)
+ if (i > 0 && i <= 255)
return COSTS_N_INSNS(2);
- if (0 < i && i <= 65535)
+ if (i > 0 && i <= 65535)
return COSTS_N_INSNS(3);
return COSTS_N_INSNS(4);
case SYMBOL_REF:
i = INTVAL (XEXP (addr, 1));
if (i == 0)
return COSTS_N_INSNS(1);
- if (0 < i && i <= 255)
+ if (i > 0 && i <= 255)
return COSTS_N_INSNS(2);
- if (0 < i && i <= 65535)
+ if (i > 0 && i <= 65535)
return COSTS_N_INSNS(3);
}
return COSTS_N_INSNS(4);
(define_predicate "shiftcount_operand"
(ior (match_operand 0 "mra_operand" "")
(and (match_operand 2 "const_int_operand" "")
- (match_test "-8 <= INTVAL (op) && INTVAL (op) && INTVAL (op) <= 8"))))
+ (match_test "INTVAL (op) >= -8 && INTVAL (op) && INTVAL (op) <= 8"))))
(define_predicate "longshiftcount_operand"
(ior (match_operand 0 "mra_operand" "")
(and (match_operand 2 "const_int_operand" "")
- (match_test "-32 <= INTVAL (op) && INTVAL (op) && INTVAL (op) <= 32"))))
+ (match_test "INTVAL (op) >= -32 && INTVAL (op) && INTVAL (op) <= 32"))))
; TRUE for r0..r3, a0..a1, or sp.
(define_predicate "mra_or_sp_operand"
{
const char *s;
- gcc_assert (GET_MODE (reg) == SImode
- && -12 <= n && n != 0 && n <= 12);
+ gcc_assert (GET_MODE (reg) == SImode && n >= -12 && n != 0 && n <= 12);
switch (n)
{
{
rtx reg2;
- gcc_assert (GET_MODE (reg1) == SImode
- && -12 <= n && n != 0 && n <= 12);
+ gcc_assert (GET_MODE (reg1) == SImode && n >= -12 && n != 0 && n <= 12);
reg1 = copy_rtx (reg1);
reg2 = copy_rtx (reg1);
{
int param = N2FPU_N (fpu_insn_index);
- if (0 <= param && param <= 255)
+ if (param >= 0 && param <= 255)
nios2_register_custom_code (param, CCS_FPU, fpu_insn_index);
/* Valid values are 0-255, but also allow -1 so that the
can_use_cdx_ldstw (int regno, int basereg, int offset)
{
if (CDX_REG_P (regno) && CDX_REG_P (basereg)
- && (offset & 0x3) == 0 && 0 <= offset && offset < 0x40)
+ && (offset & 0x3) == 0 && offset >= 0 && offset < 0x40)
return true;
else if (basereg == SP_REGNO
&& offset >= 0 && offset < 0x80 && (offset & 0x3) == 0)
((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
#define CDX_REG_P(REGNO) \
- ((REGNO) == 16 || (REGNO) == 17 || (2 <= (REGNO) && (REGNO) <= 7))
+ ((REGNO) == 16 || (REGNO) == 17 || ((REGNO) >= 2 && (REGNO) <= 7))
/* Tests for various kinds of constants used in the Nios II port. */
(define_constraint "U06"
"unsigned 6 bit value (0..63)"
(and (match_code "const_int")
- (match_test "0 <= ival && ival < 64")))
+ (match_test "ival >= 0 && ival < 64")))
(define_constraint "U08"
"Unsigned 8 bit value"
(and (match_code "const_int")
- (match_test "0 <= ival && ival < 256")))
+ (match_test "ival >= 0 && ival < 256")))
(define_constraint "U16"
"Unsigned 16 bit value"
(and (match_code "const_int")
- (match_test "0 <= ival && ival < 65536")))
+ (match_test "ival >= 0 && ival < 65536")))
(define_constraint "CN6"
"negative 6 bit value (-63..-1)"
(and (match_code "const_int")
- (match_test "-63 <= ival && ival < 0")))
+ (match_test "ival >= -63 && ival < 0")))
(define_constraint "S08"
"signed 8 bit value [old]"
(and (match_code "const_int")
- (match_test "-128 <= ival && ival < 128")))
+ (match_test "ival >= -128 && ival < 128")))
(define_constraint "S16"
"signed 16 bit value [old]"
(and (match_code "const_int")
- (match_test "-32768 <= ival && ival < 32768")))
+ (match_test "ival >= -32768 && ival < 32768")))
(define_constraint "I"
"Match a CONST_INT of 0 [old]"
if (REG_P (lo))
return mode == SImode && REGNO (lo) + 1 == REGNO (hi);
if (CONST_INT_P (lo))
- return INTVAL (hi) == 0 && 0 <= INTVAL (lo) && INTVAL (lo) < 64;
+ return INTVAL (hi) == 0 && UINTVAL (lo) < 64;
if (CONST_INT_P (lo))
return mode != SImode;
(define_constraint "J"
"Integer constant in the range 0 .. 65535 (16-bit immediate)"
(and (match_code "const_int")
- (match_test "0 <= ival && ival <= 65535")))
+ (match_test "ival >= 0 && ival <= 65535")))
(define_constraint "K"
"Integer constant in the range 1 .. 31 (5-bit immediate)"
(and (match_code "const_int")
- (match_test "1 <= ival && ival <= 31")))
+ (match_test "ival >= 1 && ival <= 31")))
(define_constraint "L"
"Integer constant in the range -65535 .. -1 (16-bit negative immediate)"
(and (match_code "const_int")
- (match_test "-65535 <= ival && ival <= -1")))
+ (match_test "ival >= -65535 && ival <= -1")))
(define_constraint "M"
"Integer constant -1"
;; Return true if OP is a constant in the range 1 .. 31.
(define_predicate "const_shift_operand"
(and (match_code "const_int")
- (match_test "1 <= INTVAL (op) && INTVAL (op) <= 31")))
+ (match_test "INTVAL (op) >= 1 && INTVAL (op) <= 31")))
;; Return true if OP is either a register or the constant 0.
(define_predicate "reg_or_0_operand"
int offset_base = offset & ~mask;
/* Check that all of the words can be accessed. */
- if (4 < size && 0x80 < size + offset - offset_base)
+ if (size > 4 && 0x80 < size + offset - offset_base)
offset_base = offset & ~0x3f;
if (offset_base != 0 && offset_base != offset && (offset & mask1) == 0)
{
int offset_base = offset & ~mask;
/* Check that all of the words can be accessed. */
- if (4 < size && 0x80 < size + offset - offset_base)
+ if (size > 4 && 0x80 < size + offset - offset_base)
offset_base = offset & ~0x3f;
if (offset_base && (offset & mask1) == 0)
+2017-12-19 Jakub Jelinek <jakub@redhat.com>
+
+ * name-lookup.c (get_std_name_hint): Replace Yoda conditions with
+ typical order conditions.
+ * class.c (check_bitfield_decl): Likewise.
+ * pt.c (convert_template_argument): Likewise.
+ * decl.c (duplicate_decls): Likewise.
+ * typeck.c (commonparms): Likewise.
+
2017-12-19 Paolo Carlini <paolo.carlini@oracle.com>
* cp-tree.h: Fix typo in comment.
&& tree_int_cst_lt (TYPE_SIZE (type), w)))
warning_at (DECL_SOURCE_LOCATION (field), 0,
"width of %qD exceeds its type", field);
- else if (TREE_CODE (type) == ENUMERAL_TYPE
- && (0 > (compare_tree_int
- (w, TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type))))))
- warning_at (DECL_SOURCE_LOCATION (field), 0,
- "%qD is too small to hold all values of %q#T",
- field, type);
+ else if (TREE_CODE (type) == ENUMERAL_TYPE)
+ {
+ int prec = TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type));
+ if (compare_tree_int (w, prec) < 0)
+ warning_at (DECL_SOURCE_LOCATION (field), 0,
+ "%qD is too small to hold all values of %q#T",
+ field, type);
+ }
}
if (w != error_mark_node)
t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
{
- if (1 == simple_cst_equal (TREE_PURPOSE (t1),
- TREE_PURPOSE (t2)))
+ if (simple_cst_equal (TREE_PURPOSE (t1),
+ TREE_PURPOSE (t2)) == 1)
{
if (permerror (input_location,
"default argument given for parameter "
const size_t num_hints = sizeof (hints) / sizeof (hints[0]);
for (size_t i = 0; i < num_hints; i++)
{
- if (0 == strcmp (name, hints[i].name))
+ if (strcmp (name, hints[i].name) == 0)
return hints[i].header;
}
return NULL;
if (innertype
&& TREE_CODE (innertype) == REFERENCE_TYPE
&& TREE_CODE (TREE_TYPE (innertype)) == FUNCTION_TYPE
- && 0 < TREE_OPERAND_LENGTH (inner)
+ && TREE_OPERAND_LENGTH (inner) > 0
&& reject_gcc_builtin (TREE_OPERAND (inner, 0)))
return error_mark_node;
}
}
else
{
- if (1 != simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2)))
+ if (simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2)) != 1)
any_change = 1;
TREE_PURPOSE (n) = TREE_PURPOSE (p2);
}
int offs;
letter = 'G';
code = N_GSYM;
- if (NULL != dbxout_common_check (decl, &offs))
+ if (dbxout_common_check (decl, &offs) != NULL)
{
letter = 'V';
addr = 0;
{
int offs;
code = N_LCSYM;
- if (NULL != dbxout_common_check (decl, &offs))
+ if (dbxout_common_check (decl, &offs) != NULL)
{
addr = 0;
number = offs;
int offs;
code = N_LCSYM;
letter = 'V';
- if (NULL == dbxout_common_check (decl, &offs))
+ if (dbxout_common_check (decl, &offs) == NULL)
addr = XEXP (XEXP (home, 0), 0);
else
{
{
pp_space (m_pp);
for (int column = 1 + m_x_offset; column <= max_column; column++)
- if (0 == column % 10)
+ if (column % 10 == 0)
pp_character (m_pp, '0' + (column / 100) % 10);
else
pp_space (m_pp);
/* Tens. */
pp_space (m_pp);
for (int column = 1 + m_x_offset; column <= max_column; column++)
- if (0 == column % 10)
+ if (column % 10 == 0)
pp_character (m_pp, '0' + (column / 10) % 10);
else
pp_space (m_pp);
do_pending_stack_adjust ();
code = unsignedp ? unsigned_condition (code) : code;
- if (0 != (tem = simplify_relational_operation (code, mode, VOIDmode,
- op0, op1)))
+ if ((tem = simplify_relational_operation (code, mode, VOIDmode,
+ op0, op1)) != 0)
{
if (CONSTANT_P (tem))
{
get_dump_file_info_by_switch (const char *swtch) const
{
for (unsigned i = 0; i < m_extra_dump_files_in_use; i++)
- if (0 == strcmp (m_extra_dump_files[i].swtch, swtch))
+ if (strcmp (m_extra_dump_files[i].swtch, swtch) == 0)
return &m_extra_dump_files[i];
/* Not found. */
{
rtx_insn *prev = get_last_insn ();
link_insn_into_chain (insn, prev, NULL);
- if (NULL == get_insns ())
+ if (get_insns () == NULL)
set_first_insn (insn);
set_last_insn (insn);
}
return NULL;
}
- if (0 < o2->depth)
+ if (o2->depth > 0)
{
om = o1;
mn = o1->depth;
return false;
}
- if (0 >= d->depth)
+ if (d->depth <= 0)
return false;
return !d->next || d->next->min + d->depth >= 0;
/* First handle constants appearing at this level explicitly. */
if (CONST_INT_P (XEXP (x, 1))
- && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr,
- XEXP (x, 1)))
+ && (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr,
+ XEXP (x, 1))) != 0
&& CONST_INT_P (tem))
{
*constptr = tem;
x0 = eliminate_constant_term (XEXP (x, 0), &tem);
x1 = eliminate_constant_term (XEXP (x, 1), &tem);
if ((x1 != XEXP (x, 1) || x0 != XEXP (x, 0))
- && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x),
- *constptr, tem))
+ && (tem = simplify_binary_operation (PLUS, GET_MODE (x),
+ *constptr, tem)) != 0
&& CONST_INT_P (tem))
{
*constptr = tem;
target
= adjust_address (target,
GET_MODE (target) == BLKmode
- || 0 != (bitpos
- % GET_MODE_ALIGNMENT (GET_MODE (target)))
+ || (bitpos
+ % GET_MODE_ALIGNMENT (GET_MODE (target))) != 0
? BLKmode : VOIDmode, bitpos / BITS_PER_UNIT);
|| (bitsize >= 0
&& TYPE_SIZE (TREE_TYPE (exp))
&& TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
- && 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)),
- bitsize)))
+ && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)),
+ bitsize) != 0))
{
machine_mode ext_mode = mode;
break;
case 'E':
- if (NULL != XVEC (in_rtx, i))
- {
- for (j = 0; j < XVECLEN (in_rtx, i); j++)
- leaf_renumber_regs_insn (XVECEXP (in_rtx, i, j));
- }
+ if (XVEC (in_rtx, i) != NULL)
+ for (j = 0; j < XVECLEN (in_rtx, i); j++)
+ leaf_renumber_regs_insn (XVECEXP (in_rtx, i, j));
break;
case 'S':
if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
&& merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
in1_p, low1, high1)
- && 0 != (tem = (build_range_check (loc, type,
- lhs != 0 ? lhs
- : rhs != 0 ? rhs : integer_zero_node,
- in_p, low, high))))
+ && (tem = (build_range_check (loc, type,
+ lhs != 0 ? lhs
+ : rhs != 0 ? rhs : integer_zero_node,
+ in_p, low, high))) != 0)
{
if (strict_overflow_p)
fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
{
tree common = save_expr (lhs);
- if (0 != (lhs = build_range_check (loc, type, common,
- or_op ? ! in0_p : in0_p,
- low0, high0))
- && (0 != (rhs = build_range_check (loc, type, common,
- or_op ? ! in1_p : in1_p,
- low1, high1))))
+ if ((lhs = build_range_check (loc, type, common,
+ or_op ? ! in0_p : in0_p,
+ low0, high0)) != 0
+ && (rhs = build_range_check (loc, type, common,
+ or_op ? ! in1_p : in1_p,
+ low1, high1)) != 0)
{
if (strict_overflow_p)
fold_overflow_warning (warnmsg,
if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
&& TREE_CODE (t2) == INTEGER_CST
&& !TREE_OVERFLOW (t2)
- && (0 != (t1 = extract_muldiv (op0, t2, code,
- code == MULT_EXPR
- ? ctype : NULL_TREE,
- strict_overflow_p))))
+ && (t1 = extract_muldiv (op0, t2, code,
+ code == MULT_EXPR ? ctype : NULL_TREE,
+ strict_overflow_p)) != 0)
return t1;
break;
so check for it explicitly here. */
&& wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)),
wi::to_wide (op1))
- && 0 != (t1 = fold_convert (ctype,
- const_binop (LSHIFT_EXPR,
- size_one_node,
- op1)))
+ && (t1 = fold_convert (ctype,
+ const_binop (LSHIFT_EXPR, size_one_node,
+ op1))) != 0
&& !TREE_OVERFLOW (t1))
return extract_muldiv (build2 (tcode == LSHIFT_EXPR
? MULT_EXPR : FLOOR_DIV_EXPR,
}
/* See if we can build a range comparison. */
- if (0 != (tem = fold_range_test (loc, code, type, op0, op1)))
+ if ((tem = fold_range_test (loc, code, type, op0, op1)) != 0)
return tem;
if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg0) == TRUTH_ORIF_EXPR)
lhs is another similar operation, try to merge its rhs with our
rhs. Then try to merge our lhs and rhs. */
if (TREE_CODE (arg0) == code
- && 0 != (tem = fold_truth_andor_1 (loc, code, type,
- TREE_OPERAND (arg0, 1), arg1)))
+ && (tem = fold_truth_andor_1 (loc, code, type,
+ TREE_OPERAND (arg0, 1), arg1)) != 0)
return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
if ((tem = fold_truth_andor_1 (loc, code, type, arg0, arg1)) != 0)
STRIP_NOPS (tree110);
STRIP_NOPS (tree111);
if (TREE_CODE (tree110) == INTEGER_CST
- && 0 == compare_tree_int (tree110,
- element_precision (rtype))
+ && compare_tree_int (tree110,
+ element_precision (rtype)) == 0
&& operand_equal_p (tree01, tree111, 0))
{
tem = build2_loc (loc, (code0 == LSHIFT_EXPR
STRIP_NOPS (tree111);
if (TREE_CODE (tree110) == NEGATE_EXPR
&& TREE_CODE (tree111) == INTEGER_CST
- && 0 == compare_tree_int (tree111,
- element_precision (rtype) - 1)
+ && compare_tree_int (tree111,
+ element_precision (rtype) - 1) == 0
&& operand_equal_p (tree01, TREE_OPERAND (tree110, 0), 0))
{
tem = build2_loc (loc, (code0 == LSHIFT_EXPR
/* Only do something if we found more than two objects. Otherwise,
nothing has changed and we risk infinite recursion. */
if (ok
- && (2 < ((var0 != 0) + (var1 != 0)
- + (minus_var0 != 0) + (minus_var1 != 0)
- + (con0 != 0) + (con1 != 0)
- + (minus_con0 != 0) + (minus_con1 != 0)
- + (lit0 != 0) + (lit1 != 0)
- + (minus_lit0 != 0) + (minus_lit1 != 0))))
+ && ((var0 != 0) + (var1 != 0)
+ + (minus_var0 != 0) + (minus_var1 != 0)
+ + (con0 != 0) + (con1 != 0)
+ + (minus_con0 != 0) + (minus_con1 != 0)
+ + (lit0 != 0) + (lit1 != 0)
+ + (minus_lit0 != 0) + (minus_lit1 != 0)) > 2)
{
var0 = associate_trees (loc, var0, var1, code, atype);
minus_var0 = associate_trees (loc, minus_var0, minus_var1,
strict_overflow_p = false;
if (TREE_CODE (arg1) == INTEGER_CST
- && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
- &strict_overflow_p)))
+ && (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
+ &strict_overflow_p)) != 0)
{
if (strict_overflow_p)
fold_overflow_warning (("assuming signed overflow does not "
strict_overflow_p = false;
if (TREE_CODE (arg1) == INTEGER_CST
- && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
- &strict_overflow_p)))
+ && (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
+ &strict_overflow_p)) != 0)
{
if (strict_overflow_p)
fold_overflow_warning (("assuming signed overflow does not occur "
case TRUNC_MOD_EXPR:
strict_overflow_p = false;
if (TREE_CODE (arg1) == INTEGER_CST
- && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
- &strict_overflow_p)))
+ && (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
+ &strict_overflow_p)) != 0)
{
if (strict_overflow_p)
fold_overflow_warning (("assuming signed overflow does not occur "
&& TREE_CODE (arg1) == INTEGER_CST
&& TREE_CODE (arg0) == ABS_EXPR
&& ! TREE_SIDE_EFFECTS (arg0)
- && (0 != (tem = negate_expr (arg1)))
+ && (tem = negate_expr (arg1)) != 0
&& TREE_CODE (tem) == INTEGER_CST
&& !TREE_OVERFLOW (tem))
return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
so check for it explicitly here. */
if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)),
wi::to_wide (op1))
- && 0 != (t1 = fold_convert (type,
- const_binop (LSHIFT_EXPR,
- size_one_node,
- op1)))
+ && (t1 = fold_convert (type,
+ const_binop (LSHIFT_EXPR, size_one_node,
+ op1))) != 0
&& !TREE_OVERFLOW (t1))
return multiple_of_p (type, t1, bottom);
}
+2017-12-19 Jakub Jelinek <jakub@redhat.com>
+
+ * scanner.c (preprocessor_line): Replace Yoda conditions with typical
+ order conditions.
+ * dependency.c (check_section_vs_section): Likewise.
+ * trans-array.c (gfc_conv_expr_descriptor): Likewise.
+
2017-12-17 Janne Blomqvist <jb@gcc.gnu.org>
* decl.c (gfc_match_implicit_none): Use GFC_STD_F2018 instead of
r_stride = r_ar->stride[n];
/* If l_start is NULL take it from array specifier. */
- if (NULL == l_start && IS_ARRAY_EXPLICIT (l_ar->as))
+ if (l_start == NULL && IS_ARRAY_EXPLICIT (l_ar->as))
l_start = l_ar->as->lower[n];
/* If l_end is NULL take it from array specifier. */
- if (NULL == l_end && IS_ARRAY_EXPLICIT (l_ar->as))
+ if (l_end == NULL && IS_ARRAY_EXPLICIT (l_ar->as))
l_end = l_ar->as->upper[n];
/* If r_start is NULL take it from array specifier. */
- if (NULL == r_start && IS_ARRAY_EXPLICIT (r_ar->as))
+ if (r_start == NULL && IS_ARRAY_EXPLICIT (r_ar->as))
r_start = r_ar->as->lower[n];
/* If r_end is NULL take it from array specifier. */
- if (NULL == r_end && IS_ARRAY_EXPLICIT (r_ar->as))
+ if (r_end == NULL && IS_ARRAY_EXPLICIT (r_ar->as))
r_end = r_ar->as->upper[n];
/* Determine whether the l_stride is positive or negative. */
c++;
i = wide_atoi (c);
- if (1 <= i && i <= 4)
+ if (i >= 1 && i <= 4)
flag[i] = true;
}
/* Special case: TRANSPOSE which needs no temporary. */
while (expr->expr_type == EXPR_FUNCTION && expr->value.function.isym
- && NULL != (arg = gfc_get_noncopying_intrinsic_argument (expr)))
+ && (arg = gfc_get_noncopying_intrinsic_argument (expr)) != NULL)
{
/* This is a call to transpose which has already been handled by the
scalarizer, so that we just need to get its argument's descriptor. */
cur_expr = table->table[hash];
found = 0;
- while (cur_expr && 0 == (found = expr_equiv_p (cur_expr->expr, x)))
+ while (cur_expr && (found = expr_equiv_p (cur_expr->expr, x)) == 0)
{
/* If the expression isn't found, save a pointer to the end of
the list. */
advance ();
const char *basename = require (ID);
/* This may be either an access specifier, or the base name. */
- if (0 == strcmp (basename, "public")
- || 0 == strcmp (basename, "protected")
- || 0 == strcmp (basename, "private"))
+ if (strcmp (basename, "public") == 0
+ || strcmp (basename, "protected") == 0
+ || strcmp (basename, "private") == 0)
basename = require (ID);
base_class = find_structure (basename, TYPE_STRUCT);
if (!base_class)
extern GTY(()) gcc::some_type *some_ptr;
where the autogenerated functions will refer to simply "some_type",
where they can be resolved into their namespace. */
- if (0 == strncmp (s, "gcc::", 5))
+ if (strncmp (s, "gcc::", 5) == 0)
s += 5;
for (p = typedefs; p != NULL; p = p->next)
}
continue;
}
- if (0 == print_nest)
+ if (print_nest == 0)
{
/* Output default definitions of target hooks. */
printf ("#ifndef %s\n#define %s %s\n#endif\n",
if (!warned
/* Only warn at level 2. */
- && 1 < warn_level
+ && warn_level > 1
&& (!minunder4k
|| (!maxunder4k && fmtres.range.max < HOST_WIDE_INT_MAX)))
{
/* Warn for the likely output size at level 1. */
&& (likelyximax
/* But only warn for the maximum at level 2. */
- || (1 < warn_level
+ || (warn_level > 1
&& maxximax
&& fmtres.range.max < HOST_WIDE_INT_MAX)))
{
expanded_location exploc
= linemap_expand_location (line_table, map, loc);
- if (0 == exploc.column)
+ if (exploc.column == 0)
{
/* Beginning of a new source line: draw the line. */
#ifdef ENABLE_IRA_CHECKING
FOR_EACH_OBJECT (obj, oi)
{
- if ((0 <= OBJECT_MIN (obj) && OBJECT_MIN (obj) <= ira_max_point)
- && (0 <= OBJECT_MAX (obj) && OBJECT_MAX (obj) <= ira_max_point))
+ if ((OBJECT_MIN (obj) >= 0 && OBJECT_MIN (obj) <= ira_max_point)
+ && (OBJECT_MAX (obj) >= 0 && OBJECT_MAX (obj) <= ira_max_point))
continue;
gcc_unreachable ();
}
+2017-12-19 Jakub Jelinek <jakub@redhat.com>
+
+ * jit-playback.c (get_type, playback::compile_to_file::copy_file,
+ playback::context::acquire_mutex): Replace Yoda conditions with
+ typical order conditions.
+ * libgccjit.c (gcc_jit_context_new_struct_type,
+ gcc_jit_struct_set_fields, gcc_jit_context_new_union_type,
+ gcc_jit_context_new_function, gcc_jit_timer_pop): Likewise.
+ * jit-builtins.c (matches_builtin): Likewise.
+ * jit-recording.c (recording::compound_type::set_fields,
+ recording::fields::write_reproducer, recording::rvalue::set_scope,
+ recording::function::validate): Likewise.
+ * jit-logging.c (logger::decref): Likewise.
+
2017-11-30 Jakub Jelinek <jakub@redhat.com>
* jit-recording.c
if (debug)
fprintf (stderr, "seen builtin: %s\n", bd.name);
- if (0 == strcmp (bd.name, in_name))
- {
- return true;
- }
+ if (strcmp (bd.name, in_name) == 0)
+ return true;
if (bd.both_p)
{
/* Then the macros in builtins.def gave a "__builtin_"
prefix to bd.name, but we should also recognize the form
without the prefix. */
- gcc_assert (0 == strncmp (bd.name, prefix, prefix_len));
+ gcc_assert (strncmp (bd.name, prefix, prefix_len) == 0);
if (debug)
fprintf (stderr, "testing without prefix as: %s\n",
bd.name + prefix_len);
- if (0 == strcmp (bd.name + prefix_len, in_name))
- {
- return true;
- }
+ if (strcmp (bd.name + prefix_len, in_name) == 0)
+ return true;
}
return false;
if (m_log_refcount_changes)
log ("%s: reason: %s refcount now %i",
__PRETTY_FUNCTION__, reason, m_refcount);
- if (0 == m_refcount)
+ if (m_refcount == 0)
delete this;
}
get_type (enum gcc_jit_types type_)
{
tree type_node = get_tree_node_for_type (type_);
- if (NULL == type_node)
+ if (type_node == NULL)
{
- add_error (NULL,
- "unrecognized (enum gcc_jit_types) value: %i", type_);
+ add_error (NULL, "unrecognized (enum gcc_jit_types) value: %i", type_);
return NULL;
}
/* Use stat on the filedescriptor to get the mode,
so that we can copy it over (in particular, the
"executable" bits). */
- if (-1 == fstat (fileno (f_in), &stat_buf))
+ if (fstat (fileno (f_in), &stat_buf) == -1)
{
add_error (NULL,
"unable to fstat %s: %s",
/* Set the permissions of the copy to those of the original file,
in particular the "executable" bits. */
- if (-1 == fchmod (fileno (f_out), stat_buf.st_mode))
+ if (fchmod (fileno (f_out), stat_buf.st_mode) == -1)
add_error (NULL,
"error setting mode of %s: %s",
dst_path,
/* Acquire the big GCC mutex. */
JIT_LOG_SCOPE (get_logger ());
pthread_mutex_lock (&jit_mutex);
- gcc_assert (NULL == active_playback_ctxt);
+ gcc_assert (active_playback_ctxt == NULL);
active_playback_ctxt = this;
}
field **field_array)
{
m_loc = loc;
- gcc_assert (NULL == m_fields);
+ gcc_assert (m_fields == NULL);
m_fields = new fields (this, num_fields, field_array);
m_ctxt->record (m_fields);
recording::fields::write_reproducer (reproducer &r)
{
if (m_struct_or_union)
- if (NULL == m_struct_or_union->dyn_cast_struct ())
+ if (m_struct_or_union->dyn_cast_struct () == NULL)
/* We have a union; the fields have already been written by
union::write_reproducer. */
return;
recording::rvalue::set_scope (function *scope)
{
gcc_assert (scope);
- gcc_assert (NULL == m_scope);
+ gcc_assert (m_scope == NULL);
m_scope = scope;
}
/* Complain about empty functions with non-void return type. */
if (m_kind != GCC_JIT_FUNCTION_IMPORTED
&& m_return_type != m_ctxt->get_type (GCC_JIT_TYPE_VOID))
- if (0 == m_blocks.length ())
+ if (m_blocks.length () == 0)
m_ctxt->add_error (m_loc,
"function %s returns non-void (type: %s)"
" but has no blocks",
/* Check that all blocks are reachable. */
if (!m_ctxt->get_inner_bool_option
(INNER_BOOL_OPTION_ALLOW_UNREACHABLE_BLOCKS)
- && m_blocks.length () > 0 && 0 == num_invalid_blocks)
+ && m_blocks.length () > 0 && num_invalid_blocks == 0)
{
/* Iteratively walk the graph of blocks, marking their "m_is_reachable"
flag, starting at the initial block. */
{
RETURN_NULL_IF_FAIL (fields[i], ctxt, loc, "NULL field ptr");
RETURN_NULL_IF_FAIL_PRINTF2 (
- NULL == fields[i]->get_container (),
+ fields[i]->get_container () == NULL,
ctxt, loc,
"%s is already a field of %s",
fields[i]->get_debug_string (),
JIT_LOG_FUNC (ctxt->get_logger ());
/* LOC can be NULL. */
RETURN_IF_FAIL_PRINTF1 (
- NULL == struct_type->get_fields (), ctxt, loc,
+ struct_type->get_fields () == NULL, ctxt, loc,
"%s already has had fields set",
struct_type->get_debug_string ());
if (num_fields)
struct_type->get_debug_string (),
i);
RETURN_IF_FAIL_PRINTF2 (
- NULL == fields[i]->get_container (),
+ fields[i]->get_container () == NULL,
ctxt, loc,
"%s is already a field of %s",
fields[i]->get_debug_string (),
{
RETURN_NULL_IF_FAIL (fields[i], ctxt, loc, "NULL field ptr");
RETURN_NULL_IF_FAIL_PRINTF2 (
- NULL == fields[i]->get_container (),
+ fields[i]->get_container () == NULL,
ctxt, loc,
"%s is already a field of %s",
fields[i]->get_debug_string (),
ctxt, loc,
"NULL parameter %i creating function %s", i, name);
RETURN_NULL_IF_FAIL_PRINTF5 (
- (NULL == params[i]->get_scope ()),
+ params[i]->get_scope () == NULL,
ctxt, loc,
"parameter %i \"%s\""
" (type: %s)"
item_name);
RETURN_IF_FAIL_PRINTF2
- (0 == strcmp (item_name, top_item_name), NULL, NULL,
+ (strcmp (item_name, top_item_name) == 0, NULL, NULL,
"mismatching item_name:"
" top of timing stack: \"%s\","
" attempting to pop: \"%s\"",
#define NEXT_PASS(PASS, NUM) \
do { \
- gcc_assert (NULL == PASS ## _ ## NUM); \
+ gcc_assert (PASS ## _ ## NUM == NULL); \
if ((NUM) == 1) \
PASS ## _1 = make_##PASS (m_ctxt); \
else \
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
- if (0 != b.coeffs[i])
+ if (b.coeffs[i] != 0)
return true;
return a != b.coeffs[0];
}
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
- if (0 < b.coeffs[i])
+ if (b.coeffs[i] > 0)
return true;
return a <= b.coeffs[0];
}
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
- if (0 < b.coeffs[i])
+ if (b.coeffs[i] > 0)
return true;
return a < b.coeffs[0];
}
m_sawclose = 0;
}
fputs (" [", m_outfile);
- if (NULL != XVEC (in_rtx, idx))
+ if (XVEC (in_rtx, idx) != NULL)
{
m_indent += 2;
if (XVECLEN (in_rtx, idx))
parse_note_insn_name (const char *string)
{
for (int i = 0; i < NOTE_INSN_MAX; i++)
- if (0 == strcmp (string, GET_NOTE_INSN_NAME (i)))
+ if (strcmp (string, GET_NOTE_INSN_NAME (i)) == 0)
return i;
fatal_with_file_and_line ("unrecognized NOTE_INSN name: `%s'", string);
}
"orig:%i", ORIGINAL_REGNO (rtx).
Consume it, we don't set ORIGINAL_REGNO, since we can
get that from the 2nd copy later. */
- if (0 == strncmp (desc, "orig:", 5))
+ if (strncmp (desc, "orig:", 5) == 0)
{
expect_original_regno = true;
desc_start += 5;
{
tree fndecl = cfun->decl;
- if (0 == strcmp (desc, "<retval>"))
+ if (strcmp (desc, "<retval>") == 0)
return DECL_RESULT (fndecl);
tree param = find_param_by_name (fndecl, desc);
parse_reg_note_name (const char *string)
{
for (int i = 0; i < REG_NOTE_MAX; i++)
- if (0 == strcmp (string, GET_REG_NOTE_NAME (i)))
+ if (strcmp (string, GET_REG_NOTE_NAME (i)) == 0)
return i;
fatal_with_file_and_line ("unrecognized REG_NOTE name: `%s'", string);
}
value for the incoming operand (same as outgoing one). */
if (rld[i].reg_rtx == out
&& (REG_P (in) || CONSTANT_P (in))
- && 0 != find_equiv_reg (in, this_insn, NO_REGS, REGNO (out),
- static_reload_reg_p, i, inmode))
+ && find_equiv_reg (in, this_insn, NO_REGS, REGNO (out),
+ static_reload_reg_p, i, inmode) != 0)
rld[i].in = out;
}
&& CONST_DOUBLE_AS_FLOAT_P (XEXP (tem, 0))
&& SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0)))
&& CONST_INT_P (goal)
- && 0 != (goaltry
- = operand_subword (XEXP (tem, 0), 0, 0,
- VOIDmode))
+ && (goaltry = operand_subword (XEXP (tem, 0), 0,
+ 0, VOIDmode)) != 0
&& rtx_equal_p (goal, goaltry)
&& (valtry
= operand_subword (SET_DEST (pat), 0, 0,
&& CONST_DOUBLE_AS_FLOAT_P (XEXP (tem, 0))
&& SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0)))
&& CONST_INT_P (goal)
- && 0 != (goaltry = operand_subword (XEXP (tem, 0), 1, 0,
- VOIDmode))
+ && (goaltry = operand_subword (XEXP (tem, 0), 1, 0,
+ VOIDmode)) != 0
&& rtx_equal_p (goal, goaltry)
&& (valtry
= operand_subword (SET_DEST (pat), 1, 0, VOIDmode))
/* Likewise for a SUBREG of an operand that dies. */
else if (GET_CODE (old) == SUBREG
&& REG_P (SUBREG_REG (old))
- && 0 != (note = find_reg_note (insn, REG_UNUSED,
- SUBREG_REG (old))))
+ && (note = find_reg_note (insn, REG_UNUSED,
+ SUBREG_REG (old))) != 0)
{
XEXP (note, 0) = gen_lowpart_common (GET_MODE (old), reg_rtx);
return;
&& (other = prev_active_insn (insn)) != 0
&& any_condjump_p (other)
&& no_labels_between_p (other, insn)
- && 0 > mostly_true_jump (other))
+ && mostly_true_jump (other) < 0)
{
rtx other_target = JUMP_LABEL (other);
target_label = JUMP_LABEL (insn);
free_dominance_info (CDI_DOMINATORS);
}
- gcc_assert (0 < nr_regions && nr_regions <= n_basic_blocks_for_fn (cfun));
+ gcc_assert (nr_regions > 0 && nr_regions <= n_basic_blocks_for_fn (cfun));
- RGN_BLOCKS (nr_regions) = (RGN_BLOCKS (nr_regions - 1) +
- RGN_NR_BLOCKS (nr_regions - 1));
+ RGN_BLOCKS (nr_regions) = (RGN_BLOCKS (nr_regions - 1)
+ + RGN_NR_BLOCKS (nr_regions - 1));
nr_regions_initial = nr_regions;
}
{
int seqno = INSN_SEQNO (succ);
- if (0 < seqno && seqno <= orig_max_seqno
+ if (seqno > 0 && seqno <= orig_max_seqno
&& (pipelining_p || INSN_SCHED_TIMES (succ) <= 0))
{
bool b = (in_same_ebb_p (insn, succ)
if (val_actual == NULL)
fail_formatted (loc, "ASSERT_STREQ (%s, %s) expected=\"%s\" actual=NULL",
desc_expected, desc_actual, val_expected);
- if (0 == strcmp (val_expected, val_actual))
+ if (strcmp (val_expected, val_actual) == 0)
pass (loc, "ASSERT_STREQ");
else
fail_formatted (loc, "ASSERT_STREQ (%s, %s) expected=\"%s\" actual=\"%s\"",
rtx tem;
/* If this simplifies, use it. */
- if (0 != (tem = simplify_ternary_operation (code, mode, op0_mode,
- op0, op1, op2)))
+ if ((tem = simplify_ternary_operation (code, mode, op0_mode,
+ op0, op1, op2)) != 0)
return tem;
return gen_rtx_fmt_eee (code, mode, op0, op1, op2);
{
rtx tem;
- if (0 != (tem = simplify_relational_operation (code, mode, cmp_mode,
- op0, op1)))
+ if ((tem = simplify_relational_operation (code, mode, cmp_mode,
+ op0, op1)) != 0)
return tem;
return gen_rtx_fmt_ee (code, mode, op0, op1);
&& (code == EQ || code == NE)
&& ! ((REG_P (op0) || CONST_INT_P (trueop0))
&& (REG_P (op1) || CONST_INT_P (trueop1)))
- && 0 != (tem = simplify_binary_operation (MINUS, mode, op0, op1))
+ && (tem = simplify_binary_operation (MINUS, mode, op0, op1)) != 0
/* We cannot do this if tem is a nonzero address. */
&& ! nonzero_address_p (tem))
return simplify_const_relational_operation (signed_condition (code),
conflict_function *ret = XCNEW (conflict_function);
va_list ap;
- gcc_assert (0 < n && n <= MAX_DIM);
+ gcc_assert (n > 0 && n <= MAX_DIM);
va_start (ap, n);
ret->n = n;
projects / gcc.git / commitdiff