{
poly_int64 size = -1;
- if (type && TREE_CODE (type) == VECTOR_TYPE)
+ if (type && VECTOR_TYPE_P (type))
{
if (aarch64_sve::builtin_type_p (type))
return false;
return "St9__va_list";
/* Half-precision floating point types. */
- if (TREE_CODE (type) == REAL_TYPE && TYPE_PRECISION (type) == 16)
+ if (SCALAR_FLOAT_TYPE_P (type) && TYPE_PRECISION (type) == 16)
{
if (TYPE_MAIN_VARIANT (type) == float16_type_node)
return NULL;
return false;
/* COMMON symbols are never small data. */
- if (TREE_CODE (exp) == VAR_DECL && DECL_COMMON (exp))
+ if (VAR_P (exp) && DECL_COMMON (exp))
return false;
- if (TREE_CODE (exp) == VAR_DECL && DECL_SECTION_NAME (exp))
+ if (VAR_P (exp) && DECL_SECTION_NAME (exp))
{
const char *section = DECL_SECTION_NAME (exp);
if (strcmp (section, ".sdata") == 0
return build2 (COMPLEX_EXPR, type, real_temp, imag_part);
}
- else if (TREE_CODE (type) == REAL_TYPE)
+ else if (SCALAR_FLOAT_TYPE_P (type))
{
tree fpaddend, cond, fourtyeight;
SYMBOL_REF_FLAGS (symbol) = flags;
}
- else if (TREE_CODE (decl) == VAR_DECL)
+ else if (VAR_P (decl))
{
rtx symbol = XEXP (rtl, 0);
return false;
/* Get the attributes. */
- if (TREE_CODE (addr) == VAR_DECL)
+ if (VAR_P (addr))
attrs = DECL_ATTRIBUTES (addr);
else if (TREE_CODE (addr) == MEM_REF)
attrs = TYPE_ATTRIBUTES (TREE_TYPE (TREE_OPERAND (addr, 0)));
/* Get the attributes. */
if (TREE_CODE (addr) == MEM_REF
- || TREE_CODE (addr) == VAR_DECL)
+ || VAR_P (addr))
{
attrs = TYPE_ATTRIBUTES (TREE_TYPE (addr));
if (lookup_attribute ("uncached", attrs))
/* FIXME! add range check. TREE_INT_CST_LOW (arg) */
}
- if (TREE_CODE (*node) == VAR_DECL)
+ if (VAR_P (*node))
{
tree fntype = TREE_TYPE (*node);
if (fntype && TREE_CODE (fntype) == POINTER_TYPE)
}
else
{
- if (TREE_CODE (*node) == FUNCTION_TYPE
- || TREE_CODE (*node) == METHOD_TYPE)
+ if (FUNC_OR_METHOD_TYPE_P (*node))
{
if (arm_isr_value (args) == ARM_FT_UNKNOWN)
{
}
}
else if (TREE_CODE (*node) == POINTER_TYPE
- && (TREE_CODE (TREE_TYPE (*node)) == FUNCTION_TYPE
- || TREE_CODE (TREE_TYPE (*node)) == METHOD_TYPE)
+ && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (*node))
&& arm_isr_value (args) != ARM_FT_UNKNOWN)
{
*node = build_variant_type_copy (*node);
{
fntype = TREE_TYPE (*node);
- if (TREE_CODE (*node) == VAR_DECL || TREE_CODE (*node) == TYPE_DECL)
+ if (VAR_P (*node) || TREE_CODE (*node) == TYPE_DECL)
decl = *node;
}
else
/* Add __attribute__ ((long_call)) to all functions, when
inside #pragma long_calls or __attribute__ ((short_call)),
when inside #pragma no_long_calls. */
- if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
+ if (FUNC_OR_METHOD_TYPE_P (type))
{
tree type_attr_list, attr_name;
type_attr_list = TYPE_ATTRIBUTES (type);
|| !DECL_COMMON (SYMBOL_REF_DECL (orig))))
{
tree decl = SYMBOL_REF_DECL (orig);
- tree init = (TREE_CODE (decl) == VAR_DECL)
+ tree init = VAR_P (decl)
? DECL_INITIAL (decl) : (TREE_CODE (decl) == CONSTRUCTOR)
? decl : 0;
int reloc = 0;
if (init && init != error_mark_node)
reloc = compute_reloc_for_constant (init);
- named_section = TREE_CODE (decl) == VAR_DECL
+ named_section = VAR_P (decl)
&& lookup_attribute ("section", DECL_ATTRIBUTES (decl));
readonly = decl_readonly_section (decl, reloc);
return "St9__va_list";
/* Half-precision floating point types. */
- if (TREE_CODE (type) == REAL_TYPE && TYPE_PRECISION (type) == 16)
+ if (SCALAR_FLOAT_TYPE_P (type) && TYPE_PRECISION (type) == 16)
{
if (TYPE_MAIN_VARIANT (type) == float16_type_node)
return NULL;
/* Return a nonzero value if DECL has a section attribute. */
#define IN_NAMED_SECTION_P(DECL) \
- ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
+ ((TREE_CODE (DECL) == FUNCTION_DECL || VAR_P (DECL)) \
&& DECL_SECTION_NAME (DECL) != NULL)
#undef ASM_OUTPUT_ALIGNED_BSS
func = TREE_TYPE (func);
}
- gcc_assert (TREE_CODE (func) == FUNCTION_TYPE
- || TREE_CODE (func) == METHOD_TYPE);
+ gcc_assert (FUNC_OR_METHOD_TYPE_P (func));
return NULL_TREE != lookup_attribute (name, TYPE_ATTRIBUTES (func));
}
static bool
avr_decl_absdata_p (tree decl, tree attributes)
{
- return (TREE_CODE (decl) == VAR_DECL
+ return (VAR_P (decl)
&& NULL_TREE != lookup_attribute ("absdata", attributes));
}
/* Add the section attribute if the variable is in progmem. */
- if (TREE_CODE (node) == VAR_DECL
+ if (VAR_P (node)
&& (TREE_STATIC (node) || DECL_EXTERNAL (node))
&& avr_progmem_p (node, *attributes))
{
if (startswith (name, ".noinit"))
{
- if (decl && TREE_CODE (decl) == VAR_DECL
+ if (decl && VAR_P (decl)
&& DECL_INITIAL (decl) == NULL_TREE)
flags |= SECTION_BSS; /* @nobits */
else
if (AVR_TINY
&& decl
- && VAR_DECL == TREE_CODE (decl)
+ && VAR_P (decl)
&& MEM_P (rtl)
&& SYMBOL_REF_P (XEXP (rtl, 0)))
{
else
set_decl_section_name (decl, ".l2.text");
}
- else if (TREE_CODE (decl) == VAR_DECL)
+ else if (VAR_P (decl))
{
if (DECL_SECTION_NAME (decl) != NULL
&& strcmp (DECL_SECTION_NAME (decl),
if (TREE_CODE (node) == ADDR_EXPR)
node = TREE_OPERAND (node, 0);
- else if (TREE_CODE (node) == INDIRECT_REF
+ else if (INDIRECT_REF_P (node)
|| TREE_CODE (node) == POINTER_PLUS_EXPR)
{
accessors->safe_push (0);
if (TREE_CODE (exp) == FUNCTION_DECL)
return false;
- if (TREE_CODE (exp) == VAR_DECL && DECL_WEAK (exp))
+ if (VAR_P (exp) && DECL_WEAK (exp))
return false;
- if (TREE_CODE (exp) == VAR_DECL && DECL_SECTION_NAME (exp))
+ if (VAR_P (exp) && DECL_SECTION_NAME (exp))
{
const char *section = DECL_SECTION_NAME (exp);
}
else
{
- if (TREE_CODE (*node) == FUNCTION_TYPE
- || TREE_CODE (*node) == METHOD_TYPE)
+ if (FUNC_OR_METHOD_TYPE_P (*node))
{
if (csky_isr_value (args) == CSKY_FT_UNKNOWN)
{
}
}
else if (TREE_CODE (*node) == POINTER_TYPE
- && (TREE_CODE (TREE_TYPE (*node)) == FUNCTION_TYPE
- || TREE_CODE (TREE_TYPE (*node)) == METHOD_TYPE)
+ && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (*node))
&& csky_isr_value (args) != CSKY_FT_UNKNOWN)
{
*node = build_variant_type_copy (*node);
static const char *
csky_mangle_type (const_tree type)
{
- if (TREE_CODE (type) == REAL_TYPE
+ if (SCALAR_FLOAT_TYPE_P (type)
&& TYPE_PRECISION (type) == 16
&& TYPE_MAIN_VARIANT (type) != float16_type_node)
return "Dh";
{
tree local = lookup_name (decl);
if (local && (TREE_CODE (local) == PARM_DECL
- || TREE_CODE (local) == VAR_DECL))
+ || VAR_P (local)))
{
TREE_USED (local) = 1;
DECL_READ_P (local) = 1;
is_objc_metadata (tree decl)
{
if (DECL_P (decl)
- && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == CONST_DECL)
+ && (VAR_P (decl) || TREE_CODE (decl) == CONST_DECL)
&& DECL_ATTRIBUTES (decl))
{
tree meta = lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl));
gcc_assert (POINTER_TYPE_P (fn_type));
fn_type = TREE_TYPE (fn_type);
- gcc_assert (TREE_CODE (fn_type) == FUNCTION_TYPE
- || TREE_CODE (fn_type) == METHOD_TYPE);
+ gcc_assert (FUNC_OR_METHOD_TYPE_P (fn_type));
call_interrupt_p
= lookup_attribute ("interrupt", TYPE_ATTRIBUTES (fn_type)) != NULL;
}
/* layout_type overrides our ADJUST_ALIGNMENT settings from epiphany-modes.def
for vector modes, so we have to override it back. */
#define ROUND_TYPE_ALIGN(TYPE, MANGLED_ALIGN, SPECIFIED_ALIGN) \
- (TREE_CODE (TYPE) == VECTOR_TYPE && !TYPE_USER_ALIGN (TYPE) \
+ (VECTOR_TYPE_P (TYPE) && !TYPE_USER_ALIGN (TYPE) \
&& SPECIFIED_ALIGN <= GET_MODE_ALIGNMENT (TYPE_MODE (TYPE)) \
? GET_MODE_ALIGNMENT (TYPE_MODE (TYPE)) \
- : ((TREE_CODE (TYPE) == RECORD_TYPE \
- || TREE_CODE (TYPE) == UNION_TYPE \
- || TREE_CODE (TYPE) == QUAL_UNION_TYPE) \
+ : (RECORD_OR_UNION_TYPE_P (TYPE) \
&& !TYPE_PACKED (TYPE)) \
? epiphany_special_round_type_align ((TYPE), (MANGLED_ALIGN), \
(SPECIFIED_ALIGN)) \
|| !DECL_COMMON (SYMBOL_REF_DECL (sym))))
{
tree decl = SYMBOL_REF_DECL (sym);
- tree init = TREE_CODE (decl) == VAR_DECL
+ tree init = VAR_P (decl)
? DECL_INITIAL (decl)
: TREE_CODE (decl) == CONSTRUCTOR
? decl : 0;
if (init && init != error_mark_node)
reloc = compute_reloc_for_constant (init);
- named_section = TREE_CODE (decl) == VAR_DECL
+ named_section = VAR_P (decl)
&& lookup_attribute ("section", DECL_ATTRIBUTES (decl));
readonly = decl_readonly_section (decl, reloc);
tree var_type = TREE_TYPE (var);
if (TREE_CODE (var_type) == COMPLEX_TYPE
- || TREE_CODE (var_type) == REAL_TYPE)
+ || SCALAR_FLOAT_TYPE_P (var_type))
code = VIEW_CONVERT_EXPR;
if (TYPE_SIZE (var_type) == TYPE_SIZE (long_long_unsigned_type_node))
tree decl;
if (cfun
&& (decl = SYMBOL_REF_DECL (x)) != 0
- && TREE_CODE (decl) == VAR_DECL
+ && VAR_P (decl)
&& AS_LDS_P (TYPE_ADDR_SPACE (TREE_TYPE (decl))))
{
/* LDS symbols (emitted using this hook) are only used at present
/* FIXME: See above -- this condition is unreachable. */
if (cfun
&& (decl = SYMBOL_REF_DECL (x)) != 0
- && TREE_CODE (decl) == VAR_DECL
+ && VAR_P (decl)
&& AS_LDS_P (TYPE_ADDR_SPACE (TREE_TYPE (decl))))
fputs ("@abs32", file);
}
if (TREE_CODE (decl) == FUNCTION_DECL
&& h8300_funcvec_function_p (decl))
extra_flags = SYMBOL_FLAG_FUNCVEC_FUNCTION;
- else if (TREE_CODE (decl) == VAR_DECL
+ else if (VAR_P (decl)
&& (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
{
if (h8300_eightbit_data_p (decl))
op0 = pc_rtx;
}
else if (TREE_CODE (arg3) == SSA_NAME
- && TREE_CODE (TREE_TYPE (arg3)) == VECTOR_TYPE)
+ && VECTOR_TYPE_P (TREE_TYPE (arg3)))
{
/* Recognize also when mask is like:
__v2df src = _mm_setzero_pd ();
{
machine_mode mode = TYPE_MODE (type);
- if (TREE_CODE (type) == VECTOR_TYPE && !VECTOR_MODE_P (mode))
+ if (VECTOR_TYPE_P (type) && !VECTOR_MODE_P (mode))
{
HOST_WIDE_INT size = int_size_in_bytes (type);
if ((size == 8 || size == 16 || size == 32 || size == 64)
if (DECIMAL_FLOAT_MODE_P (innermode))
return mode;
- if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
+ if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (type)))
mode = MIN_MODE_VECTOR_FLOAT;
else
mode = MIN_MODE_VECTOR_INT;
/* To simplify the code below, represent vector types with a vector mode
even if MMX/SSE are not active. */
- if (arg.type && TREE_CODE (arg.type) == VECTOR_TYPE)
+ if (arg.type && VECTOR_TYPE_P (arg.type))
mode = type_natural_mode (arg.type, cum, false);
if (TARGET_64BIT)
|| TYPE_MODE (type) == TCmode) && align < 128)
return 128;
}
- else if ((TREE_CODE (type) == RECORD_TYPE
- || TREE_CODE (type) == UNION_TYPE
- || TREE_CODE (type) == QUAL_UNION_TYPE)
+ else if (RECORD_OR_UNION_TYPE_P (type)
&& TYPE_FIELDS (type))
{
if (DECL_MODE (TYPE_FIELDS (type)) == DFmode && align < 64)
if (ALIGN_MODE_128 (DECL_MODE (TYPE_FIELDS (type))) && align < 128)
return 128;
}
- else if (TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == VECTOR_TYPE
+ else if (SCALAR_FLOAT_TYPE_P (type) || VECTOR_TYPE_P (type)
|| TREE_CODE (type) == INTEGER_TYPE)
{
if (TYPE_MODE (type) == DFmode && align < 64)
|| TYPE_MODE (type) == TCmode) && align < 128)
return 128;
}
- else if ((TREE_CODE (type) == RECORD_TYPE
- || TREE_CODE (type) == UNION_TYPE
- || TREE_CODE (type) == QUAL_UNION_TYPE)
+ else if (RECORD_OR_UNION_TYPE_P (type)
&& TYPE_FIELDS (type))
{
if (DECL_MODE (TYPE_FIELDS (type)) == DFmode && align < 64)
if (ALIGN_MODE_128 (DECL_MODE (TYPE_FIELDS (type))) && align < 128)
return 128;
}
- else if (TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == VECTOR_TYPE
+ else if (SCALAR_FLOAT_TYPE_P (type) || VECTOR_TYPE_P (type)
|| TREE_CODE (type) == INTEGER_TYPE)
{
for 64-bit code), accept that SIMDLEN, otherwise warn and don't
emit corresponding clone. */
tree ctype = ret_type;
- if (TREE_CODE (ret_type) == VOID_TYPE)
+ if (VOID_TYPE_P (ret_type))
ctype = base_type;
int cnt = GET_MODE_BITSIZE (TYPE_MODE (ctype)) * clonei->simdlen;
if (SCALAR_INT_MODE_P (TYPE_MODE (ctype)))
bool
i386_pe_type_dllimport_p (tree decl)
{
- gcc_assert (TREE_CODE (decl) == VAR_DECL
+ gcc_assert (VAR_P (decl)
|| TREE_CODE (decl) == FUNCTION_DECL);
if (TARGET_NOP_FUN_DLLIMPORT && TREE_CODE (decl) == FUNCTION_DECL)
bool
i386_pe_type_dllexport_p (tree decl)
{
- gcc_assert (TREE_CODE (decl) == VAR_DECL
+ gcc_assert (VAR_P (decl)
|| TREE_CODE (decl) == FUNCTION_DECL);
/* Avoid exporting compiler-generated default dtors and copy ctors.
/* Check FUNCTION_DECL's and static VAR_DECL's. */
for (member = TYPE_FIELDS (t); member; member = DECL_CHAIN (member))
- if (TREE_CODE (member) == VAR_DECL)
+ if (VAR_P (member))
maybe_add_dllexport (member);
else if (TREE_CODE (member) == FUNCTION_DECL)
{
/* Check vtables */
for (member = CLASSTYPE_VTABLES (t);
member; member = DECL_CHAIN (member))
- if (TREE_CODE (member) == VAR_DECL)
+ if (VAR_P (member))
maybe_add_dllexport (member);
}
/* Check FUNCTION_DECL's and static VAR_DECL's. */
for (member = TYPE_FIELDS (t); member; member = DECL_CHAIN (member))
- if (TREE_CODE (member) == VAR_DECL)
+ if (VAR_P (member))
maybe_add_dllimport (member);
else if (TREE_CODE (member) == FUNCTION_DECL)
{
/* Check vtables */
for (member = CLASSTYPE_VTABLES (t);
member; member = DECL_CHAIN (member))
- if (TREE_CODE (member) == VAR_DECL)
+ if (VAR_P (member))
maybe_add_dllimport (member);
/* We leave typeinfo tables alone. We can't mark TI objects as
out-of-class definition of static data. */
assoc = associated_type (decl);
if (assoc && lookup_attribute ("dllimport", TYPE_ATTRIBUTES (assoc))
- && TREE_CODE (decl) == VAR_DECL
+ && VAR_P (decl)
&& TREE_STATIC (decl) && TREE_PUBLIC (decl)
&& !DECL_EXTERNAL (decl)
/* vtable's are linkonce constants, so defining a vtable is not
bool
i386_pe_binds_local_p (const_tree exp)
{
- if ((TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == FUNCTION_DECL)
+ if ((VAR_P (exp) || TREE_CODE (exp) == FUNCTION_DECL)
&& DECL_DLLIMPORT_P (exp))
return false;
{
flags = SECTION_WRITE;
- if (decl && TREE_CODE (decl) == VAR_DECL
+ if (decl && VAR_P (decl)
&& lookup_attribute ("shared", DECL_ATTRIBUTES (decl)))
flags |= SECTION_PE_SHARED;
}
default_encode_section_info (decl, rtl, first);
/* Careful not to prod global register variables. */
- if (TREE_CODE (decl) == VAR_DECL
+ if (VAR_P (decl)
&& GET_CODE (DECL_RTL (decl)) == MEM
&& GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF
&& (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
the next even boundary. Integer and floating point arguments
do so if they are larger than 8 bytes, whether or not they are
also aligned larger than 8 bytes. */
- if ((TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == INTEGER_TYPE)
+ if ((SCALAR_FLOAT_TYPE_P (type) || TREE_CODE (type) == INTEGER_TYPE)
? int_size_in_bytes (type) > 8 : TYPE_ALIGN (type) > 8 * BITS_PER_UNIT)
{
tree t = fold_build_pointer_plus_hwi (valist, 2 * UNITS_PER_WORD - 1);
if (TREE_CODE (exp) == FUNCTION_DECL)
return false;
- if (TREE_CODE (exp) == VAR_DECL && DECL_SECTION_NAME (exp))
+ if (VAR_P (exp) && DECL_SECTION_NAME (exp))
{
const char *section = DECL_SECTION_NAME (exp);
int bias = 0;
unsigned int *arg_words = &cum->arg_words;
int struct_p = (type != 0
- && (TREE_CODE (type) == RECORD_TYPE
- || TREE_CODE (type) == UNION_TYPE
- || TREE_CODE (type) == QUAL_UNION_TYPE));
+ && RECORD_OR_UNION_TYPE_P (type));
if (TARGET_DEBUG_D_MODE)
{
for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
if (TREE_CODE (field) == FIELD_DECL
- && TREE_CODE (TREE_TYPE (field)) == REAL_TYPE
+ && SCALAR_FLOAT_TYPE_P (TREE_TYPE (field))
&& TYPE_PRECISION (TREE_TYPE (field)) == BITS_PER_WORD
&& tree_fits_shwi_p (bit_position (field))
&& int_bit_position (field) % BITS_PER_WORD == 0)
if (field
&& int_bit_position (field) == bitpos
- && TREE_CODE (TREE_TYPE (field)) == REAL_TYPE
+ && SCALAR_FLOAT_TYPE_P (TREE_TYPE (field))
&& TYPE_PRECISION (TREE_TYPE (field)) == BITS_PER_WORD)
reg = gen_rtx_REG (DFmode, regno++);
else
if (TREE_CODE (exp) == FUNCTION_DECL)
return false;
- if (TREE_CODE (exp) == VAR_DECL && DECL_SECTION_NAME (exp))
+ if (VAR_P (exp) && DECL_SECTION_NAME (exp))
{
const char *section = DECL_SECTION_NAME (exp);
if (strcmp (section, ".sdata") == 0 || strcmp (section, ".sbss") == 0)
bool *no_add_attrs)
{
tree decl = *node;
- if (TREE_CODE (decl) == VAR_DECL)
+ if (VAR_P (decl))
{
if (DECL_THREAD_LOCAL_P (decl))
{
unsigned addr;
/* See if we need to make #pragma address variables volatile. */
- if (TREE_CODE (node) == VAR_DECL)
+ if (VAR_P (node))
{
const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
if (m32c_get_pragma_address (name, &addr))
and that would be a good question. */
/* Imported variables can't be initialized. */
- if (TREE_CODE (decl) == VAR_DECL
+ if (VAR_P (decl)
&& !DECL_VIRTUAL_P (decl)
&& DECL_INITIAL (decl))
{
/* `extern' needn't be specified with dllimport.
Specify `extern' now and hope for the best. Sigh. */
- if (TREE_CODE (decl) == VAR_DECL
+ if (VAR_P (decl)
/* ??? Is this test for vtables needed? */
&& !DECL_VIRTUAL_P (decl))
{
a subsequent definition nullified that. The attribute is gone
but DECL_RTL still has @i.__imp_foo. We need to remove that. */
else if ((TREE_CODE (decl) == FUNCTION_DECL
- || TREE_CODE (decl) == VAR_DECL)
+ || VAR_P (decl))
&& DECL_RTL (decl) != NULL_RTX
&& GET_CODE (DECL_RTL (decl)) == MEM
&& GET_CODE (XEXP (DECL_RTL (decl), 0)) == MEM
if (TREE_CODE (decl) == FUNCTION_DECL)
return false;
- if (TREE_CODE (decl) == VAR_DECL && DECL_SECTION_NAME (decl))
+ if (VAR_P (decl) && DECL_SECTION_NAME (decl))
{
const char *section = DECL_SECTION_NAME (decl);
if (strcmp (section, ".sdata") == 0
.rdata then don't put them in .comm. */
if (TARGET_EMBEDDED_DATA
&& TARGET_UNINIT_CONST_IN_RODATA
- && TREE_CODE (decl) == VAR_DECL
+ && VAR_P (decl)
&& TREE_READONLY (decl)
&& (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
{
mmix_encode_section_info (tree decl, rtx rtl, int first)
{
/* Test for an external declaration, and do nothing if it is one. */
- if ((TREE_CODE (decl) == VAR_DECL
+ if ((VAR_P (decl)
&& (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl)))
|| (TREE_CODE (decl) == FUNCTION_DECL && TREE_PUBLIC (decl)))
;
For now, functions and things we know or have been told are constant. */
if (TREE_CODE (decl) == FUNCTION_DECL
|| TREE_CONSTANT (decl)
- || (TREE_CODE (decl) == VAR_DECL
+ || (VAR_P (decl)
&& TREE_READONLY (decl)
&& !TREE_SIDE_EFFECTS (decl)
&& (!DECL_INITIAL (decl)
if (TREE_CONSTANT (decl))
area = DATA_AREA_CONST;
- else if (TREE_CODE (decl) == VAR_DECL)
+ else if (VAR_P (decl))
{
if (lookup_attribute ("shared", DECL_ATTRIBUTES (decl)))
{
{
if (AGGREGATE_TYPE_P (type))
return true;
- if (TREE_CODE (type) == VECTOR_TYPE)
+ if (VECTOR_TYPE_P (type))
return true;
}
if (TREE_CODE (var_type) == COMPLEX_TYPE)
var_type = TREE_TYPE (var_type);
- if (TREE_CODE (var_type) == REAL_TYPE)
+ if (SCALAR_FLOAT_TYPE_P (var_type))
code = VIEW_CONVERT_EXPR;
if (TYPE_SIZE (var_type)
tree var_type = TREE_TYPE (var);
if (TREE_CODE (var_type) == COMPLEX_TYPE
- || TREE_CODE (var_type) == REAL_TYPE)
+ || SCALAR_FLOAT_TYPE_P (var_type))
code = VIEW_CONVERT_EXPR;
if (TYPE_SIZE (var_type) == TYPE_SIZE (long_long_unsigned_type_node))
&& type
&& (AGGREGATE_TYPE_P (type)
|| TREE_CODE (type) == COMPLEX_TYPE
- || TREE_CODE (type) == VECTOR_TYPE)))
+ || VECTOR_TYPE_P (type))))
{
/* Return PAD_NONE if justification is not required. */
if (type
if (AGGREGATE_TYPE_P (valtype)
|| TREE_CODE (valtype) == COMPLEX_TYPE
- || TREE_CODE (valtype) == VECTOR_TYPE)
+ || VECTOR_TYPE_P (valtype))
{
HOST_WIDE_INT valsize = int_size_in_bytes (valtype);
else
valmode = TYPE_MODE (valtype);
- if (TREE_CODE (valtype) == REAL_TYPE
+ if (SCALAR_FLOAT_TYPE_P (valtype)
&& !AGGREGATE_TYPE_P (valtype)
&& TYPE_MODE (valtype) != TFmode
&& !TARGET_SOFT_FLOAT)
|| mode == BLKmode
|| (type && (AGGREGATE_TYPE_P (type)
|| TREE_CODE (type) == COMPLEX_TYPE
- || TREE_CODE (type) == VECTOR_TYPE)))
+ || VECTOR_TYPE_P (type))))
{
/* Double-extended precision (80-bit), quad-precision (128-bit)
and aggregates including complex numbers are aligned on
if (mode == BLKmode
|| (type && (AGGREGATE_TYPE_P (type)
|| TREE_CODE (type) == COMPLEX_TYPE
- || TREE_CODE (type) == VECTOR_TYPE)))
+ || VECTOR_TYPE_P (type))))
{
rtx loc = gen_rtx_EXPR_LIST (VOIDmode,
gen_rtx_REG (DImode, gpr_reg_base),
/* Return a nonzero value if DECL has a section attribute. */
#define IN_NAMED_SECTION_P(DECL) \
- ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
+ ((TREE_CODE (DECL) == FUNCTION_DECL || VAR_P (DECL)) \
&& DECL_SECTION_NAME (DECL) != NULL)
/* Define this macro if references to a symbol must be treated
#define TEXT_SPACE_P(DECL)\
(TREE_CODE (DECL) == FUNCTION_DECL \
- || (TREE_CODE (DECL) == VAR_DECL \
+ || (VAR_P (DECL) \
&& TREE_READONLY (DECL) && ! TREE_SIDE_EFFECTS (DECL) \
&& (! DECL_INITIAL (DECL) || ! pa_reloc_needed (DECL_INITIAL (DECL))) \
&& !flag_pic) \
initialized variables and functions. */
#define MAKE_DECL_ONE_ONLY(DECL) \
do { \
- if (TREE_CODE (DECL) == VAR_DECL \
+ if (VAR_P (DECL) \
&& (DECL_INITIAL (DECL) == 0 \
|| DECL_INITIAL (DECL) == error_mark_node)) \
DECL_COMMON (DECL) = 1; \
in registers. The rest go into memory. */
return (TYPE_MODE (type) == DImode
|| (FLOAT_MODE_P (TYPE_MODE (type)) && ! TARGET_AC0)
- || TREE_CODE (type) == VECTOR_TYPE
+ || VECTOR_TYPE_P (type)
|| COMPLEX_MODE_P (TYPE_MODE (type)));
}
if (TREE_CODE (x) == STRING_CST || TREE_CODE (x) == FUNCTION_DECL)
return false;
- if (TREE_CODE (x) == VAR_DECL && DECL_SECTION_NAME (x))
+ if (VAR_P (x) && DECL_SECTION_NAME (x))
{
const char *sec = DECL_SECTION_NAME (x);
return strcmp (sec, ".sdata") == 0 || strcmp (sec, ".sbss") == 0;
riscv_mangle_type (const_tree type)
{
/* Half-precision float, _Float16 is "DF16_". */
- if (TREE_CODE (type) == REAL_TYPE && TYPE_PRECISION (type) == 16)
+ if (SCALAR_FLOAT_TYPE_P (type) && TYPE_PRECISION (type) == 16)
return "DF16_";
/* Mangle all vector type for vector extension. */
rl78_insert_attributes (tree decl, tree *attributes ATTRIBUTE_UNUSED)
{
if (TARGET_ES0
- && TREE_CODE (decl) == VAR_DECL
+ && VAR_P (decl)
&& TREE_READONLY (decl)
&& TREE_ADDRESSABLE (decl)
&& TYPE_ADDR_SPACE (TREE_TYPE (decl)) == ADDR_SPACE_GENERIC)
this address. So we can skip adding in the high bytes. */
if (TARGET_ES0
&& GET_CODE (operands[2]) == SYMBOL_REF
- && TREE_CODE (SYMBOL_REF_DECL (operands[2])) == VAR_DECL
+ && VAR_P (SYMBOL_REF_DECL (operands[2]))
&& TREE_READONLY (SYMBOL_REF_DECL (operands[2]))
&& ! TREE_SIDE_EFFECTS (SYMBOL_REF_DECL (operands[2])))
return "movw ax, %h1\n\taddw ax, %h2\n\tmovw %h0, ax";
/* AIX increases natural record alignment to doubleword if the first
field is an FP double while the FP fields remain word aligned. */
#define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED) \
- ((TREE_CODE (STRUCT) == RECORD_TYPE \
- || TREE_CODE (STRUCT) == UNION_TYPE \
- || TREE_CODE (STRUCT) == QUAL_UNION_TYPE) \
+ (RECORD_OR_UNION_TYPE_P (STRUCT) \
&& TARGET_ALIGN_NATURAL == 0 \
? rs6000_special_round_type_align (STRUCT, COMPUTED, SPECIFIED) \
: MAX ((COMPUTED), (SPECIFIED)))
/* Darwin increases natural record alignment to doubleword if the first
field is an FP double while the FP fields remain word aligned. */
#define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED) \
- ((TREE_CODE (STRUCT) == RECORD_TYPE \
- || TREE_CODE (STRUCT) == UNION_TYPE \
- || TREE_CODE (STRUCT) == QUAL_UNION_TYPE) \
+ (RECORD_OR_UNION_TYPE_P (STRUCT) \
&& TARGET_ALIGN_NATURAL == 0 \
? darwin_rs6000_special_round_type_align (STRUCT, COMPUTED, SPECIFIED) \
- : (TREE_CODE (STRUCT) == VECTOR_TYPE \
+ : (VECTOR_TYPE_P (STRUCT) \
&& ALTIVEC_VECTOR_MODE (TYPE_MODE (STRUCT))) \
? MAX (MAX ((COMPUTED), (SPECIFIED)), 128) \
: MAX ((COMPUTED), (SPECIFIED)))
#undef ROUND_TYPE_ALIGN
#define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED) \
((TARGET_64BIT \
- && (TREE_CODE (STRUCT) == RECORD_TYPE \
- || TREE_CODE (STRUCT) == UNION_TYPE \
- || TREE_CODE (STRUCT) == QUAL_UNION_TYPE) \
+ && RECORD_OR_UNION_TYPE_P (STRUCT) \
&& TARGET_ALIGN_NATURAL == 0) \
? rs6000_special_round_type_align (STRUCT, COMPUTED, SPECIFIED) \
: MAX ((COMPUTED), (SPECIFIED)))
#undef ROUND_TYPE_ALIGN
#define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED) \
((TARGET_64BIT \
- && (TREE_CODE (STRUCT) == RECORD_TYPE \
- || TREE_CODE (STRUCT) == UNION_TYPE \
- || TREE_CODE (STRUCT) == QUAL_UNION_TYPE) \
+ && RECORD_OR_UNION_TYPE_P (STRUCT) \
&& TARGET_ALIGN_NATURAL == 0) \
? rs6000_special_round_type_align (STRUCT, COMPUTED, SPECIFIED) \
: MAX ((COMPUTED), (SPECIFIED)))
return 64;
else if (FLOAT128_VECTOR_P (mode))
return 128;
- else if (type && TREE_CODE (type) == VECTOR_TYPE
+ else if (type && VECTOR_TYPE_P (type)
&& int_size_in_bytes (type) >= 8
&& int_size_in_bytes (type) < 16)
return 64;
else if (ALTIVEC_OR_VSX_VECTOR_MODE (elt_mode)
- || (type && TREE_CODE (type) == VECTOR_TYPE
+ || (type && VECTOR_TYPE_P (type)
&& int_size_in_bytes (type) >= 16))
return 128;
if (TARGET_ALTIVEC_ABI
&& (ALTIVEC_OR_VSX_VECTOR_MODE (elt_mode)
- || (type && TREE_CODE (type) == VECTOR_TYPE
+ || (type && VECTOR_TYPE_P (type)
&& int_size_in_bytes (type) == 16)))
{
bool stack = false;
}
else if (TARGET_ALTIVEC_ABI
&& (ALTIVEC_OR_VSX_VECTOR_MODE (mode)
- || (type && TREE_CODE (type) == VECTOR_TYPE
+ || (type && VECTOR_TYPE_P (type)
&& int_size_in_bytes (type) == 16)))
{
if (named || abi == ABI_V4)
}
/* Pass synthetic vectors in memory. */
- if (TREE_CODE (arg.type) == VECTOR_TYPE
+ if (VECTOR_TYPE_P (arg.type)
&& int_size_in_bytes (arg.type) > (TARGET_ALTIVEC_ABI ? 16 : 8))
{
static bool warned_for_pass_big_vectors = false;
prototype, so the argument type info must be available
here. */
FOREACH_FUNCTION_ARGS(fntype, type, args_iter)
- if (TREE_CODE (type) == VECTOR_TYPE
+ if (VECTOR_TYPE_P (type)
&& ALTIVEC_OR_VSX_VECTOR_MODE (TYPE_MODE (type)))
nvreg++;
FOREACH_FUNCTION_ARGS(TREE_TYPE (current_function_decl), type, args_iter)
- if (TREE_CODE (type) == VECTOR_TYPE
+ if (VECTOR_TYPE_P (type)
&& ALTIVEC_OR_VSX_VECTOR_MODE (TYPE_MODE (type)))
nvreg--;
{
if (how != align_opt)
{
- if (TREE_CODE (type) == VECTOR_TYPE && align < 128)
+ if (VECTOR_TYPE_P (type) && align < 128)
align = 128;
}
rs6000_set_default_type_attributes (tree type)
{
if (rs6000_default_long_calls
- && (TREE_CODE (type) == FUNCTION_TYPE
- || TREE_CODE (type) == METHOD_TYPE))
+ && FUNC_OR_METHOD_TYPE_P (type))
TYPE_ATTRIBUTES (type) = tree_cons (get_identifier ("longcall"),
NULL_TREE,
TYPE_ATTRIBUTES (type));
if (TREE_CODE (decl) == FUNCTION_DECL)
return false;
- if (TREE_CODE (decl) == VAR_DECL && DECL_SECTION_NAME (decl))
+ if (VAR_P (decl) && DECL_SECTION_NAME (decl))
{
const char *section = DECL_SECTION_NAME (decl);
if (compare_section_name (section, ".sdata")
}
#define IN_NAMED_SECTION(DECL) \
- ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
+ ((TREE_CODE (DECL) == FUNCTION_DECL || VAR_P (DECL)) \
&& DECL_SECTION_NAME (DECL) != NULL)
static section *
flags = SYMBOL_REF_FLAGS (symbol);
- if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
+ if (VAR_P (decl) && DECL_THREAD_LOCAL_P (decl))
flags &= ~SYMBOL_FLAG_HAS_BLOCK_INFO;
SYMBOL_REF_FLAGS (symbol) = flags;
/* VSX is a superset of Altivec and adds V2DImode/V2DFmode. Since the same
return register is used in both cases, and we won't see V2DImode/V2DFmode
for pure altivec, combine the two cases. */
- else if ((TREE_CODE (valtype) == VECTOR_TYPE || VECTOR_ALIGNMENT_P (mode))
+ else if ((VECTOR_TYPE_P (valtype) || VECTOR_ALIGNMENT_P (mode))
&& TARGET_ALTIVEC && TARGET_ALTIVEC_ABI
&& ALTIVEC_OR_VSX_VECTOR_MODE (mode))
regno = ALTIVEC_ARG_RETURN;
{
return (!rs6000_darwin64_abi
&& typelist == 0
- && TREE_CODE (TREE_TYPE (val)) == VECTOR_TYPE
+ && VECTOR_TYPE_P (TREE_TYPE (val))
&& (funcdecl == NULL_TREE
|| (TREE_CODE (funcdecl) == FUNCTION_DECL
&& DECL_BUILT_IN_CLASS (funcdecl) != BUILT_IN_MD)))
tree in_arg = (*arglist)[i];
tree in_type = TREE_TYPE (in_arg);
- if (TREE_CODE (b_arg_type) == VECTOR_TYPE)
+ if (VECTOR_TYPE_P (b_arg_type))
{
/* Vector types have to match precisely. */
if (b_arg_type != in_type
tree b_arg_chain;
int n_elem = -1;
- if (TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) == VECTOR_TYPE)
+ if (VECTOR_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl))))
n_elem = TYPE_VECTOR_SUBPARTS (TREE_TYPE (TREE_TYPE ((fndecl))));
for (b_arg_chain = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
true here. */
s390_check_type_for_vector_abi (TREE_TYPE (type), arg_p, in_struct_p);
}
- else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
+ else if (FUNC_OR_METHOD_TYPE_P (type))
{
tree arg_chain;
|| POINTER_TYPE_P (type)
|| TREE_CODE (type) == NULLPTR_TYPE
|| TREE_CODE (type) == OFFSET_TYPE
- || (TARGET_SOFT_FLOAT && TREE_CODE (type) == REAL_TYPE))
+ || (TARGET_SOFT_FLOAT && SCALAR_FLOAT_TYPE_P (type)))
return true;
/* We also accept structs of size 1, 2, 4, 8 that are not
if (INTEGRAL_TYPE_P (type)
|| POINTER_TYPE_P (type)
|| TREE_CODE (type) == OFFSET_TYPE
- || TREE_CODE (type) == REAL_TYPE)
+ || SCALAR_FLOAT_TYPE_P (type))
return int_size_in_bytes (type) > 8;
/* vector types which fit into a VR. */
{
default_encode_section_info (decl, rtl, first);
- if (TREE_CODE (decl) == VAR_DECL)
+ if (VAR_P (decl))
{
/* Store the alignment to be able to check if we can use
a larl/load-relative instruction. We only handle the cases
eff_type = type;
while (TREE_CODE (eff_type) == RECORD_TYPE
&& (member = find_sole_member (eff_type))
- && (TREE_CODE (TREE_TYPE (member)) == REAL_TYPE
+ && (SCALAR_FLOAT_TYPE_P (TREE_TYPE (member))
|| TREE_CODE (TREE_TYPE (member)) == COMPLEX_TYPE
|| TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE))
{
bool pass_as_float;
if (TARGET_FPU_DOUBLE)
{
- pass_as_float = ((TREE_CODE (eff_type) == REAL_TYPE && size <= 8)
+ pass_as_float = ((SCALAR_FLOAT_TYPE_P (eff_type) && size <= 8)
|| (TREE_CODE (eff_type) == COMPLEX_TYPE
- && TREE_CODE (TREE_TYPE (eff_type)) == REAL_TYPE
+ && SCALAR_FLOAT_TYPE_P (TREE_TYPE (eff_type))
&& size <= 16));
}
else
{
- pass_as_float = (TREE_CODE (eff_type) == REAL_TYPE && size == 4);
+ pass_as_float = (SCALAR_FLOAT_TYPE_P (eff_type) && size == 4);
}
addr = create_tmp_var (pptr_type_node);
{
tree next_fp_tmp = create_tmp_var (TREE_TYPE (f_next_fp));
tree cmp;
- bool is_double = size == 8 && TREE_CODE (eff_type) == REAL_TYPE;
+ bool is_double = size == 8 && SCALAR_FLOAT_TYPE_P (eff_type);
tmp = build1 (ADDR_EXPR, pptr_type_node, unshare_expr (next_fp));
gimplify_assign (unshare_expr (addr), tmp, pre_p);
&& (TREE_CODE (valtype) == INTEGER_TYPE
|| TREE_CODE (valtype) == ENUMERAL_TYPE
|| TREE_CODE (valtype) == BOOLEAN_TYPE
- || TREE_CODE (valtype) == REAL_TYPE
+ || SCALAR_FLOAT_TYPE_P (valtype)
|| TREE_CODE (valtype) == OFFSET_TYPE))
&& sh_promote_prototypes (fn_decl_or_type)
? SImode : TYPE_MODE (valtype)),
{
tree *x, next;
- if (solaris_pending_aligns != NULL && TREE_CODE (decl) == VAR_DECL)
+ if (solaris_pending_aligns != NULL && VAR_P (decl))
for (x = &solaris_pending_aligns; *x; x = &TREE_CHAIN (*x))
{
tree name = TREE_PURPOSE (*x);
their mode, depending upon whether VIS instructions are enabled. */
if (type && VECTOR_TYPE_P (type))
{
- if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
+ if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (type)))
{
/* The SPARC port defines no floating-point vector modes. */
gcc_assert (mode == BLKmode);
the smaller of COMPUTED and `BIGGEST_ALIGNMENT' */
#define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED) \
(TARGET_FASTER_STRUCTS ? \
- ((TREE_CODE (STRUCT) == RECORD_TYPE \
- || TREE_CODE (STRUCT) == UNION_TYPE \
- || TREE_CODE (STRUCT) == QUAL_UNION_TYPE) \
+ (RECORD_OR_UNION_TYPE_P (STRUCT) \
&& TYPE_FIELDS (STRUCT) != 0 \
? MAX (MAX ((COMPUTED), (SPECIFIED)), BIGGEST_ALIGNMENT) \
: MAX ((COMPUTED), (SPECIFIED))) \
{
default_encode_section_info (decl, r, first);
- if (TREE_CODE (decl) == VAR_DECL
+ if (VAR_P (decl)
&& (lookup_attribute ("below100", DECL_ATTRIBUTES (decl))
|| lookup_attribute ("BELOW100", DECL_ATTRIBUTES (decl))))
{
"%<__BELOW100__%> attribute only applies to variables");
*no_add_attrs = true;
}
- else if (args == NULL_TREE && TREE_CODE (*node) == VAR_DECL)
+ else if (args == NULL_TREE && VAR_P (*node))
{
if (! (TREE_PUBLIC (*node) || TREE_STATIC (*node)))
{
{
default_encode_section_info (decl, rtl, first);
- if (TREE_CODE (decl) == VAR_DECL
+ if (VAR_P (decl)
&& (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
v850_encode_data_area (decl, XEXP (rtl, 0));
}
if (data_area_stack
&& data_area_stack->data_area
&& current_function_decl == NULL_TREE
- && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == CONST_DECL)
+ && (VAR_P (decl) || TREE_CODE (decl) == CONST_DECL)
&& v850_get_data_area (decl) == DATA_AREA_NORMAL)
v850_set_data_area (decl, data_area_stack->data_area);
}
if (current_function_decl == NULL_TREE
- && (TREE_CODE (decl) == VAR_DECL
+ && (VAR_P (decl)
|| TREE_CODE (decl) == CONST_DECL
|| TREE_CODE (decl) == FUNCTION_DECL)
&& (!DECL_EXTERNAL (decl) || DECL_INITIAL (decl))
visium_pass_by_reference (cumulative_args_t, const function_arg_info &arg)
{
tree type = arg.type;
- return type && (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == VECTOR_TYPE);
+ return type && (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type));
}
/* Define how arguments are passed.
static bool
visium_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
{
- return (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == VECTOR_TYPE);
+ return (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type));
}
/* Define how scalar values are returned. */
suffix = strrchr (name, '.');
if (suffix && strcmp (suffix, ".bss") == 0)
{
- if (!decl || (TREE_CODE (decl) == VAR_DECL
+ if (!decl || (VAR_P (decl)
&& DECL_INITIAL (decl) == NULL_TREE))
flags |= SECTION_BSS; /* @nobits */
else
git://gcc.gnu.org / gcc.git / commitdiff