#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);