/* Define builtin-in macros for the C family front ends.
- Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
#include "toplev.h"
#include "tm_p.h" /* Target prototypes. */
+#ifndef TARGET_OS_CPP_BUILTINS
+# define TARGET_OS_CPP_BUILTINS()
+#endif
+
+#ifndef TARGET_OBJFMT_CPP_BUILTINS
+# define TARGET_OBJFMT_CPP_BUILTINS()
+#endif
+
#ifndef REGISTER_PREFIX
#define REGISTER_PREFIX ""
#endif
-static void builtin_define_std PARAMS ((const char *));
-static void builtin_define_with_value_n PARAMS ((const char *, const char *,
- size_t));
-static void builtin_define_with_int_value PARAMS ((const char *,
- HOST_WIDE_INT));
-static void builtin_define_with_hex_fp_value PARAMS ((const char *, tree,
- int, const char *,
- const char *));
-static void builtin_define_type_max PARAMS ((const char *, tree, int));
-static void builtin_define_type_precision PARAMS ((const char *, tree));
-static void builtin_define_float_constants PARAMS ((const char *,
- const char *, tree));
-static void define__GNUC__ PARAMS ((void));
+/* Non-static as some targets don't use it. */
+void builtin_define_std (const char *) ATTRIBUTE_UNUSED;
+static void builtin_define_with_value_n (const char *, const char *,
+ size_t);
+static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
+static void builtin_define_with_hex_fp_value (const char *, tree,
+ int, const char *,
+ const char *);
+static void builtin_define_type_max (const char *, tree, int);
+static void builtin_define_type_precision (const char *, tree);
+static void builtin_define_float_constants (const char *, const char *,
+ tree);
+static void define__GNUC__ (void);
/* Define NAME with value TYPE precision. */
static void
-builtin_define_type_precision (name, type)
- const char *name;
- tree type;
+builtin_define_type_precision (const char *name, tree type)
{
builtin_define_with_int_value (name, TYPE_PRECISION (type));
}
/* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX. */
static void
-builtin_define_float_constants (name_prefix, fp_suffix, type)
- const char *name_prefix;
- const char *fp_suffix;
- tree type;
+builtin_define_float_constants (const char *name_prefix, const char *fp_suffix, tree type)
{
/* Used to convert radix-based values to base 10 values in several cases.
int dig, min_10_exp, max_10_exp;
int decimal_dig;
- fmt = real_format_for_mode[TYPE_MODE (type) - QFmode];
+ fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
/* The radix of the exponent representation. */
if (type == float_type_node)
p radix b digits and back again without change to the q decimal digits,
p log10 b if b is a power of 10
- floor((p - 1) log10 b) otherwise
+ floor((p - 1) log10 b) otherwise
*/
dig = (fmt->p - 1) * log10_b;
sprintf (name, "__%s_DIG__", name_prefix);
/* The number of decimal digits, n, such that any floating-point number
can be rounded to n decimal digits and back again without change to
- the value.
+ the value.
p * log10(b) if b is a power of 10
ceil(1 + p * log10(b)) otherwise
/* For C++ std::numeric_limits<T>::has_infinity. */
sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
- builtin_define_with_int_value (name,
+ builtin_define_with_int_value (name,
MODE_HAS_INFINITIES (TYPE_MODE (type)));
/* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
predicate to distinguish a target that has both quiet and
/* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */
static void
-define__GNUC__ ()
+define__GNUC__ (void)
{
/* The format of the version string, enforced below, is
([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
while (ISDIGIT (*v))
v++;
builtin_define_with_value_n ("__GNUC__", q, v - q);
- if (c_language == clk_cplusplus)
+ if (c_dialect_cxx ())
builtin_define_with_value_n ("__GNUG__", q, v - q);
if (*v != '.' || !ISDIGIT (v[1]))
/* Hook that registers front end and target-specific built-ins. */
void
-cb_register_builtins (pfile)
- cpp_reader *pfile;
+c_cpp_builtins (cpp_reader *pfile)
{
/* -undef turns off target-specific built-ins. */
if (flag_undef)
/* For stddef.h. They require macros defined in c-common.c. */
c_stddef_cpp_builtins ();
- if (c_language == clk_cplusplus)
+ if (c_dialect_cxx ())
{
if (SUPPORTS_ONE_ONLY)
cpp_define (pfile, "__GXX_WEAK__=1");
else
cpp_define (pfile, "__GXX_WEAK__=0");
- if (flag_exceptions)
- cpp_define (pfile, "__EXCEPTIONS");
if (warn_deprecated)
cpp_define (pfile, "__DEPRECATED");
}
+ /* Note that we define this for C as well, so that we know if
+ __attribute__((cleanup)) will interface with EH. */
+ if (flag_exceptions)
+ cpp_define (pfile, "__EXCEPTIONS");
- /* represents the C++ ABI version, always defined so it can be used while
+ /* Represents the C++ ABI version, always defined so it can be used while
preprocessing C and assembler. */
- cpp_define (pfile, "__GXX_ABI_VERSION=102");
+ if (flag_abi_version == 0)
+ /* Use a very large value so that:
+
+ #if __GXX_ABI_VERSION >= <value for version X>
+
+ will work whether the user explicitly says "-fabi-version=x" or
+ "-fabi-version=0". Do not use INT_MAX because that will be
+ different from system to system. */
+ builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
+ else if (flag_abi_version == 1)
+ /* Due to an historical accident, this version had the value
+ "102". */
+ builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
+ else
+ /* Newer versions have values 1002, 1003, .... */
+ builtin_define_with_int_value ("__GXX_ABI_VERSION",
+ 1000 + flag_abi_version);
/* libgcc needs to know this. */
if (USING_SJLJ_EXCEPTIONS)
/* Misc. */
builtin_define_with_value ("__VERSION__", version_string, 1);
+ /* Definitions for LP64 model. */
+ if (TYPE_PRECISION (long_integer_type_node) == 64
+ && POINTER_SIZE == 64
+ && TYPE_PRECISION (integer_type_node) == 32)
+ {
+ cpp_define (pfile, "_LP64");
+ cpp_define (pfile, "__LP64__");
+ }
+
/* Other target-independent built-ins determined by command-line
options. */
if (optimize_size)
if (optimize)
cpp_define (pfile, "__OPTIMIZE__");
- if (flag_hosted)
- cpp_define (pfile, "__STDC_HOSTED__=1");
- else
- cpp_define (pfile, "__STDC_HOSTED__=0");
-
if (fast_math_flags_set_p ())
cpp_define (pfile, "__FAST_MATH__");
if (flag_really_no_inline)
if (!flag_signed_char)
cpp_define (pfile, "__CHAR_UNSIGNED__");
- if (c_language == clk_cplusplus && TREE_UNSIGNED (wchar_type_node))
+ if (c_dialect_cxx () && TREE_UNSIGNED (wchar_type_node))
cpp_define (pfile, "__WCHAR_UNSIGNED__");
/* Make the choice of ObjC runtime visible to source code. */
- if (flag_objc && flag_next_runtime)
+ if (c_dialect_objc () && flag_next_runtime)
cpp_define (pfile, "__NEXT_RUNTIME__");
/* A straightforward target hook doesn't work, because of problems
# define builtin_assert(TXT) cpp_assert (pfile, TXT)
TARGET_CPU_CPP_BUILTINS ();
TARGET_OS_CPP_BUILTINS ();
+ TARGET_OBJFMT_CPP_BUILTINS ();
}
/* Pass an object-like macro. If it doesn't lie in the user's
e.g. passing "unix" defines "__unix", "__unix__" and possibly
"unix". Passing "_mips" defines "__mips", "__mips__" and possibly
"_mips". */
-static void
-builtin_define_std (macro)
- const char *macro;
+void
+builtin_define_std (const char *macro)
{
size_t len = strlen (macro);
char *buff = alloca (len + 5);
parameter says whether or not to turn the value into a string
constant. */
void
-builtin_define_with_value (macro, expansion, is_str)
- const char *macro;
- const char *expansion;
- int is_str;
+builtin_define_with_value (const char *macro, const char *expansion, int is_str)
{
char *buf;
size_t mlen = strlen (macro);
/* Pass an object-like macro and a value to define it to. The third
parameter is the length of the expansion. */
static void
-builtin_define_with_value_n (macro, expansion, elen)
- const char *macro;
- const char *expansion;
- size_t elen;
+builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
{
char *buf;
size_t mlen = strlen (macro);
-
+
/* Space for an = and a NUL. */
buf = alloca (mlen + elen + 2);
memcpy (buf, macro, mlen);
- buf[mlen]= '=';
+ buf[mlen] = '=';
memcpy (buf + mlen + 1, expansion, elen);
buf[mlen + elen + 1] = '\0';
/* Pass an object-like macro and an integer value to define it to. */
static void
-builtin_define_with_int_value (macro, value)
- const char *macro;
- HOST_WIDE_INT value;
+builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
{
char *buf;
size_t mlen = strlen (macro);
/* Pass an object-like macro a hexadecimal floating-point value. */
static void
-builtin_define_with_hex_fp_value (macro, type, digits, hex_str, fp_suffix)
- const char *macro;
- tree type ATTRIBUTE_UNUSED;
- int digits;
- const char *hex_str;
- const char *fp_suffix;
+builtin_define_with_hex_fp_value (const char *macro,
+ tree type ATTRIBUTE_UNUSED, int digits,
+ const char *hex_str, const char *fp_suffix)
{
REAL_VALUE_TYPE real;
char dec_str[64], buf[256];
pedwarn from the preprocessor, which has no context, so we can't
suppress the warning with __extension__.
- So instead what we do is construct the number in hex (because
+ So instead what we do is construct the number in hex (because
it's easy to get the exact correct value), parse it as a real,
then print it back out as decimal. */
unsigned types, since wchar_t might be unsigned. */
static void
-builtin_define_type_max (macro, type, is_long)
- const char *macro;
- tree type;
- int is_long;
+builtin_define_type_max (const char *macro, tree type, int is_long)
{
static const char *const values[]
= { "127", "255",
OSDN Git Service
