/* 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 "coretypes.h"
#include "tm.h"
#include "tree.h"
+#include "version.h"
#include "flags.h"
#include "real.h"
#include "c-common.h"
#include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
#include "toplev.h"
#include "tm_p.h" /* Target prototypes. */
+#include "target.h"
+
+#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
/* Non-static as some targets don't use it. */
-void builtin_define_std PARAMS ((const char *)) ATTRIBUTE_UNUSED;
-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));
+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_stdint_macros (void);
+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
if (i < n)
*p++ = "08ce"[n - i];
sprintf (p, "p%d", fmt->emax * fmt->log2_b);
+ if (fmt->pnan < fmt->p)
+ {
+ /* This is an IBM extended double format made up of two IEEE
+ doubles. The value of the long double is the sum of the
+ values of the two parts. The most significant part is
+ required to be the value of the long double rounded to the
+ nearest double. Rounding means we need a slightly smaller
+ value for LDBL_MAX. */
+ buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4];
+ }
}
sprintf (name, "__%s_MAX__", name_prefix);
builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
/* 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]+)?([- ].*)? */
const char *q, *v = version_string;
- while (*v && ! ISDIGIT (*v))
+ while (*v && !ISDIGIT (*v))
v++;
- if (!*v || (v > version_string && v[-1] != '-'))
- abort ();
+ gcc_assert (*v && (v <= version_string || v[-1] == '-'));
q = v;
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]))
- abort ();
+ gcc_assert (*v == '.' || ISDIGIT (v[1]));
+
q = ++v;
while (ISDIGIT (*v))
v++;
if (*v == '.')
{
- if (!ISDIGIT (v[1]))
- abort ();
+ gcc_assert (ISDIGIT (v[1]));
q = ++v;
while (ISDIGIT (*v))
v++;
else
builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
- if (*v && *v != ' ' && *v != '-')
- abort ();
+ gcc_assert (!*v || *v == ' ' || *v == '-');
+}
+
+/* Define macros used by <stdint.h>. Currently only defines limits
+ for intmax_t, used by the testsuite. */
+static void
+builtin_define_stdint_macros (void)
+{
+ int intmax_long;
+ if (intmax_type_node == long_long_integer_type_node)
+ intmax_long = 2;
+ else if (intmax_type_node == long_integer_type_node)
+ intmax_long = 1;
+ else if (intmax_type_node == integer_type_node)
+ intmax_long = 0;
+ else
+ gcc_unreachable ();
+ builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node, intmax_long);
}
/* 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)
builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
+ /* stdint.h (eventually) and the testsuite need to know these. */
+ builtin_define_stdint_macros ();
+
/* float.h needs to know these. */
builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
/* 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 () && TYPE_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__");
+ /* Show the availability of some target pragmas. */
+ if (flag_mudflap || targetm.handle_pragma_redefine_extname)
+ cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
+
+ if (targetm.handle_pragma_extern_prefix)
+ cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
+
/* A straightforward target hook doesn't work, because of problems
linking that hook's body when part of non-C front ends. */
# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
# define builtin_assert(TXT) cpp_assert (pfile, TXT)
TARGET_CPU_CPP_BUILTINS ();
TARGET_OS_CPP_BUILTINS ();
+ TARGET_OBJFMT_CPP_BUILTINS ();
+
+ /* Support the __declspec keyword by turning them into attributes.
+ Note that the current way we do this may result in a collision
+ with predefined attributes later on. This can be solved by using
+ one attribute, say __declspec__, and passing args to it. The
+ problem with that approach is that args are not accumulated: each
+ new appearance would clobber any existing args. */
+ if (TARGET_DECLSPEC)
+ builtin_define ("__declspec(x)=__attribute__((x))");
}
/* Pass an object-like macro. If it doesn't lie in the user's
"unix". Passing "_mips" defines "__mips", "__mips__" and possibly
"_mips". */
void
-builtin_define_std (macro)
- const char *macro;
+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",
case 32: idx = 4; break;
case 64: idx = 6; break;
case 128: idx = 8; break;
- default: abort ();
+ default: gcc_unreachable ();
}
- value = values[idx + TREE_UNSIGNED (type)];
- suffix = suffixes[is_long * 2 + TREE_UNSIGNED (type)];
+ value = values[idx + TYPE_UNSIGNED (type)];
+ suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
buf = alloca (strlen (macro) + 1 + strlen (value) + strlen (suffix) + 1);
sprintf (buf, "%s=%s%s", macro, value, suffix);