#include "c-pragma.h"
#include "rtl.h"
#include "ggc.h"
-#include "expr.h" /* For vector_mode_valid_p */
+#include "expr.h"
#include "c-common.h"
#include "tm_p.h"
#include "obstack.h"
#include "real.h"
#include "cgraph.h"
#include "target-def.h"
+#include "gimple.h"
#include "fixed-value.h"
#include "libfuncs.h"
int flag_pretty_templates = 1;
+/* Nonzero means warn about implicit declarations. */
+
+int warn_implicit = 1;
+
/* Maximum template instantiation depth. This limit exists to limit the
time it takes to notice infinite template instantiations; the default
value of 1024 is likely to be in the next C++ standard. */
static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
static tree handle_target_attribute (tree *, tree, tree, int, bool *);
static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
-static tree handle_fnspec_attribute (tree *, tree, tree, int, bool *);
static void check_function_nonnull (tree, int, tree *);
static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
{ "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN },
{ "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN },
{ "new", RID_NEW, D_CXXONLY | D_CXXWARN },
- { "nullptr", RID_NULLPTR, D_CXXONLY | D_CXX0X | D_CXXWARN },
{ "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN },
{ "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN },
{ "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN },
handle_target_attribute },
{ "optimize", 1, -1, true, false, false,
handle_optimize_attribute },
- /* For internal use (marking of builtins and runtime functions) only.
- The name contains space to prevent its usage in source code. */
- { "fn spec", 1, 1, false, true, true,
- handle_fnspec_attribute },
{ NULL, 0, 0, false, false, false, NULL }
};
identifier as an argument, so the front end shouldn't look it up. */
bool
-attribute_takes_identifier_p (const_tree attr_id)
+attribute_takes_identifier_p (tree attr_id)
{
- if (is_attribute_p ("mode", attr_id)
- || is_attribute_p ("format", attr_id)
- || is_attribute_p ("cleanup", attr_id))
- return true;
- else
- return targetm.attribute_takes_identifier_p (attr_id);
+ return (is_attribute_p ("mode", attr_id)
+ || is_attribute_p ("format", attr_id)
+ || is_attribute_p ("cleanup", attr_id));
}
/* Attribute handlers common to C front ends. */
}
else if (is_type)
{
- if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
- /* OK, modify the type in place. */;
/* If we have a TYPE_DECL, then copy the type, so that we
don't accidentally modify a builtin type. See pushdecl. */
- else if (decl && TREE_TYPE (decl) != error_mark_node
- && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
+ if (decl && TREE_TYPE (decl) != error_mark_node
+ && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
{
tree tt = TREE_TYPE (decl);
*type = build_variant_type_copy (*type);
TREE_USED (*type) = TREE_USED (decl);
TREE_TYPE (decl) = *type;
}
- else
+ else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
*type = build_variant_type_copy (*type);
TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
return NULL_TREE;
}
-/* Handle a "fn spec" attribute; arguments as in
- struct attribute_spec.handler. */
-
-static tree
-handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
- tree args, int ARG_UNUSED (flags),
- bool *no_add_attrs ATTRIBUTE_UNUSED)
-{
- gcc_assert (args
- && TREE_CODE (TREE_VALUE (args)) == STRING_CST
- && !TREE_CHAIN (args));
- return NULL_TREE;
-}
-
/* Handle a "returns_twice" attribute; arguments as in
struct attribute_spec.handler. */
{
tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
tree ptype;
+ int number;
unsigned int parmnum;
/* We've declared the implementation functions to use "volatile void *"
call to check_function_arguments what ever type the user used. */
arg_types = TREE_CHAIN (arg_types);
ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
+ number = 2;
/* For the rest of the values, we need to cast these to FTYPE, so that we
don't get warnings for passing pointer types, etc. */
VEC_replace (tree, params, parmnum, val);
arg_types = TREE_CHAIN (arg_types);
+ number++;
}
/* The definition of these primitives is variadic, with the remaining