diff options
author | Geoffrey Keating <geoffk@apple.com> | 2005-02-28 22:25:57 +0000 |
---|---|---|
committer | Geoffrey Keating <geoffk@apple.com> | 2005-02-28 22:25:57 +0000 |
commit | 889dff0295a98a2959d1a9afbbc39b76fe71d778 (patch) | |
tree | 255c643af3be7e4944235e9d2b7e12e290fcbe20 | |
parent | 6a4bce908b4fdf95fc887f222708315ed474306c (diff) |
Merge changes between apple-ppc-merge-20041026 and apple-gcc-4049
git-svn-id: https://gcc.gnu.org/svn/gcc/branches/apple-local-200502-branch@95703 138bc75d-0d04-0410-961f-82ee72b054a4
-rw-r--r-- | libobjc/encoding.c | 22 | ||||
-rw-r--r-- | libstdc++-v3/config/os/bsd/darwin/os_defines.h | 138 | ||||
-rw-r--r-- | more-hdrs/assert.h | 71 | ||||
-rw-r--r-- | more-hdrs/float.h | 9 | ||||
-rw-r--r-- | more-hdrs/inttypes.h | 299 | ||||
-rw-r--r-- | more-hdrs/machine/limits.h | 11 | ||||
-rw-r--r-- | more-hdrs/ppc_intrinsics.h | 1048 | ||||
-rw-r--r-- | more-hdrs/stdarg.h | 6 | ||||
-rw-r--r-- | more-hdrs/stdbool.h | 10 | ||||
-rw-r--r-- | more-hdrs/stdint.h | 245 | ||||
-rw-r--r-- | more-hdrs/varargs.h | 6 | ||||
-rw-r--r-- | order-files/HOW TO BUILD | 170 | ||||
-rw-r--r-- | order-files/cc1.order | 1188 | ||||
-rw-r--r-- | order-files/cc1obj.order | 2163 | ||||
-rw-r--r-- | order-files/cc1objplus.order | 952 | ||||
-rw-r--r-- | order-files/cc1plus.order | 1356 |
16 files changed, 7692 insertions, 2 deletions
diff --git a/libobjc/encoding.c b/libobjc/encoding.c index 7f71276b556..a71167b95cf 100644 --- a/libobjc/encoding.c +++ b/libobjc/encoding.c @@ -780,6 +780,23 @@ objc_layout_structure (const char *type, layout->record_align = MAX (layout->record_align, STRUCTURE_SIZE_BOUNDARY); } +/* APPLE LOCAL begin Macintosh alignment 2002-2-26 --ff */ +#ifdef RS6000_PIC_OFFSET_TABLE_REGNUM +/* Ick, darwin.h doesn't work anymore... Fix this please. */ +#undef ROUND_TYPE_ALIGN +#define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED) \ + ((TREE_CODE (STRUCT) == RECORD_TYPE \ + || TREE_CODE (STRUCT) == UNION_TYPE \ + || TREE_CODE (STRUCT) == QUAL_UNION_TYPE) \ + && TARGET_ALIGN_NATURAL == 0 \ + ? rs6000_special_round_type_align (STRUCT, COMPUTED, SPECIFIED) \ + : (TREE_CODE (STRUCT) == VECTOR_TYPE \ + && ALTIVEC_VECTOR_MODE (TYPE_MODE (STRUCT))) \ + ? MAX (MAX ((COMPUTED), (SPECIFIED)), 128) \ + : MAX ((COMPUTED), (SPECIFIED))) +#define TARGET_ALIGN_MAC68K 0 +#endif +/* APPLE LOCAL end Macintosh alignment 2002-2-26 --ff */ BOOL objc_layout_structure_next_member (struct objc_struct_layout *layout) @@ -845,9 +862,11 @@ objc_layout_structure_next_member (struct objc_struct_layout *layout) #ifdef BIGGEST_FIELD_ALIGNMENT desired_align = MIN (desired_align, BIGGEST_FIELD_ALIGNMENT); #endif +/* APPLE LOCAL begin Macintosh alignment 2002-2-26 --ff */ #ifdef ADJUST_FIELD_ALIGN - desired_align = ADJUST_FIELD_ALIGN (type, desired_align); + desired_align = ADJUST_FIELD_ALIGN (type, desired_align, layout->prev_type == 0); #endif +/* APPLE LOCAL end Macintosh alignment 2002-2-26 --ff */ /* Record must have at least as much alignment as any field. Otherwise, the alignment of the field within the record @@ -909,7 +928,6 @@ objc_layout_structure_next_member (struct objc_struct_layout *layout) return YES; } - void objc_layout_finish_structure (struct objc_struct_layout *layout, unsigned int *size, unsigned int *align) diff --git a/libstdc++-v3/config/os/bsd/darwin/os_defines.h b/libstdc++-v3/config/os/bsd/darwin/os_defines.h index 07fb55b6125..bbe2000c8e5 100644 --- a/libstdc++-v3/config/os/bsd/darwin/os_defines.h +++ b/libstdc++-v3/config/os/bsd/darwin/os_defines.h @@ -44,4 +44,142 @@ // -flat_namespace to work around the way that it doesn't. #define _GLIBCXX_WEAK_DEFINITION __attribute__ ((weak)) +/* APPLE LOCAL begin keymgr */ +/* Copyright (C) 1989, 92-97, 1998, Free Software Foundation, Inc. + +This file is part of GNU CC. + +GNU CC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU CC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU CC; see the file COPYING. If not, write to +the Free Software Foundation, 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + + +/* + * This file added by Apple Computer Inc. for its OS X + * environment. + */ + +#ifndef __KEYMGR_H +#define __KEYMGR_H + +#ifdef __cplusplus +extern "C" { +#endif + + + +/* + * keymgr - Create and maintain process-wide global data known to + * all threads across all dynamic libraries. + * + */ + +typedef enum node_kinds { + NODE_THREAD_SPECIFIC_DATA=1, + NODE_PROCESSWIDE_PTR=2, + NODE_LAST_KIND + } TnodeKind ; + +/* + * These enum members are bits or combination of bits. + */ + +typedef enum node_mode { + NM_ALLOW_RECURSION=1, + NM_RECURSION_ILLEGAL=2, + NM_ENHANCED_LOCKING=3, + NM_LOCKED=4 + } TnodeMode ; + +/* WARNING: the return value of _keymgr_set_per_thread_data is + not meaningful on Tiger and above. Use the macro + KEYMGR_SET_PER_THREAD_DATA (below) to handle this properly. */ +extern void * _keymgr_get_per_thread_data(unsigned int key) ; +extern int _keymgr_set_per_thread_data(unsigned int key, void *keydata) ; +extern void *_keymgr_get_and_lock_processwide_ptr(unsigned int key) ; +extern void _keymgr_set_and_unlock_processwide_ptr(unsigned int key, void *ptr) ; +extern void _keymgr_unlock_processwide_ptr(unsigned int key) ; +extern void _keymgr_set_lockmode_processwide_ptr(unsigned int key, unsigned int mode) ; +extern unsigned int _keymgr_get_lockmode_processwide_ptr(unsigned int key) ; +extern int _keymgr_get_lock_count_processwide_ptr(unsigned int key) ; + +extern void *__keymgr_global[]; +typedef struct _Sinfo_Node { + unsigned int size ; /*size of this node*/ + unsigned short major_version ; /*API major version.*/ + unsigned short minor_version ; /*API minor version.*/ + } _Tinfo_Node ; + +#define KEYMGR_VERSION \ + (__keymgr_global[2] ? ((_Tinfo_Node *)__keymgr_global[2])->major_version : 0) + +#define KEYMGR_SET_PER_THREAD_DATA(key, keydata) \ + (KEYMGR_VERSION >= 4 \ + ? _keymgr_set_per_thread_data((key), (keydata)) \ + : (_keymgr_set_per_thread_data((key), (keydata)), 0)) + +#ifndef NULL +#ifdef __GNUG__ +#define NULL __null +#else +#define NULL 0 +#endif +#endif + +/* + * Keys currently in use: + */ + +#define KEYMGR_EH_CONTEXT_KEY 1 /*stores handle for root pointer of exception context node.*/ + +#define KEYMGR_NEW_HANLDER_KEY 2 /*store handle for new handler pointer.*/ + +#define KEYMGR_UNEXPECTED_HANDLER_KEY 3 /*store handle for unexpected exception pointer.*/ + +#define KEYMGR_TERMINATE_HANDLER_KEY 4 /*store handle for terminate handler pointer. */ + +#define KEYMGR_MODE_BITS 5 /*stores handle for runtime mode bits.*/ + +#define KEYMGR_IO_LIST 6 /*Root pointer to the list of open streams.*/ + +#define KEYMGR_IO_STDIN 7 /*GNU stdin.*/ + +#define KEYMGR_IO_STDOUT 8 /*GNU stdout.*/ + +#define KEYMGR_IO_STDERR 9 /*GNU stderr.*/ + +#define KEYMGR_IO_REFCNT 10 /*How many plugins/main program currently using streams.*/ + +#define KEYMGR_IO_MODE_BITS 11 /*Flags controlling the behavior of C++ I/O.*/ + +#define KEYMGR_ZOE_IMAGE_LIST 12 /*Head pointer for list of per image dwarf2 unwind sections.*/ + +#define KEYMGR_EH_GLOBALS_KEY 13 /* Variable used in eh_globals.cc */ + +/* + * Other important data. + */ + +#define KEYMGR_API_REV_MAJOR 2 /*Major revision number of the keymgr API.*/ +#define KEYMGR_API_REV_MINOR 1 /*Minor revision number of the keymgr API.*/ + + + +#ifdef __cplusplus +} +#endif + +#endif /* __KEYMGR_H */ +/* APPLE LOCAL end keymgr */ #endif diff --git a/more-hdrs/assert.h b/more-hdrs/assert.h new file mode 100644 index 00000000000..0bd55b020c8 --- /dev/null +++ b/more-hdrs/assert.h @@ -0,0 +1,71 @@ +/* DO NOT EDIT THIS FILE. + + It has been auto-edited by fixincludes from: + + "/usr/include/assert.h" + + This had to be done to correct non-standard usages in the + original, manufacturer supplied header file. */ + +#ifndef FIXINC_BROKEN_ASSERT_STDLIB_CHECK +#define FIXINC_BROKEN_ASSERT_STDLIB_CHECK 1 + +#ifdef __cplusplus +#include <stdlib.h> +#endif +/* Allow this file to be included multiple times + with different settings of NDEBUG. */ +#undef assert +#undef __assert + +#ifdef NDEBUG +#define assert(ignore) ((void) 0) +#else + +#ifndef __GNUC__ + +#define assert(expression) \ + ((void) ((expression) ? 0 : __assert (expression, __FILE__, __LINE__))) + +#define __assert(expression, file, lineno) \ + (printf ("%s:%u: failed assertion\n", file, lineno), \ + abort (), 0) + +#else + +#if defined(__STDC__) || defined (__cplusplus) + +/* Defined in libgcc.a */ +#ifdef __cplusplus +extern "C" { +extern void __eprintf (const char *, const char *, unsigned, const char *) + __attribute__ ((noreturn)); +} +#else +extern void __eprintf (const char *, const char *, unsigned, const char *) + __attribute__ ((noreturn)); +#endif + +#define assert(expression) \ + ((void) ((expression) ? 0 : __assert (#expression, __FILE__, __LINE__))) + +#define __assert(expression, file, line) \ + (__eprintf ("%s:%u: failed assertion `%s'\n", \ + file, line, expression), 0) + +#else /* no __STDC__ and not C++; i.e. -traditional. */ + +extern void __eprintf () __attribute__ ((noreturn)); /* Defined in libgcc.a */ + +#define assert(expression) \ + ((void) ((expression) ? 0 : __assert (expression, __FILE__, __LINE__))) + +#define __assert(expression, file, lineno) \ + (__eprintf ("%s:%u: failed assertion `%s'\n", \ + file, lineno, "expression"), 0) + +#endif /* no __STDC__ and not C++; i.e. -traditional. */ +#endif /* no __GNU__; i.e., /bin/cc. */ +#endif + +#endif /* FIXINC_BROKEN_ASSERT_STDLIB_CHECK */ diff --git a/more-hdrs/float.h b/more-hdrs/float.h new file mode 100644 index 00000000000..048737fd83a --- /dev/null +++ b/more-hdrs/float.h @@ -0,0 +1,9 @@ +/* This file is public domain. */ +/* This file exists soley to keep Metrowerks' compilers happy. The version + used by GCC 3.4 and later can be found in /usr/lib/gcc, although it's + not very informative. */ +#ifdef __MWERKS__ +#include "mw_float.h" +#else +#error "This header only supports __MWERKS__." +#endif diff --git a/more-hdrs/inttypes.h b/more-hdrs/inttypes.h new file mode 100644 index 00000000000..697fb7b48ac --- /dev/null +++ b/more-hdrs/inttypes.h @@ -0,0 +1,299 @@ +/* + * Copyright (c) 2000, 2001, 2002, 2003, 2004 Apple Computer, Inc. + * All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 1.1 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +/* + * <inttypes.h> -- Standard C header, defined in ISO/IEC 9899:1999 + * (aka "C99"), section 7.8. This defines format string conversion + * specifiers suitable for use within arguments to fprintf and fscanf + * and their ilk. + */ + +#if !defined(_INTTYPES_H_) +#define _INTTYPES_H_ + +#include <sys/cdefs.h> /* For __BEGIN_DECLS and __END_DECLS */ +#include <machine/ansi.h> /* For _BSD_WCHAR_T_ */ +#include <stdint.h> + +#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) + /* Translator is not ISO/IEC 9899:1999-compliant. */ +# if !defined(restrict) +# define restrict +# define __RESTRICT_KEYWORD_DEFINED__ +# endif +#endif + +/* "C++ implementations should define these macros only when + * __STDC_FORMAT_MACROS is defined before <inttypes.h> is included." + */ +#if (! defined(__cplusplus)) || defined(__STDC_FORMAT_MACROS) + +# undef __PRI_8_LENGTH_MODIFIER__ +# undef __PRI_64_LENGTH_MODIFIER__ +# undef __SCN_64_LENGTH_MODIFIER__ + +/* These could be "hh", "ll", and "ll" respectively, but that doesn't work on + 10.2, and these do. Note that there's no way to use scanf to scan a + decimal into a 'char' argument on 10.2, so "hh" is used unconditionally + and programs that use it won't work on Jaguar. */ +# define __PRI_8_LENGTH_MODIFIER__ "" /* none */ +# define __PRI_64_LENGTH_MODIFIER__ "q" +# define __SCN_64_LENGTH_MODIFIER__ "q" + +# define PRId8 __PRI_8_LENGTH_MODIFIER__ "d" +# define PRIi8 __PRI_8_LENGTH_MODIFIER__ "i" +# define PRIo8 __PRI_8_LENGTH_MODIFIER__ "o" +# define PRIu8 __PRI_8_LENGTH_MODIFIER__ "u" +# define PRIx8 __PRI_8_LENGTH_MODIFIER__ "x" +# define PRIX8 __PRI_8_LENGTH_MODIFIER__ "X" + +# define PRId16 "hd" +# define PRIi16 "hi" +# define PRIo16 "ho" +# define PRIu16 "hu" +# define PRIx16 "hx" +# define PRIX16 "hX" + +# define PRId32 "d" +# define PRIi32 "i" +# define PRIo32 "o" +# define PRIu32 "u" +# define PRIx32 "x" +# define PRIX32 "X" + +# define PRId64 __PRI_64_LENGTH_MODIFIER__ "d" +# define PRIi64 __PRI_64_LENGTH_MODIFIER__ "i" +# define PRIo64 __PRI_64_LENGTH_MODIFIER__ "o" +# define PRIu64 __PRI_64_LENGTH_MODIFIER__ "u" +# define PRIx64 __PRI_64_LENGTH_MODIFIER__ "x" +# define PRIX64 __PRI_64_LENGTH_MODIFIER__ "X" + +# define PRIdLEAST8 PRId8 +# define PRIiLEAST8 PRIi8 +# define PRIoLEAST8 PRIo8 +# define PRIuLEAST8 PRIu8 +# define PRIxLEAST8 PRIx8 +# define PRIXLEAST8 PRIX8 + +# define PRIdLEAST16 PRId16 +# define PRIiLEAST16 PRIi16 +# define PRIoLEAST16 PRIo16 +# define PRIuLEAST16 PRIu16 +# define PRIxLEAST16 PRIx16 +# define PRIXLEAST16 PRIX16 + +# define PRIdLEAST32 PRId32 +# define PRIiLEAST32 PRIi32 +# define PRIoLEAST32 PRIo32 +# define PRIuLEAST32 PRIu32 +# define PRIxLEAST32 PRIx32 +# define PRIXLEAST32 PRIX32 + +# define PRIdLEAST64 PRId64 +# define PRIiLEAST64 PRIi64 +# define PRIoLEAST64 PRIo64 +# define PRIuLEAST64 PRIu64 +# define PRIxLEAST64 PRIx64 +# define PRIXLEAST64 PRIX64 + +# define PRIdFAST8 PRId8 +# define PRIiFAST8 PRIi8 +# define PRIoFAST8 PRIo8 +# define PRIuFAST8 PRIu8 +# define PRIxFAST8 PRIx8 +# define PRIXFAST8 PRIX8 + +# define PRIdFAST16 PRId16 +# define PRIiFAST16 PRIi16 +# define PRIoFAST16 PRIo16 +# define PRIuFAST16 PRIu16 +# define PRIxFAST16 PRIx16 +# define PRIXFAST16 PRIX16 + +# define PRIdFAST32 PRId32 +# define PRIiFAST32 PRIi32 +# define PRIoFAST32 PRIo32 +# define PRIuFAST32 PRIu32 +# define PRIxFAST32 PRIx32 +# define PRIXFAST32 PRIX32 + +# define PRIdFAST64 PRId64 +# define PRIiFAST64 PRIi64 +# define PRIoFAST64 PRIo64 +# define PRIuFAST64 PRIu64 +# define PRIxFAST64 PRIx64 +# define PRIXFAST64 PRIX64 + +/* int32_t is 'int', but intptr_t is 'long'. */ +# define PRIdPTR "ld" +# define PRIiPTR "li" +# define PRIoPTR "lo" +# define PRIuPTR "lu" +# define PRIxPTR "lx" +# define PRIXPTR "lX" + +# define PRIdMAX PRId64 +# define PRIiMAX PRIi64 +# define PRIoMAX PRIo64 +# define PRIuMAX PRIu64 +# define PRIxMAX PRIx64 +# define PRIXMAX PRIX64 + +# define SCNd8 "hhd" +# define SCNi8 "hhi" +# define SCNo8 "hho" +# define SCNu8 "hhu" +# define SCNx8 "hhx" + +# define SCNd16 "hd" +# define SCNi16 "hi" +# define SCNo16 "ho" +# define SCNu16 "hu" +# define SCNx16 "hx" + +# define SCNd32 "d" +# define SCNi32 "i" +# define SCNo32 "o" +# define SCNu32 "u" +# define SCNx32 "x" + +# define SCNd64 __SCN_64_LENGTH_MODIFIER__ "d" +# define SCNi64 __SCN_64_LENGTH_MODIFIER__ "i" +# define SCNo64 __SCN_64_LENGTH_MODIFIER__ "o" +# define SCNu64 __SCN_64_LENGTH_MODIFIER__ "u" +# define SCNx64 __SCN_64_LENGTH_MODIFIER__ "x" + +# define SCNdLEAST8 SCNd8 +# define SCNiLEAST8 SCNi8 +# define SCNoLEAST8 SCNo8 +# define SCNuLEAST8 SCNu8 +# define SCNxLEAST8 SCNx8 + +# define SCNdLEAST16 SCNd16 +# define SCNiLEAST16 SCNi16 +# define SCNoLEAST16 SCNo16 +# define SCNuLEAST16 SCNu16 +# define SCNxLEAST16 SCNx16 + +# define SCNdLEAST32 SCNd32 +# define SCNiLEAST32 SCNi32 +# define SCNoLEAST32 SCNo32 +# define SCNuLEAST32 SCNu32 +# define SCNxLEAST32 SCNx32 + +# define SCNdLEAST64 SCNd64 +# define SCNiLEAST64 SCNi64 +# define SCNoLEAST64 SCNo64 +# define SCNuLEAST64 SCNu64 +# define SCNxLEAST64 SCNx64 + +# define SCNdFAST8 SCNd8 +# define SCNiFAST8 SCNi8 +# define SCNoFAST8 SCNo8 +# define SCNuFAST8 SCNu8 +# define SCNxFAST8 SCNx8 + +# define SCNdFAST16 SCNd16 +# define SCNiFAST16 SCNi16 +# define SCNoFAST16 SCNo16 +# define SCNuFAST16 SCNu16 +# define SCNxFAST16 SCNx16 + +# define SCNdFAST32 SCNd32 +# define SCNiFAST32 SCNi32 +# define SCNoFAST32 SCNo32 +# define SCNuFAST32 SCNu32 +# define SCNxFAST32 SCNx32 + +# define SCNdFAST64 SCNd64 +# define SCNiFAST64 SCNi64 +# define SCNoFAST64 SCNo64 +# define SCNuFAST64 SCNu64 +# define SCNxFAST64 SCNx64 + +# define SCNdPTR "ld" +# define SCNiPTR "li" +# define SCNoPTR "lo" +# define SCNuPTR "lu" +# define SCNxPTR "lx" + +# define SCNdMAX SCNd64 +# define SCNiMAX SCNi64 +# define SCNoMAX SCNo64 +# define SCNuMAX SCNu64 +# define SCNxMAX SCNx64 + +#endif /* if C++, then __STDC_FORMAT_MACROS enables the above macros */ + +__BEGIN_DECLS + + /* 7.8.2.1 */ + extern intmax_t imaxabs(intmax_t j); + + /* 7.8.2.2 */ + typedef struct { + intmax_t quot; + intmax_t rem; + } imaxdiv_t; + + extern imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom); + + /* 7.8.2.3 */ + extern intmax_t strtoimax(const char * restrict nptr, char ** restrict endptr, int base); + extern uintmax_t strtoumax(const char * restrict nptr, char ** restrict endptr, int base); + +#ifndef __cplusplus /* wchar_t is a built-in type in C++ */ +# ifndef _BSD_WCHAR_T_DEFINED_ +# define _BSD_WCHAR_T_DEFINED_ +# ifdef __WCHAR_TYPE__ + typedef __WCHAR_TYPE__ wchar_t; +# else /* __WCHAR_TYPE__ */ + typedef _BSD_WCHAR_T_ wchar_t; +# endif /* __WCHAR_TYPE__ */ +# endif /* _BSD_WCHAR_T_DEFINED_ */ +#endif /* __cplusplus */ + + /* 7.8.2.4 */ + extern intmax_t wcstoimax(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base); + extern uintmax_t wcstoumax(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base); + +__END_DECLS + +/* + No need to #undef the __*_{8,64}_LENGTH_MODIFIER__ macros; + in fact, you can't #undef them, because later uses of any of + their dependents will *not* then do the intended substitution. + Expansion of a #define like this one: + + #define x IDENT y + + uses the cpp value of IDENT at the location where x is *expanded*, + not where it is #defined. +*/ + +#if defined(__RESTRICT_KEYWORD_DEFINED__) +# undef restrict +# undef __RESTRICT_KEYWORD_DEFINED__ +#endif + +#endif /* !_INTTYPES_H_ */ diff --git a/more-hdrs/machine/limits.h b/more-hdrs/machine/limits.h new file mode 100644 index 00000000000..a669a7465f5 --- /dev/null +++ b/more-hdrs/machine/limits.h @@ -0,0 +1,11 @@ +/* This is the `system' limits.h, independent of any particular + compiler. GCC provides its own limits.h which can be found in + /usr/lib/gcc, although it is not very informative. + This file is public domain. */ +#if defined (__ppc__) || defined (__ppc64__) +#include <ppc/limits.h> +#elif defined (__i386__) +#include <i386/limits.h> +#else +#error architecture not supported +#endif diff --git a/more-hdrs/ppc_intrinsics.h b/more-hdrs/ppc_intrinsics.h new file mode 100644 index 00000000000..eef212d6174 --- /dev/null +++ b/more-hdrs/ppc_intrinsics.h @@ -0,0 +1,1048 @@ +/* APPLE LOCAL file PPC_INTRINSICS */ + +/* Definitions for PowerPC intrinsic instructions + Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. */ + +/* As a special exception, if you include this header file into source + files compiled by GCC, this header file does not by itself cause + the resulting executable to be covered by the GNU General Public + License. This exception does not however invalidate any other + reasons why the executable file might be covered by the GNU General + Public License. */ + +/* + * The following PowerPC intrinsics are provided by this header: + * + * Low-Level Processor Synchronization + * __eieio - Enforce In-Order Execution of I/O + * __isync - Instruction Synchronize + * __sync - Synchronize + * __lwsync - Lightweight Synchronize + * + * Manipulating the Contents of a Variable or Register + * __cntlzw - Count Leading Zeros Word + * __cntlzd - Count Leading Zeros Double Word + * __rlwimi - Rotate Left Word Immediate then Mask Insert + * __rlwinm - Rotate Left Word Immediate then AND with Mask + * __rlwnm - Rotate Left Word then AND with Mask + * + * Byte-Reversing Functions + * __lhbrx - Load Half Word Byte-Reverse Indexed + * __lwbrx - Load Word Byte-Reverse Indexed + * __sthbrx - Store Half Word Byte-Reverse Indexed + * __stwbrx - Store Word Byte-Reverse Indexed + * + * Data Cache Manipulation + * __dcba - Data Cache Block Allocate + * __dcbf - Data Cache Block Flush + * __dcbst - Data Cache Block Store + * __dcbt - Data Cache Block Touch + * __dcbtst - Data Cache Block Touch for Store + * __dcbzl - Data Cache Block Set to Zero + * __dcbz - Data Cache Block Set to Zero (32-bytes only) + * + * Setting the Floating-Point Environment + * __setflm - Set Floating-point Mode + * + * Math Functions + * __fabs - Floating-Point Absolute Value + * __fnabs - Floating Negative Absolute Value + * __fctiw - Floating Convert to Integer Word + * __fctiwz - Floating Convert to Integer Word with Round toward Zero + * __fctidz - Floating Convert to Integer Doubleword with Round toward Zero + * __fctid - Floating Convert to Integer Doubleword + * __fcfid - Floating Convert From Integer Doubleword + * __fmadd - Floating Multiply-Add (Double-Precision) + * __fmadds - Floating Multiply-Add Single + * __fmsub - Floating Multiply-Subract (Double-Precision) + * __fmsubs - Floating Multiply-Subract Single + * __fmul - Floating Multiply (Double-Precision) + * __fmuls - Floating Multiply Single + * __fnmadd - Floating Negative Multiply-Add (Double-Precision) + * __fnmadds - Floating Negative Multiply-Add Single + * __fnmsub - Floating Negative Multiply-Subtract (Double-Precision) + * __fnmsubs - Floating Negative Multiply-Subtract Single + * __fres - Floating Reciprocal Estimate + * __frsp - Floating Round to Single-Precision + * __frsqrte - Floating Reciprocal Square Root Estimate + * __frsqrtes - Floating Reciprocal Square Root Estimate Single + * __fsel - Floating Select + * __fsels - Floating Select (Single-Precision variant) + * __fsqrt - Floating-Point Square Root (Double-Precision) + * __fsqrts - Floating-Point Square Root Single-Precision + * __mulhw - Multiply High Word + * __mulhwu - Multiply High Word Unsigned + * __stfiwx - Store Floating-Point as Integer Word Indexed + * + * Miscellaneous Functions + * __nop - PPC preferred form of no operation + * __astrcmp - assembly strcmp + * __icbi - Instruction Cache Block Invalidate + * __mffs - Move from FPSCR + * __mfspr - Move from Special Purpose Register + * __mtfsf - Move to SPSCR Fields + * __mtspr - Move to Special Purpose Register + * __OSReadSwapSInt16 - lhbrx for signed shorts + * __OSReadSwapUInt16 - lhbrx for unsigned shorts + * + * TO DO: + * - Desired: + * mullw + * - Available in CodeWarrior, not yet implemented here: + * abs, labs, fabsf, fnabsf + * + * NOTES: + * - Some of the intrinsics need to be macros because certain + * parameters MUST be integer constants and not values in registers. + * - The declarations use __asm__ instead of asm and __inline__ instead + * of inline to prevent errors when -ansi is specified. + * - Some of the intrinsic definitions use the "volatile" specifier on + * the "asm" statements in order to work around what appears to be + * a bug in the compiler/optimizer. In general we have avoided the + * use of "volatile" because it suppresses optimization on the + * generated instructions. The instructions to which "volatile" + * has been added where it appears that it should not be needed are + * lhbrx and lwbrx. + * + * Contributors: Fred Forsman (editor), Turly O'Connor, Ian Ollmann, Sanjay Patel + * Last modified: October 6, 2004 + */ + +#ifndef _PPC_INTRINSICS_H_ +#define _PPC_INTRINSICS_H_ + +#if (defined(__ppc__) || defined(__ppc64__)) && ! defined(__MWERKS__) + +/******************************************************************* + * Special Purpose Registers (SPRs) * + *******************************************************************/ + +#define __SPR_MQR 0 /* PPC 601 only */ +#define __SPR_XER 1 +#define __SPR_RTCU 4 /* Real time clock upper. PPC 601 only.*/ +#define __SPR_RTCL 5 /* Real time clock lower. PPC 601 only.*/ +#define __SPR_LR 8 +#define __SPR_CTR 9 +#define __SPR_VRSAVE 256 /* AltiVec */ +#define __SPR_TBL 268 /* Time-base Lower. Not on PPC 601 */ +#define __SPR_TBU 269 /* Time-base Upper. Not on PPC 601 */ +#define __SPR_UMMCR2 928 /* PPC 74xx */ +#define __SPR_UPMC5 929 /* PPC 745x */ +#define __SPR_UPMC6 930 /* PPC 745x */ +#define __SPR_UBAMR 935 /* PPC 7400 and 7410 */ +#define __SPR_UMMCR0 936 /* PPC 74xx and 750 */ +#define __SPR_UPMC1 937 /* PPC 74xx and 750 */ +#define __SPR_UPMC2 938 /* PPC 74xx and 750 */ +#define __SPR_USIAR 939 /* PPC 74xx and 750 */ +#define __SPR_UMMCR1 940 /* PPC 74xx and 750 */ +#define __SPR_UPMC3 941 /* PPC 74xx and 750 */ +#define __SPR_UPMC4 942 /* PPC 74xx and 750 */ +#define __SPR_PIR 1023 /* supervisor level only! */ + +/* + * Shorthand macros for some commonly used SPR's. + */ +#define __mfxer() __mfspr(__SPR_XER) +#define __mflr() __mfspr(__SPR_LR) +#define __mfctr() __mfspr(__SPR_CTR) +#define __mfvrsave() __mfspr(__SPR_VRSAVE) +#define __mftb() __mfspr(__SPR_TBL) +#define __mftbu() __mfspr(__SPR_TBU) + +#define __mtlr(value) __mtspr(__SPR_LR, value) +#define __mtxer(value) __mtspr(__SPR_XER, value) +#define __mtctr(value) __mtspr(__SPR_CTR, value) +#define __mtvrsave(value) __mtspr(__SPR_VRSAVE, value) + + +/******************************************************************* + * Low-Level Processor Synchronization * + *******************************************************************/ + +/* + * __eieio - Enforce In-Order Execution of I/O + * + * void __eieio (void); + */ +#define __eieio() __asm__ ("eieio" : : : "memory") + +/* + * __isync - Instruction Synchronize + * + * void __isync (void); + */ +#define __isync() \ + __asm__ volatile ("isync") + +/* + * __sync - Synchronize + * + * void __sync (void); + */ +#define __sync() __asm__ volatile ("sync") + +/* + * __lwsync - Lightweight Synchronize, see PPC2.01, Book 2 + * + * void __lwsync (void); + */ +#define __lwsync() __asm__ volatile ("sync 1") + + +/******************************************************************* + * Byte-Reversing Functions * + *******************************************************************/ + +/* + * __lhbrx - Load Half Word Byte-Reverse Indexed + * + * int __lhbrx(void *, int); + */ +#define __lhbrx(base, index) \ + ({ unsigned short lhbrxResult; \ + __asm__ volatile ("lhbrx %0, %1, %2" : "=r" (lhbrxResult) : "b%" (index), "r" (base) : "memory"); \ + /*return*/ lhbrxResult; }) + +/* + * __lwbrx - Load Word Byte-Reverse Indexed + * + * int __lwbrx(void *, int); + */ +#define __lwbrx(base, index) \ + ({ unsigned long lwbrxResult; \ + __asm__ volatile ("lwbrx %0, %1, %2" : "=r" (lwbrxResult) : "b%" (index), "r" (base) : "memory"); \ + /*return*/ lwbrxResult; }) + +/* + * __sthbrx - Store Half Word Byte-Reverse Indexed + * + * int __sthbrx(unsigned short, void *, int); + */ +#define __sthbrx(value, base, index) \ + __asm__ ("sthbrx %0, %1, %2" : : "r" (value), "b%" (index), "r" (base) : "memory") + +/* + * __stwbrx - Store Word Byte-Reverse Indexed + * + * int __sthbrx(unsigned int, void *, int); + */ +#define __stwbrx(value, base, index) \ + __asm__ ("stwbrx %0, %1, %2" : : "r" (value), "b%" (index), "r" (base) : "memory") + + +/******************************************************************* + * Manipulating the Contents of a Variable or Register * + *******************************************************************/ + +/* + * __cntlzw - Count Leading Zeros Word + */ +static inline int __cntlzw (int value) __attribute__((always_inline)); +static inline int +__cntlzw (int value) +{ + long result; + __asm__ ("cntlzw %0, %1" + /* outputs: */ : "=r" (result) + /* inputs: */ : "r" (value)); + return result; +} + +#if defined( __ppc64__ ) +/* + * __cntlzd - Count Leading Zeros Double Word + */ +static inline long __cntlzd (long value) __attribute__((always_inline)); +static inline long +__cntlzd (long value) +{ + long result; + __asm__ ("cntlzd %0, %1" + /* outputs: */ : "=r" (result) + /* inputs: */ : "r" (value)); + return result; +} +#endif + +/* + * __rlwimi - Rotate Left Word Immediate then Mask Insert + * + * int __rlwimi(int, int, int, int, int); + * + * We don't mention "%1" below: operand[1] needs to be skipped as + * it's just a placeholder to let the compiler know that rA is read + * from as well as written to. + */ +#define __rlwimi(rA, rS, cnt, mb, me) \ + ({ __asm__ ("rlwimi %0,%2,%3,%4,%5" : "=r" (rA) \ + : "0" (rA), "r" (rS), "n" (cnt), "n" (mb), "n" (me)); \ + /*return*/ rA;}) + +/* + * __rlwinm - Rotate Left Word Immediate then AND with Mask + * + * int __rlwinm(int, int, int, int); + */ +#define __rlwinm(rS, cnt, mb, me) \ + ({ unsigned long val, src = (rS); \ + __asm__ ("rlwinm %0,%1,%2,%3,%4" : "=r" (val) \ + : "r" (src), "n" (cnt), "n" (mb), "n" (me)); \ + /*return*/ val;}) + +/* + * __rlwnm - Rotate Left Word then AND with Mask + * + * int __rlwnm(int, int, int, int); + */ +#define __rlwnm(value, leftRotateBits, maskStart, maskEnd) \ + ({ long result; \ + __asm__ ("rlwnm %0, %1, %2, %3, %4" : "=r" (result) : \ + "r" (value), "r" (leftRotateBits), "n" (maskStart), "n" (maskEnd)); \ + /*return */ result; }) + + +/******************************************************************* + * Data Cache Manipulation * + *******************************************************************/ + +/* + * --- Data Cache Block instructions --- + * + * Please see Motorola's "The Programming Environments for 32-Bit + * Microprocessors" for a description of what these do. + * + * Parameter descriptions: + * + * base starting address for figuring out where the + * cacheline is + * + * index byte count to be added to the base address for + * purposes of calculating the effective address + * of the cacheline to be operated on. + * + * Effective Address of cacheline to be manipulated = + * (char*) base + index + * + * WARNING: The size and alignment of cachelines are subject to + * change on future processors! Cachelines are 32 bytes in + * size and are aligned to 32 bytes on PowerPC 601, 603, 604, + * 750, 7400, 7410, 7450, and 7455. + * + */ + +/* + * __dcba - Data Cache Block Allocate + * + * void __dcba(void *, int) + * + * WARNING: dcba is a valid instruction only on PowerPC 7400, 7410, + * 7450 and 7455. + */ +#define __dcba(base, index) \ + __asm__ ("dcba %0, %1" : /*no result*/ : "b%" (index), "r" (base) : "memory") + +/* + * __dcbf - Data Cache Block Flush + * + * void __dcbf(void *, int); + */ +#define __dcbf(base, index) \ + __asm__ ("dcbf %0, %1" : /*no result*/ : "b%" (index), "r" (base) : "memory") + +/* + * __dcbst - Data Cache Block Store + * + * void __dcbst(void *, int); + */ +#define __dcbst(base, index) \ + __asm__ ("dcbst %0, %1" : /*no result*/ : "b%" (index), "r" (base) : "memory") + +/* + * __dcbt - Data Cache Block Touch + * + * void __dcbt(void *, int); + */ +#define __dcbt(base, index) \ + __asm__ ("dcbt %0, %1" : /*no result*/ : "b%" (index), "r" (base) : "memory") + +/* + * __dcbtst - Data Cache Block Touch for Store + * + * void __dcbtst(void *, int); + */ +#define __dcbtst(base, index) \ + __asm__ ("dcbtst %0, %1" : /*no result*/ : "b%" (index), "r" (base) : "memory") + +/* + * __dcbzl - Data Cache Block Set to Zero + * + * void __dcbzl(void *, int); + */ +#define __dcbzl(base, index) \ + __asm__ ("dcbzl %0, %1" : /*no result*/ : "b%" (index), "r" (base) : "memory") + +/* + * __dcbz - Data Cache Block Set to Zero (32-bytes only) + * + * WARNING: this is for legacy purposes only + * + * void __dcbz(void *, int); + */ +#define __dcbz(base, index) \ + __asm__ ("dcbz %0, %1" : /*no result*/ : "b%" (index), "r" (base) : "memory") + + +/******************************************************************* + * Setting the Floating-Point Environment * + *******************************************************************/ + +/* + * __setflm - Set Floating-point Mode + * + * Sets the FPSCR (floating-point status and control register), + * returning the original value. + * + * ??? CW: float __setflm(float); + */ +static inline double __setflm (double newflm) __attribute__((always_inline)); +static inline double +__setflm(double newflm) +{ + double original; + + __asm__ ("mffs %0" + /* outputs: */ : "=f" (original)); + __asm__ ("mtfsf 255,%0" + /* outputs: */ : /* none */ + /* inputs: */ : "f" (newflm)); + return original; +} + + +/******************************************************************* + * Math Functions * + *******************************************************************/ + +/* + * __fabs - Floating-Point Absolute Value + */ +static inline double __fabs (double value) __attribute__((always_inline)); +static inline double +__fabs (double value) +{ + double result; + __asm__ ("fabs %0, %1" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (value)); + return result; +} + +/* + * __fnabs - Floating Negative Absolute Value + */ +static inline double __fnabs (double b) __attribute__((always_inline)); +static inline double +__fnabs (double b) +{ + double result; + __asm__ ("fnabs %0, %1" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (b)); + return result; +} + +/* + * fctiw - Floating Convert to Integer Word + * + * Convert the input value to a signed long and place in the low 32 + * bits of the FP register. Clip to LONG_MIN or LONG_MAX if the FP + * value exceeds the range representable by a long. Use the rounding + * mode indicated in the FPSCR. + */ +static inline double __fctiw (double b) __attribute__((always_inline)); +static inline double +__fctiw (double b) +{ + double result; + __asm__ ("fctiw %0, %1" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (b)); + return result; +} + +/* + * fctiwz - Floating Convert to Integer Word with Round toward Zero + * + * Convert the input value to a signed long and place in the low 32 + * bits of the FP register. Clip to LONG_MIN or LONG_MAX if the FP + * value exceeds the range representable by a long. + */ +static inline double __fctiwz (double b) __attribute__((always_inline)); +static inline double +__fctiwz (double b) +{ + double result; + __asm__ ("fctiwz %0, %1" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (b)); + return result; +} + +/* + * fctidz - Floating Convert to Integer Double Word with Round toward Zero + * + * Convert the input value to a signed 64-bit int and place in the FP + * destination register. Clip to LLONG_MIN (-2**63) or LLONG_MAX (2**63-1) + * if the FP value exceeds the range representable by a int64_t. + * + * WARNING: fctidz is a valid instruction only on 64-bit PowerPC + */ +static inline double __fctidz (double b) __attribute__((always_inline)); +static inline double +__fctidz (double b) +{ + double result; + __asm__ ("fctidz %0, %1" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (b)); + return result; +} + +/* + * fctid - Floating Convert to Integer Double Word + * + * Convert the input value to a signed 64-bit int and place in the FP + * destination register. Clip to LLONG_MIN (-2**63) or LLONG_MAX (2**63-1) + * if the FP value exceeds the range representable by a int64_t. Use the + * rounding mode indicated in the FPSCR. + * + * WARNING: fctid is a valid instruction only on 64-bit PowerPC + */ +static inline double __fctid (double b) __attribute__((always_inline)); +static inline double +__fctid (double b) +{ + double result; + __asm__ ("fctid %0, %1" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (b)); + return result; +} + +/* + * fcfid - Floating Convert From Integer Double Word + * + * Convert the 64-bit signed integer input value to a 64-bit FP value. + * Use the rounding mode indicated in the FPSCR if the integer is out of + * double precision range. + * + * WARNING: fcfid is a valid instruction only on 64-bit PowerPC + */ +static inline double __fcfid (double b) __attribute__((always_inline)); +static inline double +__fcfid (double b) +{ + double result; + __asm__ ("fcfid %0, %1" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (b)); + return result; +} + +/* + * fmadd - Floating Multiply-Add (Double-Precision) + * + * (a * c + b) double precision + */ +static inline double __fmadd (double a, double c, double b) __attribute__((always_inline)); +static inline double +__fmadd (double a, double c, double b) +{ + double result; + __asm__ ("fmadd %0, %1, %2, %3" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (a), "f" (c), "f" (b)); + return result; +} + +/* + * fmadds - Floating Multiply-Add Single + * + * (a * c + b) single precision + * + * Double precision arguments are used to prevent the compiler from + * issuing frsp instructions upstream. + */ +static inline float __fmadds (double a, double c, double b) __attribute__((always_inline)); +static inline float +__fmadds (double a, double c, double b) +{ + float result; + __asm__ ("fmadds %0, %1, %2, %3" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (a), "f" (c), "f" (b)); + return result; +} + +/* + * fmsub - Floating Multiply-Subract (Double-Precision) + * + * (a * c - b) double precision + */ +static inline double __fmsub (double a, double c, double b) __attribute__((always_inline)); +static inline double +__fmsub (double a, double c, double b) +{ + double result; + __asm__ ("fmsub %0, %1, %2, %3" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (a), "f" (c), "f" (b)); + return result; +} + +/* + * fmsubs - Floating Multiply-Subract Single + * + * (a * c - b) single precision + * + * Double precision arguments are used to prevent the compiler from + * issuing frsp instructions upstream. + */ +static inline float __fmsubs (double a, double c, double b) __attribute__((always_inline)); +static inline float +__fmsubs (double a, double c, double b) +{ + float result; + __asm__ ("fmsubs %0, %1, %2, %3" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (a), "f" (c), "f" (b)); + return result; +} + +/* + * fmul - Floating Multiply (Double-Precision) + * + * (a * c) double precision + */ +static inline double __fmul (double a, double c) __attribute__((always_inline)); +static inline double +__fmul (double a, double c) +{ + double result; + __asm__ ("fmul %0, %1, %2" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (a), "f" (c)); + return result; +} + +/* + * fmuls - Floating Multiply Single + * + * (a * c) single precision + * + * Double precision arguments are used to prevent the compiler from + * issuing frsp instructions upstream. + */ +static inline float __fmuls (double a, double c) __attribute__((always_inline)); +static inline float +__fmuls (double a, double c) +{ + float result; + __asm__ ("fmuls %0, %1, %2" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (a), "f" (c)); + return result; +} + +/* + * __fnmadd - Floating Negative Multiply-Add (Double-Precision) + * + * -(a * c + b) double precision + */ +static inline double __fnmadd (double a, double c, double b) __attribute__((always_inline)); +static inline double +__fnmadd (double a, double c, double b) +{ + double result; + __asm__ ("fnmadd %0, %1, %2, %3" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (a), "f" (c), "f" (b)); + return result; +} + +/* + * __fnmadds - Floating Negative Multiply-Add Single + * + * -(a * c + b) single precision + * + * Double precision arguments are used to prevent the compiler from + * issuing frsp instructions upstream. + */ +static inline float __fnmadds (double a, double c, double b) __attribute__((always_inline)); +static inline float +__fnmadds (double a, double c, double b) +{ + float result; + __asm__ ("fnmadds %0, %1, %2, %3" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (a), "f" (c), "f" (b)); + return result; +} + +/* + * __fnmsub - Floating Negative Multiply-Subtract (Double-Precision) + * + * -(a * c - B) double precision + */ +static inline double __fnmsub (double a, double c, double b) __attribute__((always_inline)); +static inline double +__fnmsub (double a, double c, double b) +{ + double result; + __asm__ ("fnmsub %0, %1, %2, %3" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (a), "f" (c), "f" (b)); + return result; +} + +/* + * __fnmsubs - Floating Negative Multiply-Subtract Single + * + * -(a * c - b) single precision + * + * Double precision arguments are used to prevent the compiler from + * issuing frsp instructions upstream. + */ +static inline float __fnmsubs (double a, double c, double b) __attribute__((always_inline)); +static inline float +__fnmsubs (double a, double c, double b) +{ + float result; + __asm__ ("fnmsubs %0, %1, %2, %3" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (a), "f" (c), "f" (b)); + return result; +} + +/* + * __fres - Floating Reciprocal Estimate + * + * Produces a double precision result with 5 bits of accuracy. + * Note: not valid on the PowerPC 601. + * + * ??? CW: float __fres(float) + */ +static inline float __fres (float val) __attribute__((always_inline)); +static inline float +__fres (float val) +{ + float estimate; + __asm__ ("fres %0,%1" + /* outputs: */ : "=f" (estimate) + /* inputs: */ : "f" (val)); + return estimate; +} + +/* + * __frsp - Floating Round to Single-Precision + */ +static inline float __frsp (double d) __attribute__((always_inline)); +static inline float +__frsp (double d) +{ + float result; + __asm__ ("frsp %0, %1" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (d)); + return result; +} + +/* + * __frsqrte - Floating Reciprocal Square Root Estimate + * + * Note: not valid on the PowerPC 601. + */ +static inline double __frsqrte (double val) __attribute__((always_inline)); +static inline double +__frsqrte (double val) +{ + double estimate; + + __asm__ ("frsqrte %0,%1" + /* outputs: */ : "=f" (estimate) + /* inputs: */ : "f" (val)); + return estimate; +} + +/* + * __frsqrtes - Floating Reciprocal Square Root Estimate Single + */ +static inline float __frsqrtes (double f) __attribute__((always_inline)); +static inline float +__frsqrtes (double f) +{ + float result; + __asm__ ("frsqrte %0, %1" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (f)); + return result; +} + +/* + * __fsel - Floating Select + * + * if (test >= 0) return a; else return b; + * + * Note: not valid on the PowerPC 601. + */ +static inline double __fsel (double test, double a, double b) __attribute__((always_inline)); +static inline double +__fsel (double test, double a, double b) +{ + double result; + __asm__ ("fsel %0,%1,%2,%3" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (test), "f" (a), "f" (b)); + return result; +} + +/* + * __fsels - Floating Select (Single-Precision variant) + * + * An artificial single precision variant of fsel. This produces the + * same results as fsel, but is useful because the result is cast as + * a float, discouraging the compiler from issuing a frsp instruction + * afterward. + */ +static inline float __fsels (double test, double a, double b) __attribute__((always_inline)); +static inline float +__fsels (double test, double a, double b) +{ + float result; + __asm__ ("fsel %0,%1,%2,%3" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (test), "f" (a), "f" (b)); + return result; +} + +/* + * __fsqrt - Floating-Point Square Root (Double-Precision) + * + * WARNING: Illegal instruction for PowerPC 603, 604, 750, 7400, 7410, + * 7450, and 7455 + */ +static inline double __fsqrt (double b) __attribute__((always_inline)); +static inline double +__fsqrt(double d) +{ + double result; + __asm__ ("fsqrt %0, %1" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (d)); + return result; +} + +/* + * __fsqrts - Floating-Point Square Root Single-Precision + * + * WARNING: Illegal instruction for PowerPC 603, 604, 750, 7400, 7410, + * 7450, and 7455 + */ +static inline float __fsqrts (float f) __attribute__((always_inline)); +static inline float +__fsqrts (float f) +{ + float result; + __asm__ ("fsqrts %0, %1" + /* outputs: */ : "=f" (result) + /* inputs: */ : "f" (f)); + return result; +} + +/* + * __mulhw - Multiply High Word + */ +static inline int __mulhw (int a, int b) __attribute__((always_inline)); +static inline int +__mulhw (int a, int b) +{ + long result; + __asm__ ("mulhw %0, %1, %2" + /* outputs: */ : "=r" (result) + /* inputs: */ : "r" (a), "r"(b)); + return result; +} + +/* + * __mulhwu - Multiply High Word Unsigned + */ +static inline unsigned int __mulhwu (unsigned int a, unsigned int b) __attribute__((always_inline)); +static inline unsigned int +__mulhwu (unsigned int a, unsigned int b) +{ + unsigned long result; + __asm__ ("mulhwu %0, %1, %2" + /* outputs: */ : "=r" (result) + /* inputs: */ : "r" (a), "r"(b)); + return result; +} + +/* + * __stfiwx - Store Floating-Point as Integer Word Indexed + * + * void x(int, void *, int); + */ +#define __stfiwx(value, base, index) \ + __asm__ ("stfiwx %0, %1, %2" : /*no result*/ \ + : "f" (value), "b%" (index), "r" (base) : "memory") + + +/******************************************************************* + * Miscellaneous Functions * + *******************************************************************/ + +/* + * __nop - no operation (PowerPC preferred form) + * + * void __nop(); + */ +#define __nop() \ + __asm__ ("ori 0,0,0") + +/* + * __icbi - Instruction Cache Block Invalidate + * + * void __icbi(void *, int); + */ +#define __icbi(base, index) \ + __asm__ ("icbi %0, %1" : /*no result*/ : "b%" (index), "r" (base) : "memory") + +/* + * __mffs - Move from FPSCR + */ +static inline double __mffs (void) __attribute__((always_inline)); +static inline double +__mffs (void) +{ + double result; + __asm__ volatile ("mffs %0" + /* outputs: */ : "=f" (result)); + return result; +} + +/* + * __mfspr - Move from Special Purpose Register + * + * int __mfspr(int); + */ +#define __mfspr(spr) \ + __extension__ ({ long mfsprResult; \ + __asm__ volatile ("mfspr %0, %1" : "=r" (mfsprResult) : "n" (spr)); \ + /*return*/ mfsprResult; }) + +/* + * __mtfsf - Move to SPSCR Fields + * + * void __mtfsf(int, int); + */ +#define __mtfsf(mask, newValue) \ + __asm__ volatile ("mtfsf %0, %1" : : "n" (mask), "f" (newValue)) + +/* + * __mtspr - Move to Special Purpose Register + * + * __mtspr x(int, int); + */ +#define __mtspr(spr, value) \ + __asm__ volatile ("mtspr %0, %1" : : "n" (spr), "r" (value)) + +/* + * __OSReadSwapSInt16 + * + * lhbrx for signed shorts. This will do the required sign + * extension after load and byteswap. + */ +static inline signed short __OSReadSwapSInt16 (signed short *base, int index) __attribute__((always_inline)); +static inline signed short +__OSReadSwapSInt16 (signed short *base, int index) +{ + signed long result; + __asm__ volatile ("lhbrx %0, %1, %2" + /* outputs: */ : "=r" (result) + /* inputs: */ : "b%" (index), "r" (base) + /* clobbers: */ : "memory"); + return result; +} + +/* + * __OSReadSwapUInt16 + */ +static inline unsigned short __OSReadSwapUInt16 (volatile void *base, int inex) __attribute__((always_inline)); +static inline unsigned short +__OSReadSwapUInt16 (volatile void *base, int index) +{ + unsigned long result; + __asm__ volatile ("lhbrx %0, %1, %2" + /* outputs: */ : "=r" (result) + /* inputs: */ : "b" (index), "r" (base) + /* clobbers: */ : "memory"); + return result; +} + +/* + * __astrcmp - assembly strcmp + */ +static inline int astrcmp (const char *in_s1, const char *in_s2) __attribute__((always_inline)); +static inline int +astrcmp (const char *in_s1, const char *in_s2) +{ + int result, temp; + register const char *s1 = in_s1 - 1; + register const char *s2 = in_s2 - 1; + + __asm__ ("1:lbzu %0,1(%1)\n" + "\tcmpwi cr1,%0,0\n" + "\tlbzu %3,1(%2)\n" + "\tsubf. %0,%3,%0\n" + "\tbeq- cr1,2f\n" + "\tbeq+ 1b\n2:" + /* outputs: */ : "=&r" (result), "+b" (s1), "+b" (s2), "=r" (temp) + /* inputs: */ : + /* clobbers: */ : "cr0", "cr1", "memory"); + + return result; + + /* + * "=&r" (result) means: 'result' is written on (the '='), it's any GP + * register (the 'r'), and it must not be the same as + * any of the input registers (the '&'). + * "+b" (s1) means: 's1' is read from and written to (the '+'), + * and it must be a base GP register (i.e., not R0.) + * "=r" (temp) means: 'temp' is any GP reg and it's only written to. + * + * "memory" in the 'clobbers' section means that gcc will make + * sure that anything that should be in memory IS there + * before calling this routine. + */ +} + +#endif /* (defined(__ppc__) || defined(__ppc64__)) && ! defined(__MWERKS__) */ + +#endif /* _PPC_INTRINSICS_H_ */ diff --git a/more-hdrs/stdarg.h b/more-hdrs/stdarg.h new file mode 100644 index 00000000000..e12e16383c6 --- /dev/null +++ b/more-hdrs/stdarg.h @@ -0,0 +1,6 @@ +/* This file is public domain. */ +#ifdef __MWERKS__ +#include "mw_stdarg.h" +#else +#error "This header only supports __MWERKS__." +#endif diff --git a/more-hdrs/stdbool.h b/more-hdrs/stdbool.h new file mode 100644 index 00000000000..de5287ef12b --- /dev/null +++ b/more-hdrs/stdbool.h @@ -0,0 +1,10 @@ +/* This file is public domain. */ +/* stdbool.h has moved to avoid accidental use with a non-GCC + compiler. Only GCC should have used stdbool.h due to licensing + restrictions. */ +#ifdef __MWERKS__ +#include "mw_stdbool.h" +#else +#error "This header only supports __MWERKS__." +#endif + diff --git a/more-hdrs/stdint.h b/more-hdrs/stdint.h new file mode 100644 index 00000000000..d7f97e332be --- /dev/null +++ b/more-hdrs/stdint.h @@ -0,0 +1,245 @@ +/* + * Copyright (c) 2000, 2001, 2003, 2004 Apple Computer, Inc. + * All rights reserved. + */ + +#ifndef _STDINT_H_ +#define _STDINT_H_ + +/* from ISO/IEC 988:1999 spec */ + +/* 7.18.1.1 Exact-width integer types */ +#ifndef _INT8_T +#define _INT8_T +typedef signed char int8_t; +#endif /*_INT8_T */ + +#ifndef _INT16_T +#define _INT16_T +typedef short int16_t; +#endif /* _INT16_T */ + +#ifndef _INT32_T +#define _INT32_T +typedef int int32_t; +#endif /* _INT32_T */ + +#ifndef _INT64_T +#define _INT64_T +typedef long long int64_t; +#endif /* _INT64_T */ + +#ifndef _UINT8_T +#define _UINT8_T +typedef unsigned char uint8_t; +#endif /*_UINT8_T */ + +#ifndef _UINT16_T +#define _UINT16_T +typedef unsigned short uint16_t; +#endif /* _UINT16_T */ + +#ifndef _UINT32_T +#define _UINT32_T +typedef unsigned int uint32_t; +#endif /* _UINT32_T */ + +#ifndef _UINT64_T +#define _UINT64_T +typedef unsigned long long uint64_t; +#endif /* _UINT64_T */ + +/* 7.18.1.2 Minimum-width integer types */ +typedef int8_t int_least8_t; +typedef int16_t int_least16_t; +typedef int32_t int_least32_t; +typedef int64_t int_least64_t; +typedef uint8_t uint_least8_t; +typedef uint16_t uint_least16_t; +typedef uint32_t uint_least32_t; +typedef uint64_t uint_least64_t; + + +/* 7.18.1.3 Fastest-width integer types */ +typedef int8_t int_fast8_t; +typedef int16_t int_fast16_t; +typedef int32_t int_fast32_t; +typedef int64_t int_fast64_t; +typedef uint8_t uint_fast8_t; +typedef uint16_t uint_fast16_t; +typedef uint32_t uint_fast32_t; +typedef uint64_t uint_fast64_t; + + +/* 7.18.1.4 Integer types capable of holding object pointers */ + +#ifndef _INTPTR_T +#define _INTPTR_T +typedef long intptr_t; +#endif /* _INTPTR_T */ + +#ifndef _UINTPTR_T +#define _UINTPTR_T +typedef unsigned long uintptr_t; +#endif /* _UINTPTR_T */ + + +/* 7.18.1.5 Greatest-width integer types */ +#ifndef _INTMAX_T +#define _INTMAX_T +#ifdef __INTMAX_TYPE__ +typedef __INTMAX_TYPE__ intmax_t; +#else /* __INTMAX_TYPE__ */ +typedef long long intmax_t; +#endif /* __INTMAX_TYPE__ */ +#endif /* _INTMAX_T */ + +#ifndef _UINTMAX_T +#define _UINTMAX_T +#ifdef __UINTMAX_TYPE__ +typedef __UINTMAX_TYPE__ uintmax_t; +#else /* __UINTMAX_TYPE__ */ +typedef unsigned long long uintmax_t; +#endif /* __UINTMAX_TYPE__ */ +#endif /* _UINTMAX_T */ + +/* "C++ implementations should define these macros only when + * __STDC_LIMIT_MACROS is defined before <stdint.h> is included." + * In other words, if C++, then __STDC_LIMIT_MACROS enables the + * macros below. (Note that there also exists a different enabling + * macro (__STDC_CONSTANT_MACROS) for the last few, below.) + */ +#if (! defined(__cplusplus)) || defined(__STDC_LIMIT_MACROS) + + +/* 7.18.2 Limits of specified-width integer types: + * These #defines specify the minimum and maximum limits + * of each of the types declared above. + */ + + +/* 7.18.2.1 Limits of exact-width integer types */ +#define INT8_MAX 127 +#define INT16_MAX 32767 +#define INT32_MAX 2147483647 +#define INT64_MAX 9223372036854775807LL + +#define INT8_MIN -128 +#define INT16_MIN -32768 + /* + Note: the literal "most negative int" cannot be written in C -- + the rules in the standard (section 6.4.4.1 in C99) will give it + an unsigned type, so INT32_MIN (and the most negative member of + any larger signed type) must be written via a constant expression. + */ +#define INT32_MIN (-INT32_MAX-1) +#define INT64_MIN (-INT64_MAX-1) + +#define UINT8_MAX 255 +#define UINT16_MAX 65535 +#define UINT32_MAX 4294967295U +#define UINT64_MAX 18446744073709551615ULL + +/* 7.18.2.2 Limits of minimum-width integer types */ +#define INT_LEAST8_MIN INT8_MIN +#define INT_LEAST16_MIN INT16_MIN +#define INT_LEAST32_MIN INT32_MIN +#define INT_LEAST64_MIN INT64_MIN + +#define INT_LEAST8_MAX INT8_MAX +#define INT_LEAST16_MAX INT16_MAX +#define INT_LEAST32_MAX INT32_MAX +#define INT_LEAST64_MAX INT64_MAX + +#define UINT_LEAST8_MAX UINT8_MAX +#define UINT_LEAST16_MAX UINT16_MAX +#define UINT_LEAST32_MAX UINT32_MAX +#define UINT_LEAST64_MAX UINT64_MAX + +/* 7.18.2.3 Limits of fastest minimum-width integer types */ +#define INT_FAST8_MIN INT8_MIN +#define INT_FAST16_MIN INT16_MIN +#define INT_FAST32_MIN INT32_MIN +#define INT_FAST64_MIN INT64_MIN + +#define INT_FAST8_MAX INT8_MAX +#define INT_FAST16_MAX INT16_MAX +#define INT_FAST32_MAX INT32_MAX +#define INT_FAST64_MAX INT64_MAX + +#define UINT_FAST8_MAX UINT8_MAX +#define UINT_FAST16_MAX UINT16_MAX +#define UINT_FAST32_MAX UINT32_MAX +#define UINT_FAST64_MAX UINT64_MAX + +/* 7.18.2.4 Limits of integer types capable of holding object pointers */ + +#define INTPTR_MIN INT32_MIN +#define INTPTR_MAX INT32_MAX + +#define UINTPTR_MAX UINT32_MAX + +/* 7.18.2.5 Limits of greatest-width integer types */ +#define INTMAX_MIN INT64_MIN +#define INTMAX_MAX INT64_MAX + +#define UINTMAX_MAX UINT64_MAX + +/* 7.18.3 "Other" */ +#define PTRDIFF_MIN INT32_MIN +#define PTRDIFF_MAX INT32_MAX + +/* We have no sig_atomic_t yet, so no SIG_ATOMIC_{MIN,MAX}. + Should end up being {-127,127} or {0,255} ... or bigger. + My bet would be on one of {U}INT32_{MIN,MAX}. */ + +#define SIZE_MAX UINT32_MAX + +#ifndef WCHAR_MAX +# ifdef __WCHAR_MAX__ +# define WCHAR_MAX __WCHAR_MAX__ +# else +# define WCHAR_MAX 0x7fffffff +# endif +#endif + +/* WCHAR_MIN should be 0 if wchar_t is an unsigned type and + (-WCHAR_MAX-1) if wchar_t is a signed type. Unfortunately, + it turns out that -fshort-wchar changes the signedness of + the type. */ +#if WCHAR_MAX == 0xffff +# define WCHAR_MIN 0 +#else +# define WCHAR_MIN (-WCHAR_MAX-1) +#endif + +#define WINT_MIN INT32_MIN +#define WINT_MAX INT32_MAX + +#define SIG_ATOMIC_MIN INT32_MIN +#define SIG_ATOMIC_MAX INT32_MAX + +#endif /* if C++, then __STDC_LIMIT_MACROS enables the above macros */ + +/* "C++ implementations should define these macros only when + * __STDC_CONSTANT_MACROS is defined before <stdint.h> is included." + */ +#if (! defined(__cplusplus)) || defined(__STDC_CONSTANT_MACROS) + +/* 7.18.4 Macros for integer constants */ +#define INT8_C(v) (v) +#define INT16_C(v) (v) +#define INT32_C(v) (v ## L) +#define INT64_C(v) (v ## LL) + +#define UINT8_C(v) (v ## U) +#define UINT16_C(v) (v ## U) +#define UINT32_C(v) (v ## UL) +#define UINT64_C(v) (v ## ULL) + +#define INTMAX_C(v) (v ## LL) +#define UINTMAX_C(v) (v ## ULL) + +#endif /* if C++, then __STDC_CONSTANT_MACROS enables the above macros */ + +#endif /* _STDINT_H_ */ diff --git a/more-hdrs/varargs.h b/more-hdrs/varargs.h new file mode 100644 index 00000000000..83188caef34 --- /dev/null +++ b/more-hdrs/varargs.h @@ -0,0 +1,6 @@ +/* This file is public domain. */ +#ifdef __MWERKS__ +#include "mw_varargs.h" +#else +#error "This header only supports __MWERKS__." +#endif diff --git a/order-files/HOW TO BUILD b/order-files/HOW TO BUILD new file mode 100644 index 00000000000..7cca046f37a --- /dev/null +++ b/order-files/HOW TO BUILD @@ -0,0 +1,170 @@ + Creating Order files, i.e., Scatter Loading the Compiler + -------------------------------------------------------- + +This is a brief description on how to generate the cc1*.order files. +The order files are intended to minimize the number of page-ins of +the compiler as it is loaded. If there is enough memory this +benifits only the first load of the compiler since it will stay +resident after that. + +Unfortunately it's a manual process since one of the tools requires +an explicit interrupt from the terminal. You should only need to +(re)do the order files if there's any major reorganizations or +additions to the compilers. + +There are five steps involved to genrrate the order files. + +1. Select test cases. + + These should be "average" compilations to exercise each of the + cc1* compilers. They should be large enough to take enough time + to generate acceptible results. As of this writing the + following cases were chosen: + + For cc1 - gcc/c-decl.c (from the compiler sources) + For cc1plus - Finder_FE/AboutWindow/AboutWindow.cp + For cc1obj - MailViewer/Compose.subproj/MessageEditor.m + For cc1objplus - devkit/cpp.subproj/Cpp-precomp.mm + + Of these four the cc1objplus test case is not very good. + Unfortunately there are few .mm files of any significant size. + If a better one can be found it probably should be used. + +2. Capture the command lines needed to build the chosen files. + + For the selected projects built with with PB set PB's building + preferences for detailed build logs. That way you can the + full command lines you need. In non-PB projects like gcc the + command lines are of course echoed on the terminal. + +3. Run selected command lines with -### to get the cc1* lines. + + From the full command lines you need the cc1* lines generated + by the driver. The easiest way to get these is to add -### + to the full command lines captured in step 2. + +4. Prepare to generate the order files + + If you don't already have it you should build a set of cc1* + compilers with -O2 with symbols. The easiest way to do this + is FSF-style but using buildit with build_gcc probably will + also work. + + In the gcc objects directory you will of course have the cc1* + compilers. You need to substitute these in each of the cc1* + command lines captured in step 3. You also need to run these + with ~perf/bin/pcsample to generate the order files. Thus, + for each cc1* command line it should have the following in + the beginning in place of the original cc1* of the step 3 + lines. + + sudo ~perf/bin/pcsample -O -E $gcc3-obj/cc1* ... rest of line... + + Where $gcc3-obj represents whatever the path is to the gcc3 + objects directory and cc1* is one of the cc1* compilers (is + -B necessary here?). + + Note, you need sudo because pcsample will only run as root. + Also, if you have a dual processor you need to reboot as in + single processor mode. If you don't pcscample will tell you + to do that by executing the command, + + nvram boot-args="cpus=1" + +5. Generate the order files + + Run the lines created in step 4. The order files (cc1*.order) + will be left in /tmp in the direectory indicated by the summary + that pcsample displays when you hit cmd-c to stop the pcsample + execution. Be sure to run pcsample long enough to compile the + entire program. + + At this point you now have the order files created. You place + them in the order-files directory at the top level of the gcc + source directory. + + You can also use them to measure he effects of these order files + on compiler page-ins. If you do this go to the next step (6). + Otherwisw you are ready to go. + +6. Creating the compilers with ther order files + + You will need two versions of the cc1* files; the ones from above + and a set linked with their respective order file. + + From a gcc compiler build extract the command lines that link + the cc1* files. Change the -o file to something else, for + example, cc1 to cc1X. Then add the following options to the + link line. Note, if you build using buildit and build_gcc the + lines will already be there referencing the order-files + directory. Otherwise you need to add, + + -sectorder __TEXT __text $order/cc1*.order -e start + + where $order is the directory containing the order file being + used and cc1* is of course a reference to a specific order + file. + + 7. Measuring the performance improvement + + You need to have two terminbal windows open; T1 and T2. The + execute the follwoing commands on the indicated terminals: + + T2: sudo fs_usage -w > /tmp/fs.out1 (do NOT execute yet) + T1: ~perf/bin/flushmem (note this can take a while) + T2: fs_usage + T1: use cc1* line originally used to build order file + T2: ctl-c when cc1* compilation done + + T2: sudo fs_usage -w > /tmp/fs.out2 (do not execute yet) + T1: ~perf/bin/flushmem + T2: fs_usage + T1: use cc1*X line originally used to build order file + T2: ctl-c when cc1XXX compilation done + + In the first group of commands you use the original cc1* line + with the command line used to build the order file. You also + run fs_usage at the same time to measure the paging behavior. + + The second group of commands is similar but you use the cc1* + linked with its order file (with the -sectorder stuff mentioned + in step 6). For this discussion call this compiler cc1*X. + + In both cases you need to run ~perf/bin/flushmem to make sure + compiler is flused from the cached. That way you are + measuring the initial page-in bechavor as thee compiler is + loaded. Warning, the flushmem's sometimes take quite a + while. + + At this point you should have /tmp/fs.out1 and /tmp/fs.out2. + You need to extract the page-ins times for the compilers in + order to sum them up. The easies way to do this is make the + data tab delimited for importing into Excel. + + T1: fgrep cc1* /tmp/fs.out1 | fgrep PAGE_IN | \ + tr -s "[:blank:]" '\t' >/tmp/cc1*.pageins-1 + T1: fgrep cc1*X /tmp/fs.out2 | fgrep PAGE_IN | \ + tr -s "[:blank:]" '\t' >/tmp/cc1*.pageins-2 + + Load each of these into Excel and sum the pagin times to + determine the percent change. + + Remember that the '*'s in the above illustrations are not really + a '*'. It is just a short way to show the general command lines + where in reality you explicitly specify cc1, cc1plus, cc1obj, or + cc1objplus. + + Also remember that you are measuring the page-in performance + improvement on the test cases used to generate the order files + in the first place. Thus you should expect that these would + probably show the greatest improvement. That is why it is + important to try to choose representative test cases in the + first place. You can try the measurements on other tests. + But that requires you again extracting the cc1* lines using + -###. The above procedure only uses the orignal files since + the command lines are already handy. + + + + + diff --git a/order-files/cc1.order b/order-files/cc1.order new file mode 100644 index 00000000000..a3bd7b04a39 --- /dev/null +++ b/order-files/cc1.order @@ -0,0 +1,1188 @@ +start +__start +__dyld_init_check +dyld_stub_binding_helper +___darwin_gcc3_preregister_frame_info +__call_mod_init_funcs +__dyld_func_lookup +_main +_toplev_main +_hex_init +_general_init +_xmalloc_set_program_name +_diagnostic_initialize +__obstack_begin +_xmalloc +_parse_options_and_default_flags +_init_reg_sets +_add_params +_xrealloc +_pfe_init +_override_O_option +_extract_override_options +_lang_init_options +_c_common_init_options +_cpp_create_reader +_init_library +_init_trigraph_map +_xcalloc +_set_lang +_deps_init +_init_line_maps +__cpp_init_tokenrun +__cpp_get_buff +_new_buff +_pfe_s_malloc +_pfe_malloc +_gcc_obstack_init +_pfe_obstack_chuck_alloc +__cpp_init_includes +_splay_tree_new +_splay_tree_new_with_allocator +_splay_tree_xmalloc_allocate +_set_index_lang +_set_target_switch +_optimization_options +_override_option +_c_decode_option +_cpp_handle_option +_parse_option +_independent_decode_option +_xstrdup +_append_include_chain +__cpp_simplify_pathname +_remove_component_p +_new_pending_directive +_dump_switch_p +_decode_f_option +_decode_g_option +_set_Wunused +_set_Wformat +_decode_W_option +_add_env_options +_c_common_post_options +_cpp_post_options +_init_dependency_output +_do_compile +_process_options +_rs6000_override_options +_rs6000_parse_abi_options +_rs6000_add_gc_roots +_ggc_add_rtx_root +_ggc_add_root +_htab_create +_higher_prime_number +_machopic_add_gc_roots +_ggc_add_tree_root +_new_alias_set +_floor_log2_wide +_init_timevar +_timevar_start +_lang_independent_init +_init_ggc +_exact_log2_wide +_pfe_s_calloc +_pfe_calloc +_init_stringpool +_ht_create +_init_obstacks +_ggc_add_deletable_htab +_init_emit_once +_mode_for_size +_gen_rtx +_rtx_alloc +_ggc_alloc +_alloc_page +_pfe_free +_set_page_table_entry +_gen_raw_REG +_gen_rtx_fmt_i0 +_gen_rtx_fmt_w +_ereal_atof +_asctoe53 +_asctoeg +_ecleaz +_enormlz +_eshup6 +_toe53 +_eiisnan +_eshift +_eshup1 +_e53toe +_eshdn1 +_ecleazs +_emovo +_emovz +_eaddm +_eshup8 +_emdnorm +_gen_rtx_CONST_INT +_gen_const_vector_0 +_rtvec_alloc +_gen_rtx_fmt_E0 +_gen_rtx_REG +_init_regs +_init_reg_sets_1 +_reg_class_subset_p +_init_reg_modes +_choose_hard_reg_mode +_init_alias_once +_init_stmt +_init_loop +_address_cost +_memory_address_p +_rs6000_legitimate_address +_init_reload +_gen_rtx_fmt_ee +_gen_rtx_MEM +_gen_rtx_fmt_e0 +_gen_rtx_fmt_s +_pfe_savestring +_plus_constant_wide +_find_constant_term_loc +_bitmap_initialize +_init_function_once +_varray_init +_init_stor_layout_once +_init_varasm_once +_init_EXPR_INSN_LIST_cache +_init_dummy_function_start +_prepare_function_start +_ggc_alloc_cleared +_init_stmt_for_function +_init_eh_for_function +_init_emit +_clear_emit_caches +_init_virtual_regs +_init_expr +_init_varasm_status +_init_temp_slots +_init_pending_stack_adjust +_rs6000_init_machine_status +_init_expmed +_start_sequence +_rtx_cost +_emit_insn +_make_insn_raw +_add_insn +_init_recog +_recog +_recog_13 +_gpc_reg_operand +_register_operand +_recog_4 +_reg_or_cint_operand +_recog_5 +_nonimmediate_operand +_general_operand +_input_operand +_memory_operand +_toc_relative_expr_p +_constant_pool_expr_1 +_reg_or_short_operand +_short_cint_operand +_htab_find_slot_with_hash +_const_int_htab_eq +_init_expr_once +_boolean_or_operator +_boolean_operator +_recog_1 +_reg_or_mem_operand +_recog_7 +_recog_10 +_recog_9 +_altivec_register_operand +_zero_constant +_extract_insn +_init_caller_save +_constrain_operands +_reg_fits_class_p +_insn_extract +_recog_memoized_1 +_cc_reg_operand +_recog_6 +_record_builtin_type +_build_decl +_make_node +_tree_size +_pushdecl +_lookup_name_current_level +_c_common_nodes_and_builtins +_get_identifier +_ht_lookup +_calc_hash +_alloc_node +_make_signed_type +_default_set_default_type_attributes +_fixup_signed_type +_build_int_2_wide +_layout_type +_tree_int_cst_sgn +_smallest_mode_for_size +_size_int_wide +_size_int_type_wide +_force_fit_type +_htab_find_slot +_size_htab_hash +_size_htab_eq +_finalize_type_size +_get_mode_alignment +_round_type_align +_round_up +_size_binop +_int_const_binop +_integer_onep +_tree_cons +_make_unsigned_type +_fixup_unsigned_type +_identifier_global_value +_signed_type +_set_sizetype +_copy_node +_build_common_tree_nodes_2 +_build_pointer_type +_build_qualified_type +_get_qualified_type +_build_type_copy +_set_type_quals +_mul_double +_encode +_decode +_rs6000_build_va_list +_make_vector +_finish_vector_type +_build_index_type +_convert +_convert_to_integer +_build1 +_first_rtl_op +_fold +_fold_convert +_compare_tree_int +_host_integerp +_tree_low_cst +_type_hash_canon +_type_hash_lookup +_htab_find_with_hash +_type_hash_add +_build_array_type +_build +_integer_zerop +_non_lvalue +_add_double +_simple_cst_equal +_mode_for_size_tree +_start_record_layout +_place_field +_layout_decl +_default_ms_bitfield_layout_p +_normalize_rli +_normalize_offset +_finish_record_layout +_finalize_record_size +_get_inner_array_type +_rli_size_so_far +_bit_from_pos +_rli_size_unit_so_far +_byte_from_pos +_compute_record_mode +_type_hash_eq +_attribute_list_equal +_attribute_list_contained +_bit_position +_int_bit_position +_builtin_function +_make_decl_rtl +_decode_reg_name +_darwin_encode_section_info +_ggc_alloc_string +_update_stubs +_decl_attributes +_default_insert_attributes +_insert_default_attributes +_c_common_insert_default_attributes +_builtin_function_2 +_builtin_function_disabled_p +_set_decl_assembler_name +_is_attribute_p +_c_init_decl_processing +_build_function_type +_type_hash_list +_type_list_equal +_start_fname_decls +_set_dump_tree_p +_c_objc_common_init +_c_common_init +_init_c_lex +_get_fileinfo +_splay_tree_lookup +_splay_tree_splay +_splay_tree_insert +_cpp_get_callbacks +_cpp_read_main_file +__cpp_init_hashtable +__cpp_init_directives +_cpp_lookup +__obstack_newchunk +__cpp_init_internal_pragmas +_cpp_register_pragma +_lookup_pragma_entry +_insert_pragma_entry +__cpp_aligned_alloc +_init_standard_includes +_update_path +_concat +_translate_name +_get_key_value +_merge_include_chains +_remove_dup_dirs +_remove_dup_dir +__cpp_read_file +_open_file +_find_or_create_entry +_splay_tree_foreach +_splay_tree_foreach_helper +_inode_finder +_stack_include_file +_read_include_file +_cpp_push_buffer +__cpp_do_file_change +_add_line_map +_cb_file_change +_update_header_times +_extract_interface_info +_init_pragma +_add_c_tree_codes +_ggc_add_tree_varray_root +_lang_dependent_init +_init_asm_output +_init_eh +_init_optabs +_new_optab +_init_all_optabs +_init_integral_libfuncs +_init_libfuncs +_init_floating_libfuncs +_init_one_libfunc +_init_traps +_push_srcloc +_timevar_push +_dwarf2out_do_frame +_dbxout_init +_getdecls +_getpwd +_output_quoted_string +_assemble_name +_maybe_get_identifier +_text_section +_dbxout_typedefs +_dbxout_symbol +_timevar_pop +_compile_file +_init_final +_init_branch_prob +_yyparse +_dbxout_start_source_file +_cpp_finish_options +_init_builtins +__cpp_define_builtin +_run_directive +_start_directive +_do_define +_lex_macro_node +__cpp_lex_token +__cpp_lex_direct +_parse_identifier +__cpp_create_definition +_skip_whitespace +_parse_string +_unescaped_terminator_p +_alloc_expansion_token +_lex_expansion_token +_handle_newline +_pfe_is_cmd_ln_processing +_end_directive +_skip_rest_of_line +__cpp_pop_buffer +_parse_number +_pfe_set_cmd_ln_processing +_cpp_define +_warn_of_redefinition +__cpp_equiv_tokens +__cpp_free_definition +_pfe_reset_cmd_ln_processing +_free_chain +__cpp_push_next_buffer +_yyparse_1 +_yylex +__yylex +_c_lex +_cpp_get_token +_get_effective_char +_skip_block_comment +_skip_escaped_newlines +_trigraph_p +__cpp_handle_directive +_directive_diagnostics +_do_include +_do_include_common +_parse_include +_check_eol +__cpp_execute_include +_find_include_file +_search_from +_lbasename +_splay_tree_splay_helper +_adjust_column +__cpp_extend_buff +_parse_params +_save_parameter +_cb_line_change +_yylexname +_altivec_treat_as_keyword +_ggc_collect +_lookup_name +_start_enum +_lookup_tag +_pushtag +_build_enumerator +_int_fits_type_p +_build_binary_op +_common_type +_tree_int_cst_lt +_type_for_size +_const_binop +_chainon +_nreverse +_finish_enum +_in_parm_level_p +_min_precision +_tree_floor_log2 +_rest_of_type_compilation +_shadow_tag +_shadow_tag_warned +_split_specs_attrs +_lookup_tag_reverse +_check_trad_stringification +_xref_tag +_pending_xref_error +_build_tree_list +_grokdeclarator +_c_apply_type_quals_to_decl +_grokfield +_finish_decl +_maybe_apply_renaming_pragma +_get_pending_sizes +_finish_struct +_start_decl +_maybe_apply_pragma_weak +_rest_of_decl_compilation +_start_struct +_do_ifdef +_push_conditional +_do_else +_do_endif +_constant_expression_warning +__cpp_pop_file_buffer +_pop_srcloc +_dbxout_end_source_file +_make_pointer_declarator +_pushlevel +_make_binding_level +_clear_parm_order +_declare_parm_level +_push_parm_decl +_simple_type_promotes_to +_c_promoting_integer_type_p +_get_parm_info +_gettags +_storedecls +_parmlist_tags_warning +_poplevel +_warn_about_unused_variables +_build_nt +_grokparms +_unsigned_type +_lex_number +_build_compound_expr +_internal_build_compound_expr +_build_array_declarator +_set_array_declarator_type +_signed_or_unsigned_type +_operand_equal_p +_tree_int_cst_equal +_neg_double +_do_undef +_warn_if_shadowing +_build_decl_attribute_variant +_gen_aux_info_record +_collect_args +_enter_macro_context +_replace_args +_expand_arg +_push_ptoken_context +_next_context +__cpp_pop_context +__cpp_release_buff +_padding_token +__cpp_temp_token +_c_build_qualified_type +_push_token_context +_list_length +_handle_noreturn_attribute +_lookup_attribute +_purge_cache +_do_ifndef +_do_if +__cpp_parse_expr +_lex +_parse_number +___udivdi3 +___udivmoddi4 +_funlike_invocation_p +_parse_defined +_cpp_warning +__cpp_begin_message +_do_elif +_groktypename +_c_sizeof +_parser_build_binary_op +_default_conversion +_merge_type_attributes +_merge_attributes +_build_type_attribute_variant +_extract_muldiv +_unsigned_conversion_warning +_overflow_warning +_get_narrower +_attribute_hash_list +_duplicate_decls +_comptypes +_default_comp_type_attributes +_function_types_compatible_p +_self_promoting_args_p +_merge_decl_attributes +_handle_format_attribute +_decode_format_attr +_decode_format_type +_start_function +_announce_function +_store_parm_decls +_decl_function_context +_storetags +_init_function_start +_decl_name +_emit_line_note +_set_file_and_line_for_stmt +_emit_note +_aggregate_value_p +_hard_function_value +_begin_stmt_tree +_current_stmt_tree +_c_begin_compound_stmt +_build_stmt +_add_stmt +_stmts_are_full_exprs_p +_clear_last_expr +_add_scope_stmt +_current_scope_stmt_stack +_c_begin_if_stmt +_build_external_ref +_lookup_objc_ivar +_assemble_external +_build_indirect_ref +_build_component_ref +_lookup_field +_build_unary_op +_unary_complex_lvalue +_get_unwidened +_lvalue_or_else +_lvalue_p +_shorten_compare +_twoval_comparison_p +_invert_tree_comparison +_truthvalue_conversion +_build_c_cast +_default_function_array_conversion +_lex_charconst +_cpp_interpret_charconst +_cpp_parse_escape +_truth_value_p +_fold_range_test +_make_range +_fold_truthop +_c_expand_start_cond +_c_size_in_bytes +_convert_to_pointer +_build_modify_expr +_require_complete_type +_convert_for_assignment +_convert_and_check +_c_expand_return +_build_return_stmt +_c_finish_then +_c_expand_start_else +_build_function_call +_decl_target_overloaded_intrinsic_p +_convert_arguments +_check_function_format +_c_finish_else +_c_expand_end_cond +_kept_level_p +_finish_function +_clear_limbo_values +_finish_fname_decls +_finish_stmt_tree +_free_after_parsing +_free_stmt_status +_free_after_compilation +_free_eh_status +_free_expr_status +_free_emit_status +_free_varasm_status +_rs6000_free_machine_status +_c_expand_body +_tree_inlinable_function_p +_inlinable_function_p +_c_disregard_inline_limits +_c_cannot_inline_tree_fn +_function_attribute_inlinable_p +_put_pending_sizes +_walk_tree +_inline_forbidden_p +_statement_code_p +_lhd_tree_inlining_walk_subtrees +_get_callee_fndecl +_setjmp_call_p +_special_function_p +_defer_fn +_debug_nothing_tree +_integer_all_onesp +_distribute_bit_expr +_place_union_field +_cpp_pedwarn +_do_include_next +___divdi3 +___udivmoddi4 +_handle_malloc_attribute +_type_lists_compatible_p +_redeclaration_error_message +_pedwarn +_set_diagnostic_context +_report_diagnostic +_count_error +_build_range_type +_complete_array_type +_start_init +_push_string +_really_start_incremental_init +_process_init_element +_push_member_name +_output_init_element +_initializer_constant_valid_p +_lhd_return_tree +_digest_init +_output_pending_init_elements +_pop_init_level +_finish_init +_store_init_value +_assemble_variable +_set_mem_attributes +_get_alias_set +_maybe_set_unchanging +_can_address_p +_handled_component_p +_get_mem_attrs +_mem_attrs_htab_hash +_update_non_lazy_ptrs +_app_disable +_set_mem_align +_mem_attrs_htab_eq +_output_addressed_constants +_resolve_unique_section +_variable_section +_darwin_set_section_for_var_p +_data_section +_try_section_alias +_in_text_section +_machopic_define_name +_machopic_define_ident +_machopic_ident_defined_p +_machopic_classify_ident +_name_needs_quotes +_output_constant +_int_size_in_bytes +_output_constructor +_int_byte_position +_byte_position +_expand_expr +_get_subtarget +_immed_double_const +_assemble_integer +_rs6000_assemble_integer +_find_weak_imports +_default_assemble_integer +_integer_asm_op +_assemble_integer_with_op +_output_addr_const +_global_bindings_p +_handle_unused_attribute +_add_decl_stmt +_build_array_ref +_pointer_int_sum +_size_in_bytes +_omit_one_operand +_decl_constant_value_for_broken_optimization +_comp_target_types +_c_expand_expr_stmt +_verify_sequence_points +_verify_tree +_warning_candidate_p +_split_tree +_lex_string +_build_string +_combine_strings +_choose_string_type +_mark_addressable +_staticp +_expand_tree_builtin +_fold_builtin +_invert_truthvalue +_define_label +_lookup_label +_new_tlist +_add_tlist +_warn_for_collisions +_warn_for_collisions_1 +_merge_tlist +_decode_field_reference +_get_inner_reference +_hash_pointer +_htab_find +_eq_pointer +_expand_call_inline +_lhd_tree_inlining_tree_chain_matters_p +_htab_expand +_find_empty_slot_for_expand +_expand_call +_precompute_register_parameters +_push_temp_slots +_preserve_temp_slots +_find_temp_slot_from_address +_pop_temp_slots +_combine_temp_slots +_emit_queue +_protect_from_queue +_mark_temp_addr_taken +_force_operand +_save_fixed_argument_area +_prepare_call_address +_lookup_static_chain +_load_register_parameters +_emit_move_insn +_emit_move_insn_1 +_gen_movsi +_rs6000_emit_move +_gen_sequence +_end_sequence +_use_reg +_gen_rtx_fmt_e +_easy_fp_constant +_rs6000_machopic_legitimize_pic_address +_machopic_legitimize_pic_address +_machopic_indirect_data_reference +_machopic_data_defined_p +_machopic_function_base_name +_gen_rtx_fmt_E +_trunc_int_for_mode +_num_insns_constant +_num_insns_constant_wide +_get_last_insn +_function_arg +_emit_call_1 +_gen_call_value +_machopic_indirect_call_target +_machopic_name_defined_p +_machopic_stub_list_entry +_gen_rtx_fmt_0 +_gen_rtvec +_gen_rtvec_v +_emit_call_insn +_make_call_insn_raw +_any_pending_cleanups +_get_insns +_gen_rtx_fmt_uuuu +_expand_builtin +_do_jump +_do_pending_stack_adjust +_can_compare_p +_do_compare_rtx_and_jump +_reverse_condition +_swap_commutative_operands_p +_commutative_operand_precedence +_force_not_mem +_emit_cmp_and_jump_insns +_prepare_cmp_insn +_preserve_subexpressions_p +_emit_cmp_and_jump_insn_1 +_prepare_operand +_gen_cmpsi +_gen_beq +_rs6000_emit_cbranch +_rs6000_generate_compare +_gen_reg_rtx +_validate_condition_mode +_gen_rtx_fmt_u00 +_gen_rtx_fmt_eee +_emit_jump_insn +_make_jump_insn_raw +_start_cleanup_deferral +_expand_builtin_strcmp +_validate_arglist +_c_getstr +_string_constant +_c_strlen +_build_function_call_expr +_expand_builtin_memcmp +_flags_from_decl_or_type +_init_cumulative_args +_tree_last +_rearrange_arg_list +_initialize_argument_information +_function_arg_pass_by_reference +_promote_mode +_no_reg_parm_stack_space +_function_arg_partial_nregs +_function_arg_skip +_function_arg_boundary +_locate_and_pad_parm +_function_arg_padding +_function_arg_mod_boundary +_pad_to_arg_alignment +_function_arg_advance +_finalize_must_preallocate +_function_ok_for_sibcall +_unsafe_for_reeval +_c_unsafe_for_reeval +_expand_start_target_temps +_expand_start_bindings_and_block +_compute_argument_block_size +_sbitmap_alloc +_sbitmap_zero +_compute_argument_addresses +_rtx_for_function_call +_output_constant_def +_const_hash +_record_constant +_record_constant_1 +_set_mem_alias_set +_copy_constant +_gen_sibcall_value +_gen_rtx_fmt_ +_emit_barrier_after +_add_insn_after +_copy_to_reg +_expand_end_target_temps +_expand_end_bindings +_precompute_arguments +_calls_function +_calls_function_1 +_end_cleanup_deferral +_gen_bne +_emit_jump +_gen_jump +_emit_barrier +_emit_label +_genrtl_if_stmt +_expand_stmt +_prep_stmt +_genrtl_compound_stmt +_genrtl_scope_stmt +_genrtl_expr_stmt_value +_expand_expr_stmt_value +_warn_if_unused_value +_expand_assignment +_copy_rtx +_replace_equiv_address +_update_temp_slot_address +_rtx_equal_p +_change_address_1 +_memory_address +_force_reg +_machopic_non_lazy_ptr_list_entry +_set_unique_reg_note +_find_reg_note +_mark_reg_pointer +_store_expr +_queued_subexp_p +_free_temp_slots +_pfe_s_realloc +_pfe_realloc +_expand_start_else +_gen_label_rtx +_gen_rtx_fmt_iuu00iss +_genrtl_do_pushlevel +_expand_cond +_expand_start_cond +_gen_sibcall +_gen_call +_expand_end_cond +_compare_constant +_compare_constant_1 +_safe_from_p +_expand_binop +_convert_modes +_reg_or_arith_cint_operand +_gen_addsi3 +_add_operand +_do_compare_and_jump +_gen_movqi +_convert_move +_can_extend_p +_emit_unop_insn +_gen_extendqisi2 +_gen_extendqisi2_ppc +_simplify_binary_operation +_avoid_constant_pool_reference +_break_out_memory_refs +_genrtl_goto_stmt +_label_rtx +_expand_goto +_expand_goto_internal +_const_str_htab_eq +_expand_fixup +_expand_value_return +_expand_return +_genrtl_return_stmt +_obstack_free +_assign_temp +_expand_null_return_1 +_clear_pending_stack_adjust +_expand_function_end +_finish_expr_for_function +_in_sequence_p +_emit_line_note_force +_expand_eh_return +_clobber_return_register +_diddle_return_value +_do_clobber_return_reg +_emit_insn_after +_use_return_register +_do_use_return_reg +_expand_fixups +_fixup_gotos +_rest_of_compilation +_reorder_blocks +_reorder_blocks_0 +_reorder_blocks_1 +_blocks_nreverse +_purge_hard_subreg_sets +_open_dump_file +_optimize_sibling_and_tail_recursive_calls +_find_exception_handler_labels +_rebuild_jump_labels +_init_label_info +_mark_all_labels +_mark_jump_label +_find_unreachable_blocks +_delete_unreachable_blocks +_flow_delete_block_noexpunge +_never_reached_warning +_next_nonnote_insn +_delete_insn_chain +_can_delete_note_p +_delete_insn +_remove_insn +_remove_edge +_free_edge +_expunge_block_nocompact +_tidy_fallthru_edges +_tidy_fallthru_edge +_next_real_insn +_forwarder_block_p +_update_forwarder_flag +_try_optimize_cfg +_active_insn_p +_simplejump_p +_hook_void_bool_false +_try_forward_edges +_redirect_edge_and_branch +_try_redirect_by_replacing_jump +_redirect_edge_succ_nodup +_redirect_edge_succ +_flow_delete_block +_expunge_block +_onlyjump_p +_side_effects_p +_can_fallthru +_next_active_insn +_block_label +_redirect_jump +_redirect_exp +_redirect_exp_1 +_validate_change +_num_validated_changes +_apply_change_group +_insn_invalid_p +_prev_nonnote_insn +_computed_jump_p +_computed_jump_p_1 +_returnjump_p +_for_each_rtx +_returnjump_p_1 +_branch_comparison_operator +_merge_blocks +_tail_recursion_label_p +_merge_blocks_nomove +_can_delete_label_p +_in_expr_list_p +_remove_node_from_expr_list +_set_block_for_insn +_label_is_jump_target_p +_uses_addressof +_sequence_uses_addressof +_free_basic_block_vars +_clear_edges +_close_dump_file +_htab_empty +_doing_eh +_emit_initial_value_sets +_unshare_all_rtl +_copy_rtx_if_shared +_unshare_all_decls +_unshare_all_rtl_1 +_max_reg_num +_find_basic_blocks +_count_basic_blocks +_inside_basic_block_p +_control_flow_insn_p +_can_throw_internal +_compute_bb_for_insn +_make_edges +_cached_make_edge +_make_label_edge +_try_simplify_condjump +_any_uncondjump_p +_pc_set +_any_condjump_p +_invert_jump +_invert_exp +_invert_exp_1 +_reversed_comparison_code +_reversed_comparison_code_parts +_invert_br_probabilities +_update_br_prob_note +_find_basic_blocks_1 +_create_basic_block_structure +_reorder_insns +_reorder_insns_nobb +_thread_jump +_comparison_dominates_p +_find_if_header +_find_if_block +_find_cond_trap +_block_has_only_trap +_if_convert +_process_if_block +_noce_process_if_block +_noce_get_condition +_get_condition +_canonicalize_condition +_set_of +_note_stores +_set_of_1 +_first_active_insn +_last_active_insn_p +_clear_aux_for_blocks +_free_bb_for_insn +_delete_null_pointer_checks +_get_bitmap_width +_sbitmap_vector_alloc +_reg_scan_mark_refs +_reg_scan +_cse_main +_init_alias_analysis +_record_set +_find_base_value +_rtx_varies_p +_single_set_2 +_reg_overlap_mentioned_p +_ggc_push_context +_cse_end_of_basic_block +_cse_basic_block +_new_basic_block +_cse_process_notes +_cse_insn +_canon_reg +_fold_rtx +_canon_hash +_get_cse_reg_info +_lookup +_approx_reg_cost +_approx_reg_cost_1 +_bitmap_set_bit +_bitmap_element_allocate +_bitmap_element_link +_bitmap_clear +_preferrable +_insert_regs +_make_new_qty +_rehash_using_reg +_insert +_invalidate_from_clobbers +_invalidate +_delete_reg_equiv +_lookup_for_remove +_make_regs_eqv +_check_for_label_ref +_find_best_addr +_notreg_cost +_mention_regs +_lookup_as_function +_safe_hash +_equiv_constant +_asm_noperands +_cancel_changes +_exp_equiv_p +_recog_33 +_mov_to_vrsave_operation +_load_multiple_operation +_store_multiple_operation +_recog_25 +_current_file_function_operand +_call_operand +_immediate_operand +_scratch_operand +_remove_from_table +_invalidate_memory +_invalidate_for_call +_remove_invalid_refs +_refers_to_regno_p +_gen_lowpart_if_possible +_gen_lowpart_common +_subreg_lowpart_offset +_recog_3 +_invalidate_skipped_block +_invalidate_skipped_set +_canon_rtx +_replace_equiv_address_nv +_check_dependence +_true_dependence +_mems_in_disjoint_alias_sets_p +_alias_sets_conflict_p +_nonoverlapping_memrefs_p +_simplify_relational_operation +_simplify_ternary_operation +_record_jump_equiv +_find_comparison_args +_record_jump_cond +_get_addr +_find_base_term +_base_alias_check +_memrefs_conflict_p +_addr_side_effect_eval +_rtx_equal_for_memref_p +_aliases_everything_p +_fixed_scalar_and_varying_struct_p +_merge_equiv_classes +_reg_mentioned_p diff --git a/order-files/cc1obj.order b/order-files/cc1obj.order new file mode 100644 index 00000000000..730010f4851 --- /dev/null +++ b/order-files/cc1obj.order @@ -0,0 +1,2163 @@ +start +__start +__dyld_init_check +dyld_stub_binding_helper +___darwin_gcc3_preregister_frame_info +__call_mod_init_funcs +__dyld_func_lookup +_main +_toplev_main +_hex_init +_general_init +_xmalloc_set_program_name +_diagnostic_initialize +__obstack_begin +_xmalloc +_parse_options_and_default_flags +_init_reg_sets +_add_params +_xrealloc +_pfe_init +_read_integral_parameter +_override_O_option +_extract_override_options +_objc_init_options +_c_common_init_options +_cpp_create_reader +_init_library +_init_trigraph_map +_xcalloc +_set_lang +_deps_init +_init_line_maps +__cpp_init_tokenrun +__cpp_get_buff +_new_buff +_pfe_s_malloc +_pfe_malloc +_gcc_obstack_init +_pfe_obstack_chuck_alloc +__cpp_init_includes +_splay_tree_new +_splay_tree_new_with_allocator +_splay_tree_xmalloc_allocate +_set_index_lang +_set_target_switch +_optimization_options +_override_option +_objc_decode_option +_c_decode_option +_cpp_handle_option +_parse_option +_independent_decode_option +_new_pending_directive +_xstrdup +_append_include_chain +__cpp_simplify_pathname +_hmap_load_header_map +_dump_switch_p +_decode_f_option +_decode_g_option +_set_Wunused +_set_Wformat +_decode_W_option +_output_set_maximum_length +_set_real_maximum_length +_output_is_line_wrapping +_add_env_options +_objc_post_options +_c_common_post_options +_cpp_post_options +_init_dependency_output +_do_compile +_process_options +_rs6000_override_options +_rs6000_parse_abi_options +_rs6000_add_gc_roots +_ggc_add_rtx_root +_ggc_add_root +_htab_create +_higher_prime_number +_machopic_add_gc_roots +_ggc_add_tree_root +_new_alias_set +_floor_log2_wide +_init_timevar +_timevar_start +_lang_independent_init +_init_ggc +_exact_log2_wide +_pfe_s_calloc +_pfe_calloc +_init_stringpool +_ht_create +_init_obstacks +_ggc_add_deletable_htab +_init_emit_once +_mode_for_size +_gen_rtx +_rtx_alloc +_ggc_alloc +_alloc_page +_pfe_free +_set_page_table_entry +_gen_raw_REG +_gen_rtx_fmt_i0 +_gen_rtx_fmt_w +_ereal_atof +_asctoe53 +_asctoeg +_ecleaz +_enormlz +_eshup6 +_toe53 +_eiisnan +_eshift +_eshup1 +_e53toe +_eshdn1 +_ecleazs +_emovo +_emovz +_eaddm +_eshup8 +_emdnorm +_gen_rtx_CONST_INT +_gen_const_vector_0 +_rtvec_alloc +_gen_rtx_fmt_E0 +_gen_rtx_REG +_init_regs +_init_reg_sets_1 +_reg_class_subset_p +_init_reg_modes +_choose_hard_reg_mode +_init_alias_once +_init_stmt +_init_loop +_address_cost +_memory_address_p +_rs6000_legitimate_address +_init_reload +_gen_rtx_fmt_ee +_gen_rtx_MEM +_gen_rtx_fmt_e0 +_gen_rtx_fmt_s +_pfe_savestring +_plus_constant_wide +_find_constant_term_loc +_bitmap_initialize +_init_function_once +_varray_init +_init_stor_layout_once +_init_varasm_once +_init_EXPR_INSN_LIST_cache +_init_dummy_function_start +_prepare_function_start +_ggc_alloc_cleared +_init_stmt_for_function +_init_eh_for_function +_init_emit +_clear_emit_caches +_init_virtual_regs +_init_expr +_init_varasm_status +_init_temp_slots +_init_pending_stack_adjust +_rs6000_init_machine_status +_init_expmed +_start_sequence +_rtx_cost +_emit_insn +_make_insn_raw +_add_insn +_init_recog +_recog +_recog_13 +_gpc_reg_operand +_register_operand +_recog_4 +_reg_or_cint_operand +_recog_5 +_nonimmediate_operand +_general_operand +_input_operand +_memory_operand +_toc_relative_expr_p +_constant_pool_expr_1 +_reg_or_short_operand +_short_cint_operand +_htab_find_slot_with_hash +_const_int_htab_eq +_init_expr_once +_recog_6 +_recog_10 +_recog_9 +_altivec_register_operand +_zero_constant +_cc_reg_operand +_end_sequence +_init_caller_save +_strict_memory_address_p +_recog_memoized_1 +_extract_insn +_insn_extract +_constrain_operands +_reg_fits_class_p +_boolean_or_operator +_boolean_operator +_recog_1 +_reg_or_mem_operand +_recog_7 +_make_node +_build_decl +_builtin_function +_get_identifier +_ht_lookup +_calc_hash +_alloc_node +_tree_size +_make_decl_rtl +_decode_reg_name +_darwin_encode_section_info +_ggc_alloc_string +_update_stubs +_pushdecl +_lookup_name_current_level +_decl_attributes +_default_insert_attributes +_insert_default_attributes +_c_common_insert_default_attributes +_builtin_function_2 +_builtin_function_disabled_p +_set_decl_assembler_name +_c_common_nodes_and_builtins +_is_attribute_p +_list_length +_handle_format_attribute +_decode_format_attr +_decode_format_type +_chainon +_lookup_attribute +_tree_cons +_build_type_attribute_variant +_attribute_list_equal +_attribute_list_contained +_copy_node +_set_type_quals +_attribute_hash_list +_type_hash_canon +_type_hash_lookup +_layout_type +_htab_find_with_hash +_type_hash_add +_build_qualified_type +_get_qualified_type +_c_init_decl_processing +_make_unsigned_type +_default_set_default_type_attributes +_fixup_unsigned_type +_build_int_2_wide +_tree_int_cst_sgn +_smallest_mode_for_size +_size_int_wide +_size_int_type_wide +_force_fit_type +_htab_find_slot +_size_htab_hash +_size_htab_eq +_finalize_type_size +_get_mode_alignment +_round_type_align +_round_up +_size_binop +_int_const_binop +_integer_onep +_build_function_type +_type_hash_list +_type_hash_eq +_type_list_equal +__obstack_newchunk +_start_fname_decls +_set_dump_tree_p +_c_objc_common_init +_c_common_init +_init_c_lex +_get_fileinfo +_splay_tree_lookup +_splay_tree_splay +_splay_tree_insert +_cpp_get_callbacks +_cpp_read_main_file +__cpp_init_hashtable +__cpp_init_directives +_cpp_lookup +__cpp_init_internal_pragmas +_cpp_register_pragma +_lookup_pragma_entry +_insert_pragma_entry +__cpp_aligned_alloc +_init_standard_includes +_update_path +_remove_component_p +_concat +_translate_name +_get_key_value +_merge_include_chains +_remove_dup_dirs +_remove_dup_dir +__cpp_read_file +_open_file +_find_or_create_entry +_splay_tree_foreach +_splay_tree_foreach_helper +_inode_finder +_stack_include_file +_read_include_file +_cpp_push_buffer +__cpp_do_file_change +_add_line_map +_cb_file_change +_update_header_times +_extract_interface_info +_init_pragma +_add_c_tree_codes +_ggc_add_tree_varray_root +_objc_init +_add_objc_tree_codes +_init_objc +_hash_init +_synth_module_prologue +_xref_tag +_lookup_tag +_pushtag +_build_pointer_type +_objc_declare_class +_is_class_name +_lookup_interface +_lookup_name +_generate_forward_declaration_to_string_table +_build_nt +_define_decl +_start_decl +_grokdeclarator +_signed_type +_signed_or_unsigned_type +_build_array_type +_layout_decl +_c_apply_type_quals_to_decl +_maybe_apply_pragma_weak +_finish_decl +_maybe_apply_renaming_pragma +_complete_array_type +_objc_check_decl +_rest_of_decl_compilation +_timevar_push +_timevar_pop +_get_pending_sizes +_build_tree_list +_objc_act_parse_init +_lang_dependent_init +_init_asm_output +_init_eh +_init_optabs +_new_optab +_init_all_optabs +_init_integral_libfuncs +_init_libfuncs +_init_floating_libfuncs +_init_one_libfunc +_init_traps +_push_srcloc +_dwarf2out_do_frame +_dbxout_init +_getdecls +_getpwd +_output_quoted_string +_assemble_name +_maybe_get_identifier +_text_section +_dbxout_typedefs +_dbxout_symbol +_compile_file +_init_final +_init_branch_prob +_yyparse +_dbxout_start_source_file +_cpp_finish_options +_init_builtins +__cpp_define_builtin +_run_directive +_start_directive +_do_define +_lex_macro_node +__cpp_lex_token +__cpp_lex_direct +_parse_identifier +__cpp_create_definition +_skip_whitespace +_parse_string +_unescaped_terminator_p +_alloc_expansion_token +_lex_expansion_token +_handle_newline +_pfe_is_cmd_ln_processing +_end_directive +_skip_rest_of_line +__cpp_pop_buffer +_parse_number +_pfe_set_cmd_ln_processing +_cpp_define +_warn_of_redefinition +__cpp_equiv_tokens +__cpp_free_definition +_pfe_reset_cmd_ln_processing +_free_chain +__cpp_push_next_buffer +_yyparse_1 +_yylex +__yylex +_c_lex +_cpp_get_token +_get_effective_char +_skip_line_comment +__cpp_handle_directive +_directive_diagnostics +_do_import +_do_include_common +_parse_include +_check_eol +__cpp_execute_include +_find_include_file +_hmap_lookup_path +_splay_tree_splay_helper +_find_framework_file +__cpp_never_reread +_skip_block_comment +_adjust_column +_do_ifndef +_push_conditional +_do_if +__cpp_parse_expr +_lex +_parse_defined +_do_else +_do_endif +__cpp_pop_file_buffer +_purge_cache +_pop_srcloc +_dbxout_end_source_file +_cb_line_change +_yylexname +_altivec_treat_as_keyword +_pending_xref_error +_split_specs_attrs +_make_pointer_declarator +_build1 +_first_rtl_op +_build_type_copy +_ggc_collect +_start_struct +_grokfield +_finish_struct +_in_parm_level_p +_start_record_layout +_place_field +_integer_zerop +_default_ms_bitfield_layout_p +_normalize_rli +_normalize_offset +_compare_tree_int +_finish_record_layout +_finalize_record_size +_convert +_convert_to_integer +_fold +_fold_convert +_mul_double +_encode +_decode +_rli_size_so_far +_bit_from_pos +_rli_size_unit_so_far +_byte_from_pos +_compute_record_mode +_host_integerp +_bit_position +_int_bit_position +_tree_low_cst +_simple_cst_equal +_rest_of_type_compilation +_get_object_reference +_pushlevel +_make_binding_level +_clear_parm_order +_declare_parm_level +_push_parm_decl +_simple_type_promotes_to +_c_promoting_integer_type_p +_warn_about_unused_variables +_poplevel +_grokparms +_enter_macro_context +_push_token_context +_next_context +_padding_token +__cpp_temp_token +__cpp_pop_context +_warn_if_shadowing +_get_parm_info +_gettags +_nreverse +_storedecls +_parmlist_tags_warning +_build_decl_attribute_variant +_gen_aux_info_record +_c_build_qualified_type +_parse_params +_save_parameter +_do_include +_search_from +_lbasename +___udivmoddi4 +_parse_number +_do_elif +___udivdi3 +_skip_escaped_newlines +_unsigned_type +__cpp_extend_buff +_build_index_type +_build +_non_lvalue +_add_double +_mode_for_size_tree +_shadow_tag +_shadow_tag_warned +_lookup_tag_reverse +_lex_number +_build_compound_expr +_internal_build_compound_expr +_build_array_declarator +_set_array_declarator_type +_constant_expression_warning +_operand_equal_p +_tree_int_cst_equal +_const_binop +_neg_double +_trigraph_p +_build_enumerator +_default_conversion +_build_binary_op +_common_type +_tree_int_cst_lt +_type_for_size +_finish_enum +_min_precision +_tree_floor_log2 +_int_fits_type_p +_start_enum +_do_undef +_do_ifdef +_function_attribute_inlinable_p +_c_cannot_inline_tree_fn +_put_pending_sizes +_walk_tree +_inline_forbidden_p +_statement_code_p +_lhd_tree_inlining_walk_subtrees +_get_callee_fndecl +_setjmp_call_p +_special_function_p +_inlinable_function_p +_c_expand_body +_defer_fn +_debug_nothing_tree +_finish_function +_start_function +_announce_function +_store_parm_decls +_decl_function_context +_storetags +_init_function_start +_objc_printable_name +_objc_demangle +_emit_line_note +_set_file_and_line_for_stmt +_emit_note +_aggregate_value_p +_hard_function_value +_begin_stmt_tree +_current_stmt_tree +_c_begin_compound_stmt +_build_stmt +_add_stmt +_stmts_are_full_exprs_p +_clear_last_expr +_add_scope_stmt +_current_scope_stmt_stack +_c_begin_if_stmt +_build_external_ref +_lookup_objc_ivar +_assemble_external +_build_indirect_ref +_is_public +_build_component_ref +_lookup_field +_truthvalue_conversion +_convert_to_pointer +_truth_value_p +_twoval_comparison_p +_optimize_bit_field_compare +_get_inner_reference +_c_expand_start_cond +_parser_build_binary_op +_split_tree +_unsigned_conversion_warning +_overflow_warning +_build_array_ref +_pointer_int_sum +_size_in_bytes +_extract_muldiv +_c_expand_return +_convert_for_assignment +_objc_comptypes +_build_return_stmt +_c_finish_then +_c_expand_end_cond +_shorten_compare +_get_narrower +_invert_tree_comparison +_fold_range_test +_make_range +_fold_truthop +_merge_type_attributes +_merge_attributes +_swap_tree_comparison +_convert_and_check +_build_modify_expr +_c_expand_expr_stmt +_verify_sequence_points +_verify_tree +_warning_candidate_p +_new_tlist +_merge_tlist +_add_tlist +_warn_for_collisions +_warn_for_collisions_1 +_require_complete_type +_lvalue_or_else +_lvalue_p +_get_unwidened +_negate_expr +_build_function_call +_decl_target_overloaded_intrinsic_p +_convert_arguments +_default_function_array_conversion +_check_function_format +_build_unary_op +_unary_complex_lvalue +_mark_addressable +_byte_position +_staticp +_kept_level_p +_lshift_double +_place_union_field +_get_inner_array_type +__cpp_release_buff +_funlike_invocation_p +_collect_args +_replace_args +_expand_arg +_push_ptoken_context +_clear_limbo_values +_finish_fname_decls +_finish_stmt_tree +_free_after_parsing +_free_stmt_status +_free_after_compilation +_free_eh_status +_free_expr_status +_free_emit_status +_free_varasm_status +_rs6000_free_machine_status +_tree_inlinable_function_p +_c_disregard_inline_limits +_merge_ranges +_range_binop +_build_range_check +_invert_truthvalue +_put_var_into_stack +_integer_all_onesp +_distribute_bit_expr +_integer_pow2p +_build_conditional_expr +_operand_equal_for_comparison_p +_decl_constant_value_for_broken_optimization +_decl_constant_value +_warn_about_long_double +_duplicate_decls +_comptypes +_merge_decl_attributes +_groktypename +_c_sizeof +_default_comp_type_attributes +_function_types_compatible_p +_self_promoting_args_p +_type_lists_compatible_p +_start_init +_push_string +_finish_init +_store_init_value +_digest_init +_add_decl_stmt +_build_c_cast +_is_id +_lex_string +_build_string +_combine_strings +_choose_string_type +_global_bindings_p +_htab_expand +_type_hash_hash +_find_empty_slot_for_expand +_get_static_reference +_start_protocol +_build_protocol_template +_lookup_protocol +_make_tree_vec +_lookup_and_install_protocols +_add_protocol +_check_protocol_recursively +_build_keyword_decl +_adjust_type_for_id_default +_is_objc_type_qualifier +_build_method_decl +_build_keyword_selector +_add_instance_method +_lookup_method +_hash_lookup +_hash_func +_hash_enter +_finish_protocol +_start_class +_add_class +_add_class_method +_finish_class +_continue_class +_build_ivar_chain +_objc_copy_list +_add_category +_decode_field_reference +_get_best_mode +_comp_proto_with_proto +_get_arg_type_list +_groktypename_in_parm_context +_hash_add_attr +_add_instance_variable +_type_for_mode +_rshift_double +_constant_boolean_node +_omit_one_operand +_unextend +_make_bit_field_ref +_all_ones_mask_p +_do_float_handler +_set_float_handler +_parse_float +_target_isinf +_eisinf +_eisnan +restFP +_build_real +_convert_to_real +_real_onep +_ereal_cmp +_ecmp +_emovi +_exact_real_inverse +_ediv +_eisneg +_edivm +_m16m +_ecmpm +_esubm +_real_value_truncate +_eclear +_etoe53 +_real_twop +saveFP +_lex_charconst +_cpp_interpret_charconst +_do_pragma +_darwin_pragma_options +_push_field_alignment +_pop_field_alignment +_ht_expand +_redeclaration_error_message +_build_range_type +_release_pages +_ggc_mark_roots +_ggc_mark_rtx_ptr +_ggc_set_mark +_ggc_mark_rtx_children +_mark_optab +_mark_ehl_map +_ggc_mark_hash_table +_zap_lists +_ggc_mark_tree_ptr +_mark_const_str_htab +_htab_traverse +_mark_const_hash_entry +_maybe_mark_struct_function +_ggc_mark_rtvec_children +_mark_ident_hash +_ht_forall +_mark_ident +_varray_grow +_ggc_mark_trees +_lang_mark_tree +_c_mark_lang_decl +_ggc_htab_delete +_type_hash_marked_p +_ggc_marked_p +_type_hash_mark +_htab_clear_slot +_sweep_pages +_c_expand_start_else +_c_finish_else +_stabilize_reference +_stabilize_reference_1 +_c_begin_while_stmt +_c_finish_while_stmt_cond +_c_size_in_bytes +_pedantic_non_lvalue +_pop_label_level +_build_message_expr +_finish_message_expr +_save_expr +_contains_placeholder_p +_lookup_instance_method_static +_build_selector_reference +_build_objc_method_call +_build_selector_reference_decl +_set_mem_attributes +_get_alias_set +_maybe_set_unchanging +_can_address_p +_handled_component_p +_get_mem_attrs +_mem_attrs_htab_hash +_update_non_lazy_ptrs +_pushdecl_top_level +_comp_target_types +_get_class_reference +_build_class_reference_decl +_receiver_is_class_object +_lookup_class_method_static +_initializer_constant_valid_p +_lhd_return_tree +_assemble_variable +_app_disable +_set_mem_align +_mem_attrs_htab_eq +_output_addressed_constants +_output_constant_def +_const_hash +_record_constant +_record_constant_1 +_set_mem_alias_set +_output_constant_def_contents +_cstring_section +_data_section +_try_section_alias +_int_size_in_bytes +_output_constant +_assemble_string +_decode_addr_const +_objc_constant_string_object_section +_objc_section_init +_objc_cat_cls_meth_section +_objc_cat_inst_meth_section +_objc_string_object_section +_cfstring_constant_object_section +_objc_selector_refs_section +_objc_selector_fixup_section +_objc_cls_refs_section +_objc_class_section +_objc_meta_class_section +_objc_cls_meth_section +_objc_inst_meth_section +_objc_protocol_section +_objc_class_names_section +_objc_meth_var_types_section +_objc_meth_var_names_section +_objc_category_section +_objc_class_vars_section +_objc_instance_vars_section +_objc_module_info_section +_objc_symbols_section +_output_constructor +_int_byte_position +_expand_expr +_get_subtarget +_protect_from_queue +_mark_temp_addr_taken +_assemble_integer +_rs6000_assemble_integer +_find_weak_imports +_default_assemble_integer +_integer_asm_op +_assemble_integer_with_op +_output_addr_const +_name_needs_quotes +_immed_double_const +_resolve_unique_section +_variable_section +_darwin_set_section_for_var_p +_const_data_section +_in_text_section +_machopic_define_name +_machopic_define_ident +_machopic_ident_defined_p +_machopic_classify_ident +__cpp_backup_tokens +_build_objc_string_object +_add_class_reference +_setup_string_decl +_build_constructor +_build_super_template +_build_private_template +_build_class_template +_is_ivar +_check_duplicates +_locate_and_pad_parm +_function_arg_padding +_function_arg_boundary +_function_arg_mod_boundary +_pad_to_arg_alignment +_assign_parms +_function_arg_partial_nregs +_function_arg_skip +_no_reg_parm_stack_space +_function_arg_advance +_promote_mode +_gen_reg_rtx +_mark_user_reg +_validize_mem +_emit_move_insn +_emit_move_insn_1 +_gen_movsi +_rs6000_emit_move +_gen_sequence +_pfe_s_realloc +_pfe_realloc +_reg_mentioned_p +_get_last_insn +_mark_reg_pointer +_function_arg_pass_by_reference +_function_arg +_emit_insns +_expand_function_start +_expand_pending_sizes +_force_next_line_note +_expand_stmt +_prep_stmt +_genrtl_compound_stmt +_genrtl_scope_stmt +_expand_start_bindings_and_block +_push_temp_slots +_genrtl_decl_stmt +_anon_aggr_type_p +_emit_local_var +_expand_decl +_expand_decl_init +_expand_assignment +_store_expr +_queued_subexp_p +_preserve_subexpressions_p +_expand_call +_flags_from_decl_or_type +_init_cumulative_args +_tree_last +_rearrange_arg_list +_initialize_argument_information +_finalize_must_preallocate +_any_pending_cleanups +_function_ok_for_sibcall +_unsafe_for_reeval +_c_unsafe_for_reeval +_assign_temp +_precompute_arguments +_calls_function +_calls_function_1 +_value_member +_compute_argument_block_size +_compute_argument_addresses +_rtx_for_function_call +_precompute_register_parameters +_rtx_equal_p +_preserve_temp_slots +_pop_temp_slots +_combine_temp_slots +_emit_queue +_copy_rtx +_replace_equiv_address +_update_temp_slot_address +_change_address_1 +_memory_address +_force_reg +_easy_fp_constant +_gen_rtx_fmt_e +_rs6000_machopic_legitimize_pic_address +_machopic_legitimize_pic_address +_machopic_indirect_data_reference +_machopic_data_defined_p +_machopic_function_base_name +_gen_rtx_fmt_E +_set_unique_reg_note +_find_reg_note +_find_temp_slot_from_address +_copy_to_mode_reg +_save_fixed_argument_area +_prepare_call_address +_lookup_static_chain +_load_register_parameters +_use_reg +_trunc_int_for_mode +_num_insns_constant +_num_insns_constant_wide +_emit_call_1 +_gen_call_value +_machopic_indirect_call_target +_machopic_name_defined_p +_machopic_stub_list_entry +_gen_rtx_fmt_0 +_gen_rtvec +_gen_rtvec_v +_emit_call_insn +_make_call_insn_raw +_get_insns +_expand_start_target_temps +_do_pending_stack_adjust +_sbitmap_alloc +_sbitmap_zero +_gen_lowpart_SUBREG +_subreg_lowpart_offset +_gen_rtx_SUBREG +_gen_rtx_fmt_ei +_convert_modes +_gen_lowpart +_gen_lowpart_common +_simplify_gen_subreg +_simplify_subreg +_gen_sibcall_value +_gen_rtx_fmt_ +_emit_barrier_after +_add_insn_after +_expand_end_target_temps +_expand_end_bindings +_do_jump +_can_compare_p +_do_compare_and_jump +_copy_to_reg +_gen_rtx_fmt_uuuu +_do_compare_rtx_and_jump +_reverse_condition +_swap_commutative_operands_p +_commutative_operand_precedence +_force_not_mem +_emit_cmp_and_jump_insns +_unsigned_condition +_prepare_cmp_insn +_emit_cmp_and_jump_insn_1 +_prepare_operand +_gen_cmpsi +_gen_bne +_rs6000_emit_cbranch +_rs6000_generate_compare +_validate_condition_mode +_gen_rtx_fmt_u00 +_gen_rtx_fmt_eee +_emit_jump_insn +_make_jump_insn_raw +_genrtl_if_stmt +_genrtl_expr_stmt_value +_expand_expr_stmt_value +_warn_if_unused_value +_gen_call +_free_temp_slots +_expand_end_cond +_emit_label +_gen_sibcall +_genrtl_return_stmt +_expand_return +_expand_value_return +_expand_null_return_1 +_clear_pending_stack_adjust +_expand_goto_internal +_expand_fixup +_emit_jump +_gen_jump +_emit_barrier +_objc_expand_function_end +_encode_method_prototype +_encode_type_qualifiers +_encode_type +_encode_pointer +_forwarding_offset +_apply_args_register_offset +_apply_args_size +_encode_aggregate +_expand_function_end +_finish_expr_for_function +_in_sequence_p +_emit_line_note_force +_expand_eh_return +_clobber_return_register +_diddle_return_value +_do_clobber_return_reg +_emit_insn_after +_use_return_register +_do_use_return_reg +_expand_fixups +_fixup_gotos +_rest_of_compilation +_reorder_blocks +_reorder_blocks_0 +_reorder_blocks_1 +_blocks_nreverse +_reorder_fix_fragments +_pfe_varray_free +_init_flow +_open_dump_file +_convert_from_eh_region_ranges +_collect_eh_region_array +_resolve_fixup_regions +_convert_from_eh_region_ranges_1 +_remove_fixup_regions +_remove_unreachable_regions +_get_max_uid +_remove_unnecessary_notes +_remove_insn +_alloc_INSN_LIST +_gen_rtx_fmt_ue +_free_INSN_LIST_node +_init_function_for_compilation +_purge_hard_subreg_sets +_optimize_sibling_and_tail_recursive_calls +_find_exception_handler_labels +_rebuild_jump_labels +_init_label_info +_mark_all_labels +_mark_jump_label +_cse_basic_block +_new_basic_block +_any_uncondjump_p +_pc_set +_cse_process_notes +_cse_insn +_canon_reg +_apply_change_group +_fold_rtx +_canon_hash +_get_cse_reg_info +_lookup +_approx_reg_cost +_for_each_rtx +_approx_reg_cost_1 +_bitmap_set_bit +_bitmap_element_allocate +_bitmap_element_link +_bitmap_clear +_preferrable +_validate_change +_insert_regs +_make_new_qty +_rehash_using_reg +_insert +_invalidate_from_clobbers +_invalidate +_delete_reg_equiv +_lookup_for_remove +_make_regs_eqv +_check_for_label_ref +_lookup_as_function +_safe_hash +_exp_equiv_p +_equiv_constant +_simplify_binary_operation +_avoid_constant_pool_reference +_notreg_cost +_insn_invalid_p +_asm_noperands +_cancel_changes +_mention_regs +_remove_invalid_refs +_refers_to_regno_p +_remove_from_table +_gen_lowpart_if_possible +_find_best_addr +_recog_33 +_mov_to_vrsave_operation +_load_multiple_operation +_store_multiple_operation +_recog_25 +_current_file_function_operand +_call_operand +_immediate_operand +_scratch_operand +_invalidate_memory +_invalidate_for_call +_recog_3 +_invalidate_skipped_block +_note_stores +_invalidate_skipped_set +_cse_main +_cse_end_of_basic_block +_next_real_insn +_prev_nonnote_insn +_ggc_pop_context +_end_alias_analysis +_ggc_del_root +_max_reg_num +_find_basic_blocks +_clear_edges +_free_edge +_count_basic_blocks +_inside_basic_block_p +_control_flow_insn_p +_can_throw_internal +_find_basic_blocks_1 +_create_basic_block_structure +_compute_bb_for_insn +_make_edges +_cached_make_edge +_computed_jump_p +_computed_jump_p_1 +_returnjump_p +_returnjump_p_1 +_make_label_edge +_next_nonnote_insn +_make_eh_edge +_reachable_handlers +_free_INSN_LIST_list +_tidy_fallthru_edges +_tidy_fallthru_edge +_cleanup_cfg +_delete_unreachable_blocks +_find_unreachable_blocks +_try_optimize_cfg +_update_forwarder_flag +_forwarder_block_p +_active_insn_p +_hook_void_bool_false +_try_simplify_condjump +_any_condjump_p +_try_forward_edges +_onlyjump_p +_free_EXPR_LIST_list +_free_bb_for_insn +_delete_trivially_dead_insns +_count_reg_usage +_side_effects_p +_canonicalize_condition +_set_of +_set_of_1 +_delete_null_pointer_checks +_delete_null_pointer_checks_1 +_sbitmap_vector_zero +_invalidate_nonnull_info +_single_set_2 +_compute_available +_sbitmap_vector_ones +_sbitmap_ones +_sbitmap_union_of_diff +_sbitmap_intersection_of_preds +_sbitmap_copy +_clear_aux_for_edges +_clear_aux_for_blocks +_renumber_insns +_close_dump_file +_purge_addressof +_hash_table_init +_hash_table_init_n +_compute_insns_for_mem +_insns_for_mem_walk +_hash_lookup +_insns_for_mem_hash +_compute_hash_table +_record_last_reg_set_info +_mark_call +_record_last_mem_set_info +_record_last_set_info +_hash_scan_insn +_hash_scan_set +_find_reg_equal_equiv_note +_oprs_available_p +_oprs_unchanged_p +_insert_set_in_table +_hash_set +_gcse_alloc +_hash_scan_call +_hash_scan_clobber +_expr_equiv_p +_one_cprop_pass +_alloc_cprop_mem +_sbitmap_vector_alloc +_compute_cprop_data +_compute_local_properties +_compute_transp +_cprop +_reset_opr_set_tables +_clear_modify_mem_tables +_free_list +_cprop_insn +_note_uses +_find_used_regs +_mark_oprs_set +_oprs_not_set_p +_bitmap_bit_p +_find_avail_set +_lookup_set +_mark_set +_mark_clobber +_free_cprop_mem +_free_set_hash_table +_gcse_main +_free_gcse_mem +_free_modify_mem_tables +_alloc_gcse_mem +_gmalloc +_one_classic_gcse_pass +_alloc_expr_hash_table +_alloc_rd_mem +_compute_expr_hash_table +_want_to_gcse_p +_set_noop_p +_oprs_anticipatable_p +_insert_expr_in_table +_hash_expr +_hash_expr_1 +_load_killed_in_block_p +_find_comparison_args +_comparison_dominates_p +_simplify_relational_operation +_simplify_ternary_operation +_record_jump_equiv +_reversed_comparison_code_parts +_record_jump_cond +_merge_equiv_classes +_check_function_return_warnings +_mark_constant_function +_mark_dfs_back_edges +_init_alias_analysis +_record_set +_find_base_value +_rtx_varies_p +_nonlocal_mentioned_p +_flow_loops_find +_calculate_dominance_info +_init_dom_info +_calc_dfs_tree +_calc_dfs_tree_nonrec +_calc_idoms +_link_roots +_idoms_to_doms +_free_dom_info +_flow_loops_tree_build +_flow_loops_level_compute +_estimate_probability +_predict_edge_def +_predict_edge +_predict_insn +_get_condition +_predict_insn_def +_combine_predictions_for_insn +_dump_prediction +_estimate_bb_frequencies +_alloc_aux_for_blocks +_alloc_aux_for_block +_alloc_aux_for_edges +_alloc_aux_for_edge +_estimate_loops_at_level +_propagate_freq +_free_aux_for_blocks +_free_aux_for_edges +_flow_loops_free +_life_analysis +_allocate_reg_life_data +_allocate_reg_info +_allocate_bb_life_data +_mark_regs_live_at_end +_mark_reg +_update_life_info +_clear_log_links +_calculate_global_regs_live +_bitmap_operation +_bitmap_copy +_propagate_block +_init_propagate_block_info +_propagate_one_insn +_insn_dead_p +_mark_set_regs +_mark_used_regs +_mark_used_reg +_volatile_refs_p +_mark_set_1 +_invalidate_mems_from_set +_bitmap_clear_bit +_invalidate_mems_from_autoinc +_free_propagate_block_info +_bitmap_equal_p +_sched_analyze +_add_dependence_list_and_free +_add_dependence +_sched_analyze_insn +_sched_analyze_1 +_sched_analyze_2 +_read_dependence +_add_insn_mem_dependence +_alloc_EXPR_LIST +_add_dependence_list +_flush_pending_lists +_compute_jump_reg_dependencies +_get_condition +_compute_block_backward_dependences +_add_branch_dependences +_sets_likely_spilled +_sets_likely_spilled_1 +_free_deps +_schedule_region +_get_block_head_tail +_compute_forward_dependences +_group_leader +_set_priorities +_priority +_insn_cost +_result_ready_cost +_contributes_to_priority +_rs6000_adjust_cost +_get_attr_type +_extract_constrain_insn_cached +_extract_insn_cached +_regclass +_secondary_reload_class +_scan_one_insn +_record_operand_costs +_record_reg_classes +_find_regno_note +_copy_cost +_local_alloc +_update_equiv_regs +_reg_preferred_class +_equiv_init_movable_p +_equiv_init_varies_p +_no_equiv +_block_alloc +_requires_inout +_get_hard_reg_initial_reg +_combine_regs +_reg_is_born +_alloc_qty +_reg_alternate_class +_wipe_dead_reg +_mark_life +_reg_is_set +_multiple_sets +_qty_sugg_compare_1 +_find_free_reg +_post_mark_life +_qty_compare_1 +_reg_set_to_hard_reg_set +_qty_sugg_compare +_qty_compare +_global_alloc +_global_conflicts +_record_conflicts +_mark_reg_clobber +_mark_reg_death +_mark_reg_store +_set_preference +_record_one_conflict +_expand_preferences +_allocno_compare +_prune_preferences +_find_reg +_build_insn_chain +_new_insn_chain +_reg_dies +_reg_becomes_live +_reload +_clear_secondary_mem +_init_save_areas +_mark_home_live +_scan_paradoxical_subregs +_function_invariant_p +_init_elim_table +_max_label_num +_get_first_label_num +_alter_reg +_mark_not_eliminable +_maybe_fix_stack_asms +_finish_spills +_rs6000_stack_info +_first_reg_to_save +_first_fp_reg_to_save +_first_altivec_reg_to_save +_rs6000_ra_ever_killed +_push_topmost_sequence +_pop_topmost_sequence +_reg_overlap_mentioned_p +_get_frame_size +_get_func_frame_size +_set_initial_elim_offsets +_set_initial_label_offsets +_calculate_needs_all_insns +_set_label_offsets +_eliminate_regs_in_insn +_elimination_effects +_eliminate_regs +_check_eliminable_occurrences +_find_reloads +_update_eliminable_offsets +_combine_reloads +_operands_match_p +_emit_reload_insns +_emit_insns_before +_emit_insns_after +_reload_reg_reaches_end_p +_reload_as_needed +_subst_reloads +_forget_old_reloads_1 +_push_reload +_reload_inner_reg_of_subreg +_find_reusable_reload +_earlyclobber_operand_p +_choose_reload_regs +_choose_reload_regs_init +_compute_use_by_pseudos +_allocate_reload_reg +_reload_reg_free_p +_set_reload_reg +_true_regnum +_mark_reload_reg_in_use +_do_input_reload +_do_output_reload +_set_offsets_for_label +_verify_initial_elim_offsets +_cleanup_subreg_operands +_add_auto_inc_notes +_auto_inc_p +_replace_pseudos_in_call_usage +_obstack_free +_fixup_abnormal_edges +_unshare_all_rtl_again +_reset_used_flags +_reset_used_decls +_unshare_all_rtl +_copy_rtx_if_shared +_unshare_all_decls +_unshare_all_rtl_1 +_reload_cse_regs +_reload_cse_regs_1 +_cselib_init +_clear_table +_htab_empty +_prologue_epilogue_contains +_contains +_cselib_process_insn +_reload_cse_simplify +_reload_cse_simplify_set +_reload_cse_noop_set_p +_rtx_equal_for_cselib_p +_cselib_lookup +_reload_cse_simplify_operands +_cselib_record_sets +_new_cselib_val +_new_elt_loc_list +_new_elt_list +_cselib_invalidate_rtx +_cselib_invalidate_regno +_push_operand +_cselib_record_set +_hash_rtx +_wrap_constant +_cselib_subst_to_values +_shallow_copy_rtx +_cselib_lookup_mem +_add_mem_for_addr +_replace_equiv_address_nv +_unchain_one_elt_list +_unchain_one_elt_loc_list +_entry_and_rtx_equal_p +_cselib_invalidate_mem +_cselib_invalidate_mem_1 +_cselib_mem_conflict_p +_cselib_finish +_htab_delete +_reload_combine +_reload_combine_note_use +_reload_combine_note_store +_get_value_hash +_if_convert +_find_if_header +_find_if_block +_process_if_block +_find_cond_trap +_block_has_only_trap +_find_if_case_1 +_find_if_case_2 +_split_all_insns +_split_insn +_try_split +_split_insns +_const_int_operand +_non_add_cint_operand +_split_11 +_split_7 +_equality_operator +_vector_comparison_operator +_schedule_insns +_scope_to_insns_initialize +_delete_insn +_sched_init +_rs6000_issue_rate +_init_dependency_caches +_rtx_equal_for_memref_p +_memrefs_conflict_p +_canon_rtx +_addr_side_effect_eval +_write_dependence_p +_output_dependence +_mems_in_disjoint_alias_sets_p +_alias_sets_conflict_p +_nonoverlapping_memrefs_p +_get_addr +_base_alias_check +_find_base_term +_true_dependence +_lsu_unit_blockage +_actual_hazard +_schedule_block +_schedule_more_p +_iu2_unit_blockage +_can_schedule_ready_p +_move_insn +_move_insn1 +_reemit_notes +_schedule_insn +_new_ready +_rs6000_adjust_priority +_queue_to_ready +_rank_for_schedule +_function_units_used +_rgn_rank +_find_insn_list +_no_real_insns_p +_save_line_notes +_rm_line_notes +_rm_other_notes +_clear_units +_init_ready_list +_ready_add +_verify_local_live_at_start +_reposition_prologue_and_epilogue_notes +_reorder_insns +_reorder_insns_nobb +_set_block_for_insn +_rm_redundant_line_notes +_scope_to_insns_finalize +_set_block_levels +_change_scope +_emit_note_before +_add_insn_before +_sched_finish +_free_dependency_caches +_add_noreturn_fake_exit_edges +_try_crossjump_bb +_try_crossjump_to_edge +_outgoing_edges_match +_remove_fake_edges +_remove_fake_successors +_compute_alignments +_purge_line_number_notes +_cleanup_barriers +_split_all_insns_noflow +_convert_to_eh_region_ranges +_shorten_branches +_insn_default_length +_insn_variable_length_p +_dwarf2out_begin_prologue +_final_start_function +_number_blocks +_get_block_vector +_all_blocks +_rs6000_output_function_prologue +_final +_final_scan_insn +_debug_nothing_int +_peephole +_scc_comparison_operator +_constrain_operands_cached +_get_insn_template +_output_asm_insn +_output_operand +_print_operand +_notice_source_line +_dbxout_source_line +_dbxout_source_file +_dbxout_begin_block +_simplify_subtraction +_decode_rtx_const +_walk_alter_subreg +_output_address +_print_operand_address +_no_asm_to_stream +_profile_after_prologue +_output_406 +_machopic_validate_stub_or_non_lazy_ptr +_output_405 +_output_541 +_output_cbranch +_get_attr_length +_output_asm_label +_dbxout_end_block +_final_end_function +_rs6000_output_function_epilogue +_output_compiler_stub +_debug_nothing_void +_assemble_end_function +_output_after_function_constants +_output_function_exception_table +_free_basic_block_vars +_regset_release_memory +_bitmap_release_memory +_dbxout_function_decl +_dbxout_begin_function +_dbxout_prepare_symbol +_dbxout_type +_dbxout_type_index +_dbxout_queue_symbol +_dbxout_type_name +_dbxout_finish_symbol +_dbxout_flush_symbol_queue +_print_wide_int +_dbxout_type_fields +_print_int_cst_octal +_print_octal +_finish_method_def +_optimize_inline_calls +_lhd_tree_inlining_add_pending_fn_decls +_expand_calls_inline +_htab_find +_hash_pointer +_expand_call_inline +_lhd_tree_inlining_tree_chain_matters_p +_eq_pointer +_init_recog_no_volatile +_gen_label_rtx +_gen_rtx_fmt_iuu00iss +_genrtl_for_stmt +_emit_nop +_expand_start_loop_continue_elsewhere +_expand_start_loop +_genrtl_do_pushlevel +_expand_cond +_expand_exit_loop_top_cond +_expand_exit_loop_if_false +_gen_blt +_expand_start_cond +_gen_beq +_expand_binop +_reg_or_arith_cint_operand +_gen_addsi3 +_add_operand +_expand_increment +_expand_end_loop +_emit_label_before +_emit_jump_insn_before +_emit_barrier_before +_maybe_remove_eh_handler +_flow_delete_block_noexpunge +_delete_insn_chain +_can_delete_label_p +_in_expr_list_p +_remove_node_from_expr_list +_can_delete_note_p +_remove_edge +_flow_delete_block +_expunge_block +_expunge_block_nocompact +_redirect_edge_and_branch +_try_redirect_by_replacing_jump +_can_fallthru +_next_active_insn +_simplejump_p +_never_reached_warning +_ehl_hash +_block_label +_redirect_jump +_redirect_exp +_redirect_exp_1 +_num_validated_changes +_branch_comparison_operator +_redirect_edge_succ_nodup +_redirect_edge_succ +_merge_blocks +_tail_recursion_label_p +_sequence_uses_addressof +_uses_addressof +_replace_call_placeholder +_call_ends_block_p +_skip_copy_to_return_value +_identify_call_return_value +_skip_stack_adjustment +_skip_pic_restore +_reg_set_between_p +_purge_reg_equiv_notes +_remove_note +_purge_mem_unchanging_flag +_purge_addressof_1 +_hash_table_free +_alloc_reg_set_mem +_compute_sets +_record_set_info +_record_one_set +_alloc_set_hash_table +_compute_set_hash_table +_compute_kill_rd +_compute_rd +_sbitmap_union_of_preds +_alloc_avail_expr_mem +_compute_ae_gen +_compute_ae_kill +_expr_killed_p +_classic_gcse +_lookup_expr +_free_avail_expr_mem +_free_rd_mem +_free_expr_hash_table +_one_code_hoisting_pass +_cse_around_loop +_cse_set_around_loop +_addr_affects_sp_p +_find_and_verify_loops +_compute_luids +_for_each_eh_label +_mark_loop_jump +_loop_optimize +_reg_scan +_reg_scan_mark_refs +_find_single_use_in_loop +_loop_regs_scan +_count_one_set +_reg_used_between_p +_find_reg_fusage +_find_regno_fusage +_scan_loop +_count_insns_in_loop +_next_insn_in_loop +_reg_in_basic_block_p +_loop_invariant_p +_consec_sets_invariant_p +_loop_movables_add +_skip_consec_insns +_modified_between_p +_reg_set_p +_no_labels_between_p +_may_trap_p +_rtx_addr_can_trap_p +_loop_reg_used_before_p +_ignore_some_movables +_force_movables +_combine_movables +_load_mems +_reg_scan_update +_strength_reduce +_loop_bivs_find +_for_each_insn_in_loop +_check_insn_for_bivs +_basic_induction_var +_record_biv +_loop_bivs_init_find +_record_initial +_get_condition_for_loop +_valid_initial_value_p +_loop_bivs_check +_loop_givs_find +_check_insn_for_givs +_find_mem_givs +_update_giv_derive +_general_induction_var +_simplify_giv_expr +_loop_iterations +_biv_total_increment +_fold_rtx_mult_add +_loop_find_equiv_value +_find_common_reg_term +_loop_givs_check +_check_dbra_loop +_count_nonfixed_reads +_loop_biv_eliminable_p +_maybe_eliminate_biv +_maybe_eliminate_biv_1 +_check_ext_dependent_givs +_combine_givs +_loop_givs_dead_check +_loop_givs_reduce +_loop_givs_rescan +_replace_regs +_loop_ivs_free +_loop_movables_free +_ggc_push_context +_regclass_init +_thread_jump +_reversed_comparison_code +_compress +_flow_depth_first_order_compute +_flow_loop_nodes_find +_sbitmap_first_set_bit +_sbitmap_last_set_bit +_flow_loop_scan +_flow_loop_level_compute +_flow_loop_exit_edges_find +_find_auto_inc +_delete_dead_jumptables +_uninitialized_vars_warning +_regno_uninitialized +_initialize_uninitialized_subregs +_combine_instructions +_init_reg_last_arrays +_setup_incoming_promotions +_promoted_input_arg +_record_value_for_reg +_update_table_tick +_get_last_value_validate +_nonzero_bits +_num_sign_bit_copies +_set_nonzero_bits_and_sign_copies +_expand_field_assignment +_get_last_value +_record_dead_and_set_regs +_record_dead_and_set_regs_1 +_replace_rtx +_recog_15 +_recog_21 +_recog_16 +_recog_17 +_recog_19 +_recog_31 +_recog_28 +_recog_26 +_stmw_operation +_mtcrf_operation +_lmw_operation +_vrsave_operation +_recog_for_combine +_check_asm_operands +_do_SUBST_INT +_try_combine +_undo_all +_cant_combine_insn_p +_can_combine_p +_combinable_i3pat +_do_SUBST +_reg_referenced_p +_dead_or_set_p +_dead_or_set_regno_p +_subst +_combine_simplify_rtx +_simplify_set +_find_single_use +_find_single_use_1 +_simplify_comparison +_swap_condition +_make_compound_operation +_make_field_assignment +_mark_used_regs_combine +_use_crosses_set_p +_volatile_insn_p +_force_to_mode +_recog_22 +_recog_23 +_any_operand +_check_promoted_subreg +_if_then_else_cond +_simplify_if_then_else +_combine_reversed_comparison_code +_recog_30 +_contains_muldiv +_apply_distributive_law +_have_insn_for +_move_deaths +_restore_line_notes +_free_pending_lists +_finish_deps_global +_init_deps_global +_init_deps +_unlink_line_notes +_unlink_other_notes +_leaf_function_p +_allocate_initial_values +_record_address_regs +_assign_stack_local +_assign_stack_local_1 +_find_reloads_address +_regno_clobbered_p +_copy_reloads +_condjump_p +_thread_prologue_and_epilogue_insns +_gen_prologue +_rs6000_emit_prologue +_try_leaf_pic_optimization +_name_encodes_objc_method_p +_rs6000_frame_related +_simplify_rtx +_rs6000_maybe_dead +_rs6000_emit_allocate_stack +_gen_movsi_update +_record_insns +_insert_insn_on_edge +_direct_return +_gen_epilogue +_rs6000_emit_epilogue +_commit_edge_insertions +_commit_one_edge_insertion +_find_sub_basic_blocks +_find_bb_boundaries +_purge_dead_edges +_compute_outgoing_frequencies +___divdi3 +___udivmoddi4 +_gen_sibcall_epilogue +_emit_insn_before +_insns_match_p +_copyprop_hardreg_forward +_init_value_data +_copyprop_hardreg_forward_1 +_preprocess_constraints +_kill_clobbered_value +_kill_autoinc_value +_replace_oldest_value_reg +_find_oldest_value_reg +_kill_set_value +_kill_value +_kill_value_regno +_set_value_regno +_copy_value +_replace_oldest_value_mem +_replace_oldest_value_addr +_recog_20 +_delete_noop_moves +_noop_move_p +_find_insn_reg_weight +_init_regions +_find_single_block_region +_count_or_remove_death_notes +_free_EXPR_LIST_node +_assemble_start_function +_output_408 +_purge_all_dead_edges +_notice_stack_pointer_modification +_notice_stack_pointer_modification_1 +_distribute_notes +_reg_bitfield_target_p +_distribute_links +_undo_commit +_remove_death +_emit_note_after +_reload_cse_delete_noop_set +_references_value_p +_reload_cse_move2add +_move2add_note_store +_sext_for_mode +_start_method_def +_synth_self_and_ucmd_args +_handle_unused_attribute +_expr_last +_continue_method_def +_really_start_method +_lookup_method_in_protocol_list +_find_label_refs +_alloc_block +_merge_blocks_nomove +_skip_use_of_return_value +_skip_unreturned_value +_skip_jump_insn +_doing_eh +_emit_initial_value_sets +_instantiate_virtual_regs +_instantiate_decls +_instantiate_decl +_instantiate_decls_1 +_instantiate_virtual_regs_1 +_instantiate_new_reg +_output_407 +_dbxout_parms +_dbxout_block +_dbxout_syms +_dbxout_reg_parms +_dbxout_symbol_location +_dbxout_function_end +_init_insn_lengths +_clear_const_double_mem +_expected_value_to_br_prob +_prev_real_insn +_insn_live_p +_set_live_p +_regmove_optimize +_discover_flags_reg +_gen_add3_insn +_mark_flags_life_zones +_find_matches +_validate_replace_rtx +_validate_replace_rtx_1 +_mirror_conflicts +_nothrow_function_p +_output_constant_pool +_mark_constant_pool +_htab_elements +_function_section +_unsave_expr +_expand_start_else +_machopic_non_lazy_ptr_list_entry +_start_cleanup_deferral +_end_cleanup_deferral +_expand_loop_continue_here +_genrtl_expr_stmt +_delete_related_insns +_canon_list_insert +_mems_conflict_for_gcse_p +_try_replace_reg +_validate_replace_src +_validate_replace_src_1 +_simplify_replace_rtx +_try_pre_increment_1 +_try_pre_increment +_find_use_as_address +_split_2 +_cc_reg_not_cr0_operand +_split_3 +_split_4 +_split_6 +_non_short_cint_operand +_add_to_mem_set_list +_comp_method_with_proto +_force_operand +_unsave_expr_now +_unsave_expr_now_r +_unsave_expr_1 +_duplicate_loop_exit_test +_copy_loop_headers +_invert_jump +_invert_exp +_invert_exp_1 +_invert_br_probabilities +_update_br_prob_note +_label_is_jump_target_p +_get_bitmap_width +_indirect_jump_in_function_p +_prescan_loop +_note_addr_stored +_set_sched_group_p +_remove_dependence diff --git a/order-files/cc1objplus.order b/order-files/cc1objplus.order new file mode 100644 index 00000000000..380a0e211c1 --- /dev/null +++ b/order-files/cc1objplus.order @@ -0,0 +1,952 @@ +start +__start +__dyld_init_check +dyld_stub_binding_helper +___darwin_gcc3_preregister_frame_info +__call_mod_init_funcs +__dyld_func_lookup +_main +_toplev_main +_hex_init +_general_init +_xmalloc_set_program_name +_diagnostic_initialize +__obstack_begin +_xmalloc +_parse_options_and_default_flags +_init_reg_sets +_add_params +_xrealloc +_pfe_init +_read_integral_parameter +_override_O_option +_extract_override_options +_objc_init_options +_cxx_init_options +_c_common_init_options +_cpp_create_reader +_init_library +_init_trigraph_map +_xcalloc +_set_lang +_deps_init +_init_line_maps +__cpp_init_tokenrun +__cpp_get_buff +_new_buff +_pfe_s_malloc +_pfe_malloc +_gcc_obstack_init +_pfe_obstack_chuck_alloc +__cpp_init_includes +_splay_tree_new +_splay_tree_new_with_allocator +_splay_tree_xmalloc_allocate +_set_index_lang +_set_target_switch +_optimization_options +_override_option +_objc_decode_option +_cxx_decode_option +_cpp_handle_option +_parse_option +_xstrdup +_append_include_chain +__cpp_simplify_pathname +_independent_decode_option +_new_pending_directive +_hmap_load_header_map +_decode_W_option +_set_Wunused +_compare_options +_dump_switch_p +_decode_f_option +_output_set_maximum_length +_set_real_maximum_length +_output_is_line_wrapping +_add_env_options +_objc_post_options +_c_common_post_options +_cpp_post_options +_init_dependency_output +_do_compile +_process_options +_rs6000_override_options +_rs6000_parse_abi_options +_rs6000_add_gc_roots +_ggc_add_rtx_root +_ggc_add_root +_htab_create +_higher_prime_number +_machopic_add_gc_roots +_ggc_add_tree_root +_new_alias_set +_floor_log2_wide +_init_timevar +_timevar_start +_lang_independent_init +_init_ggc +_exact_log2_wide +_pfe_s_calloc +_pfe_calloc +_init_stringpool +_ht_create +_init_obstacks +_ggc_add_deletable_htab +_init_emit_once +_mode_for_size +_gen_rtx +_rtx_alloc +_ggc_alloc +_alloc_page +_pfe_free +_set_page_table_entry +_gen_raw_REG +_gen_rtx_fmt_i0 +_gen_rtx_fmt_w +_ereal_atof +_asctoe53 +_asctoeg +_ecleaz +_enormlz +_eshup6 +_toe53 +_eiisnan +_eshift +_eshup1 +_e53toe +_eshdn1 +_ecleazs +_emovo +_emovz +_eaddm +_eshup8 +_emdnorm +_init_reg_sets_1 +_reg_class_subset_p +_init_regs +_init_reg_modes +_choose_hard_reg_mode +_recog_13 +_nonimmediate_operand +_general_operand +_input_operand +_memory_operand +_register_operand +_toc_relative_expr_p +_constant_pool_expr_1 +_init_expmed +_gen_rtx_CONST_INT +_recog +_gpc_reg_operand +_recog_4 +_reg_or_cint_operand +_rtx_cost +_recog_5 +_reg_or_short_operand +_short_cint_operand +_htab_find_slot_with_hash +_const_int_htab_eq +_init_expr_once +_gen_rtx_REG +_recog_10 +_recog_9 +_altivec_register_operand +_rs6000_legitimate_address +_zero_constant +_cc_reg_operand +_constrain_operands +_reg_fits_class_p +_init_caller_save +_extract_insn +_insn_extract +_gen_rtx_MEM +_gen_rtx_fmt_e0 +_gen_rtx_fmt_ee +_emit_insn +_make_insn_raw +_add_insn +_recog_memoized_1 +_reg_or_mem_operand +_recog_7 +_recog_6 +_boolean_or_operator +_boolean_operator +_recog_1 +_builtin_function_2 +_builtin_function +_builtin_function_1 +_get_identifier +_ht_lookup +_calc_hash +_alloc_node +_make_node +_tree_size +_build_library_fn_1 +_build_lang_decl +_build_decl +_pfe_savestring +_retrofit_lang_decl +_ggc_alloc_cleared +_pushdecl +_lookup_name_current_level +_namespace_binding +_check_template_shadow +_push_overloaded_decl +_namespace_bindings_p +_innermost_nonclass_level +_set_namespace_binding +_decls_match +_warn_extern_redeclared_static +_check_default_args +_add_decl_to_level +_make_decl_rtl +_decode_reg_name +_gen_rtx_fmt_s +_darwin_encode_section_info +_ggc_alloc_string +_update_stubs +_decl_attributes +_init_attributes +_default_insert_attributes +_insert_default_attributes +_c_common_insert_default_attributes +_c_init_attributes +_build_int_2_wide +_tree_cons +_builtin_function_disabled_p +_mangle_decl +_mangle_decl_string +_c_common_nodes_and_builtins +_init_standard_includes +_update_path +_cpp_read_main_file +_merge_include_chains +_remove_dup_dirs +_remove_dup_dir +__cpp_read_file +_open_file +_find_or_create_entry +_splay_tree_lookup +_splay_tree_splay +_splay_tree_insert +_splay_tree_foreach +_splay_tree_foreach_helper +_inode_finder +_stack_include_file +_read_include_file +_cpp_push_buffer +__cpp_do_file_change +_add_line_map +_cb_file_change +_update_header_times +_extract_interface_info +_get_fileinfo +_splay_tree_splay_helper +_c_common_init +_init_pragma +_cpp_register_pragma +_cpp_lookup +_lookup_pragma_entry +_insert_pragma_entry +__cpp_aligned_alloc +_cxx_init +_init_cp_pragma +_init_repo +_objc_init +_add_objc_tree_codes +_set_dump_tree_p +_init_objc +_hash_init +_synth_module_prologue +_push_lang_context +_objcp_xref_tag +_xref_tag +_tree_low_cst +_host_integerp +_identifier_type_value +_lookup_tag +_binding_for_name +_lookup_name +_lookup_name_real +_lookup_flags +_unqualified_namespace_lookup +_current_decl_namespace +_find_binding +_lookup_using_namespace +_select_decl +_make_aggr_type +_cp_make_lang_type +_default_set_default_type_attributes +_build_pointer_type +_layout_type +_size_int_wide +_size_int_type_wide +_force_fit_type +_htab_find_slot +_size_htab_hash +_size_htab_eq +_finalize_type_size +_get_mode_alignment +_round_type_align +_round_up +_size_binop +_int_const_binop +_integer_onep +_make_binfo +_make_tree_vec +_pushtag +_current_scope +_create_implicit_typedef +_set_identifier_type_value_with_scope +_maybe_process_template_type_declaration +_maybe_check_template_type +_pushdecl_with_scope +_objc_declare_class +_is_class_name +_lookup_interface +_objcp_lookup_name +_follow_tag_typedef +_original_type +_build_function_type +_type_hash_list +_type_hash_canon +_type_hash_lookup +_htab_find_with_hash +_type_hash_add +_objcp_builtin_function +_type_hash_eq +_attribute_list_equal +_attribute_list_contained +_type_list_equal +_generate_forward_declaration_to_string_table +_build_nt +_define_decl +_objcp_start_decl +_start_decl +_chainon +_grokdeclarator +_toplevel_bindings_p +_cp_type_quals +_strip_array_types +_cp_build_qualified_type_real +_create_array_type_for_decl +_build_cplus_array_type +_build_cplus_array_type_1 +_uses_template_parms +_is_id +_for_each_template_parm +_walk_tree +_for_each_template_parm_r +_cp_walk_subtrees +_build_array_type +_grokvardecl +_layout_decl +_set_decl_namespace +_is_namespace_ancestor +_no_linkage_check +_walk_tree_without_duplicates +_htab_find +_hash_pointer +_no_linkage_helper +_htab_delete +_bad_specifiers +_c_apply_type_quals_to_decl +_cplus_decl_attributes +_maybe_apply_pragma_weak +_maybe_push_decl +_maybe_register_incomplete_var +_start_decl_1 +_maybe_push_cleanup_level +_objcp_finish_decl +_cp_finish_decl +_maybe_apply_renaming_pragma +_cp_has_mutable_p +_target_type +_check_initializer +_maybe_deduce_size_from_array_init +_complete_array_type +_current_stmt_tree +_layout_var_decl +_maybe_commonize_var +_make_rtl_for_nonlocal_decl +_rest_of_decl_compilation +_timevar_push +_assemble_variable +_timevar_pop +_abstract_virtuals_error +_pop_lang_context +_objc_act_parse_init +_lang_dependent_init +_init_asm_output +_strip_off_ending +_init_eh +_init_optabs +_c_lex +_read_token +_read_process_identifier +_altivec_treat_as_keyword +_yylex +_yyparse_1 +_do_pending_lang_change +_cpp_get_token +__cpp_lex_token +__cpp_lex_direct +_skip_whitespace +_parse_identifier +_enter_macro_context +_push_token_context +_next_context +_padding_token +__cpp_temp_token +_hash_tree_cons +_list_hash_pieces +__cpp_pop_context +_scan_tokens +_frob_id +_parse_decl0 +_frob_specs +_save_type_access_control +_split_specs_attrs +_parse_decl +_build_type_copy +_copy_node +_parse_end_decl +_decl_type_access_control +_deferred_type_access_control +_note_list_got_semicolon +_clear_anon_tags +_do_pending_inlines +_ggc_collect +_handle_newline +_get_effective_char +__cpp_handle_directive +_start_directive +_directive_diagnostics +_do_endif +_check_eol +_skip_block_comment +_end_directive +_skip_rest_of_line +_do_undef +_lex_macro_node +_adjust_column +_do_if +__cpp_parse_expr +_lex +_parse_defined +_push_conditional +_do_ifndef +__obstack_newchunk +_do_define +__cpp_create_definition +_alloc_expansion_token +_pfe_is_cmd_ln_processing +_cb_line_change +_list_hash_eq +_build_tree_list +_do_ifdef +_find_include_file +__cpp_execute_include +_push_srcloc +_debug_nothing_int_charstar +__cpp_never_reread +_do_import +_do_include_common +_parse_include +_parse_string +_unescaped_terminator_p +_hmap_lookup_path +_maybe_note_name_used_in_class +_note_got_semicolon +_parse_params +_save_parameter +_lex_expansion_token +_parse_number +_parse_number +___udivdi3 +___udivmoddi4 +_do_else +_identifier_type +_do_include +_search_from +_lbasename +__cpp_pop_buffer +__cpp_pop_file_buffer +_purge_cache +_pop_srcloc +_debug_nothing_int +_do_elif +_comptypes +_compparms +_add_method +_build_overload +_ovl_cons +_clone_function_decl +_clone_constructors_and_destructors +_check_bases_and_members +_finish_struct_methods +_maybe_warn_about_overly_private_class +_method_name_cmp +_type_requires_array_cookie +_lookup_fnfields +_lookup_member +_complete_type +_bfs_walk +_varray_init +_lookup_field_r +_lookup_fnfields_1 +_lookup_field_1 +_finish_struct_1 +_layout_class_type +_start_record_layout +_determine_primary_base +_create_vtable_ptr +_build_base_fields +_layout_nonempty_base_or_field +_place_field +_integer_zerop +_default_ms_bitfield_layout_p +_normalize_rli +_normalize_offset +_compare_tree_int +_tree_int_cst_sgn +_byte_position +_byte_from_pos +_convert +_ocp_convert +_decl_constant_value +_convert_to_integer +_build1 +_first_rtl_op +_fold +_fold_convert +_layout_conflict_p +_splay_tree_max +_add_double +_end_of_class +_rli_size_unit_so_far +_finish_record_layout +_finalize_record_size +_mul_double +_encode +_decode +_rli_size_so_far +_bit_from_pos +_compute_record_mode +_bit_position +_int_bit_position +_simple_cst_equal +_mode_for_size_tree +_remove_zero_width_bit_fields +_layout_virtual_bases +_warn_about_ambiguous_direct_bases +_splay_tree_delete +_splay_tree_delete_helper +_splay_tree_xmalloc_deallocate +_nreverse +_modify_all_vtables +_dfs_walk +_dfs_walk_real +_dfs_modify_vtables +_dfs_unmark +_finish_struct_bits +_aggregate_value_p +_count_fields +_add_fields_to_vec +_field_decl_cmp +_finish_vtbls +_accumulate_vtbl_inits +_build_vtt +_build_vtt_inits +_complete_vars +_maybe_suppress_debug_info +_dump_class_hierarchy +_dump_begin +_decl_function_context +_rest_of_type_compilation +_finish_struct +_popclass +_poplevel_class +_pop_binding +_pop_binding_level +_find_class_binding_level +_pop_class_decls +_pop_search_level +_pop_stack_level +_finish_class_definition +_check_for_missing_semicolon +_do_pending_defargs +_done_pending_defargs +_begin_inline_definitions +_finish_inline_definitions +_clear_inline_text_obstack +_set_identifier_type_value +_build_self_reference +_finish_member_declaration +_pushdecl_class_level +_push_class_level_binding +_push_class_binding +_note_name_declared_in_class +_push_binding +_context_for_name_lookup +_is_properly_derived_from +_begin_class_definition +_check_class_key +_decl_namespace +_parse_field0 +_parse_field +_grokfield +_constructor_name +_constructor_name_full +_objc_check_decl +_template_class_depth +_template_class_depth_real +_splay_tree_compare_pointers +_reset_type_access_control +_unreverse_member_declarations +_fixup_inline_methods +_check_bases +_check_field_decls +_delete_duplicate_fields +_delete_duplicate_fields_1 +_pod_type_p +_check_field_decl +_finish_struct_anon +_check_methods +_add_implicitly_declared_members +_implicitly_declare_fn +_synthesize_exception_spec +_make_call_declarator +_parmlist_is_exprlist +_check_special_function_return_type +_member_function_or_else +_grokparms +_build_cplus_method_type +_grokfndecl +_build_exception_variant +_comp_except_specs +_eq_pointer +_get_containing_scope +_grokclassfn +_build_qualified_type +_get_qualified_type +_set_type_quals +_build_artificial_parm +_maybe_retrofit_in_chrg +_statement_code_p +_cp_statement_code_p +_cp_is_overload_p +_check_explicit_specialization +_current_tmpl_spec_kind +_grok_ctor_properties +_copy_fn_p +_skip_artificial_parms_for +_grok_special_member_properties +_sufficient_parms_p +_defer_fn +_build_reference_type +_hash_tree_chain +_type_promotes_to +_c_promoting_integer_type_p +_grok_op_properties +_ambi_op_p +_unary_op_p +_build_clone +_copy_decl +_copy_lang_decl +_copy_list +_parse_bitfield0 +_parse_bitfield +_grokbitfield +_constant_expression_warning +_lex_number +_int_fits_type_p +_check_bitfield_decl +_do_aggr +_yyungetc +_handle_class_head +_maybe_process_partial_specialization +_pushclass +_invalidate_class_lookup_cache +_pushlevel_class +_push_binding_level +_push_class_decls +_push_search_level +_push_stack_level +_dfs_push_type_decls +_dfs_push_decls +_storetags +_reset_specialization +_make_pointer_declarator +_get_type_decl +_finish_decl_parsing +_check_for_new_type +_finish_parmlist +_varray_grow +_pfe_s_realloc +_pfe_realloc +_do_warning +__cpp_extend_buff +_nothrow_libfn_p +_libc_name_p +_lex_string +_build_string +_lookup_tag_reverse +_skip_escaped_newlines +_begin_function_definition +_start_function +_lookup_attribute +_check_function_type +_require_complete_types_for_parms +_complete_type_or_else +_init_function_start +_prepare_function_start +_init_stmt_for_function +_init_eh_for_function +_init_emit +_clear_emit_caches +_init_virtual_regs +_init_expr +_init_varasm_status +_init_temp_slots +_init_pending_stack_adjust +_push_cp_function_context +_rs6000_init_machine_status +_objc_printable_name +_objc_demangle +_emit_line_note +_set_file_and_line_for_stmt +_emit_note +_hard_function_value +_begin_stmt_tree +_announce_function +_pushlevel +_start_fname_decls +_store_parm_decls +_storedecls +_push_local_binding +_getdecls +_gettags +_begin_function_body +_keep_next_level +_begin_compound_stmt +_build_stmt +_add_stmt +_stmts_are_full_exprs_p +_do_pushlevel +_make_binding_level +_add_scope_stmt +_current_scope_stmt_stack +_at_function_scope_p +_compute_array_index_type +_cp_convert +_build_binary_op +_really_overloaded_fn +_default_conversion +_decay_conversion +_type_unknown_p +_is_overloaded_fn +_common_type +_type_after_usual_arithmetic_conversions +_merge_type_attributes +_merge_attributes +_build_type_attribute_variant +_build +_operand_equal_p +_tree_int_cst_equal +_const_binop +_neg_double +_build_index_type +_non_lvalue +_place_union_field +_qualify_lookup +_finish_id_expr +_do_identifier +_objcp_lookup_identifier +_lookup_objc_ivar +_hack_identifier +_mark_used +_assemble_external +_convert_from_reference +_build_x_unary_op +_build_new_op +_build_unary_op +_lvalue_type +_unary_complex_lvalue +_lvalue_or_else +_lvalue_p +_lvalue_p_1 +_mark_addressable +_staticp +_reparse_absdcl_as_casts +_altivec_is_vector_constant_element +_groktypename +_build_c_cast +_convert_force +_convert_to_pointer_force +_cp_convert_to_pointer +_build_x_modify_expr +_build_modify_expr +_require_complete_type +_convert_for_assignment +_dubious_conversion_warnings +_overflow_warning +_can_convert_arg_bad +_implicit_conversion +_standard_conversion +_strip_top_quals +_perform_implicit_conversion +_convert_like_real +_finish_expr_stmt +_convert_to_void +_finish_stmt +_dependent_base_p +_currently_open_class +_type_access_control +_build_x_component_ref +_build_component_ref +_lookup_field +_enforce_access +_accessible_p +_friend_accessible_p +_access_in_type +_dfs_access_in_type +_assert_canonical_unmarked +_dfs_assert_unmarked_p +_dfs_accessible_p +_grok_array_decl +_build_expr_type_conversion +_build_array_ref +_build_x_arrow +_build_indirect_ref +_canonical_type_variant +_build_conv +_finish_call_expr +_is_global +_lookup_arg_dependent +_arg_assoc_args +_arg_assoc +_arg_assoc_type +_build_x_function_call +_build_function_call +_build_function_call_real +_decl_target_overloaded_intrinsic_p +_inline_conversion +_convert_arguments +_convert_for_initialization +_build_call +_build_addr_func +_is_empty_class +_finish_return_stmt +_check_return_expr +_maybe_warn_about_returning_address_of_local +_finish_compound_stmt +_finish_function_body +_do_poplevel +_kept_level_p +_poplevel +_warn_about_unused_variables +_finish_function +_finish_fname_decls +_finish_stmt_tree +_pop_labels +_save_function_data +_calls_setjmp_p +_calls_setjmp_r +_setjmp_call_p +_special_function_p +_free_after_parsing +_pop_cp_function_context +_free_stmt_status +_free_after_compilation +_free_eh_status +_free_expr_status +_free_emit_status +_free_varasm_status +_rs6000_free_machine_status +_expand_body +_simplify_aggr_init_exprs_r +_maybe_clone_body +_debug_nothing_tree +_start_enum +_build_enumerator +_tree_int_cst_lt +_finish_enum +_min_precision +_tree_floor_log2 +_fixup_unsigned_type +_smallest_mode_for_size +_shadow_tag +_check_tag_decl +_add_builtin_candidates +_non_reference +_type_decays_to +_type_for_size +_add_builtin_candidate +_build_builtin_candidate +_add_candidate +_any_viable +_splice_viable +_tourney +_lshift_double +_finish_parenthesized_expr +_build_x_binary_op +_lookup_function_nonclass +_lookup_name_nonclass +_arg_assoc_namespace +_purpose_member +_get_narrower +_truth_value_p +_integer_all_onesp +_distribute_bit_expr +_default_comp_type_attributes +_build_x_indirect_ref +_build_opfncall +_reparse_decl_as_expr +_build_expr_from_tree +_warn_of_redefinition +_cpp_pedwarn_with_line +__cpp_begin_message +__cpp_free_definition +_funlike_invocation_p +_collect_args +_replace_args +_expand_arg +_push_ptoken_context +__cpp_release_buff +_finish_sizeof +_c_sizeof +_extract_muldiv +_get_inner_array_type +_duplicate_decls +_redeclaration_error_message +_locate_copy +_merge_exception_specifiers +_add_binding +_locate_ctor +_make_anon_name +_clear_identifier_class_values +_merge_decl_attributes +_merge_types +_commonparms +_list_length +_tree_last +_skip_line_comment +_trigraph_p +_see_typename +_push_nested_class +_set_class_shadows +_unuse_fields +_dfs_unuse_fields +_maybe_begin_member_template_processing +_inline_needs_template_parms +_feed_defarg +_feed_input +_replace_defarg +_can_convert_arg +_finish_defarg +_end_input +_obstack_free +_maybe_end_member_template_processing +_pop_nested_class diff --git a/order-files/cc1plus.order b/order-files/cc1plus.order new file mode 100644 index 00000000000..39806c011ca --- /dev/null +++ b/order-files/cc1plus.order @@ -0,0 +1,1356 @@ +start +__start +__dyld_init_check +dyld_stub_binding_helper +___darwin_gcc3_preregister_frame_info +__call_mod_init_funcs +__dyld_func_lookup +_main +_toplev_main +_hex_init +_general_init +_xmalloc_set_program_name +_diagnostic_initialize +__obstack_begin +_xmalloc +_parse_options_and_default_flags +_init_reg_sets +_add_params +_xrealloc +_pfe_init +_read_integral_parameter +_override_O_option +_extract_override_options +_lang_init_options +_cxx_init_options +_c_common_init_options +_cpp_create_reader +_init_library +_init_trigraph_map +_xcalloc +_set_lang +_deps_init +_init_line_maps +__cpp_init_tokenrun +__cpp_get_buff +_new_buff +_pfe_s_malloc +_pfe_malloc +_gcc_obstack_init +_pfe_obstack_chuck_alloc +__cpp_init_includes +_splay_tree_new +_splay_tree_new_with_allocator +_splay_tree_xmalloc_allocate +_set_index_lang +_set_target_switch +_optimization_options +_override_option +_cxx_decode_option +_cpp_handle_option +_parse_option +_xstrdup +_append_include_chain +__cpp_simplify_pathname +_independent_decode_option +_remove_component_p +_new_pending_directive +_compare_options +_dump_switch_p +_decode_f_option +_decode_g_option +_set_Wunused +_set_Wformat +_decode_W_option +_output_set_maximum_length +_set_real_maximum_length +_output_is_line_wrapping +_add_env_options +_cxx_post_options +_c_common_post_options +_cpp_post_options +_init_dependency_output +_do_compile +_process_options +_rs6000_override_options +_rs6000_parse_abi_options +_rs6000_add_gc_roots +_ggc_add_rtx_root +_ggc_add_root +_htab_create +_higher_prime_number +_machopic_add_gc_roots +_ggc_add_tree_root +_new_alias_set +_floor_log2_wide +_init_timevar +_timevar_start +_lang_independent_init +_init_ggc +_exact_log2_wide +_pfe_s_calloc +_pfe_calloc +_init_stringpool +_ht_create +_init_obstacks +_ggc_add_deletable_htab +_init_emit_once +_mode_for_size +_gen_rtx +_rtx_alloc +_ggc_alloc +_alloc_page +_pfe_free +_set_page_table_entry +_gen_raw_REG +_gen_rtx_fmt_i0 +_gen_rtx_fmt_w +_ereal_atof +_asctoe53 +_asctoeg +_ecleaz +_enormlz +_eshup6 +_toe53 +_eiisnan +_eshift +_eshup1 +_e53toe +_eshdn1 +_ecleazs +_emovo +_emovz +_eaddm +_eshup8 +_emdnorm +_gen_rtx_CONST_INT +_gen_const_vector_0 +_rtvec_alloc +_gen_rtx_fmt_E0 +_gen_rtx_REG +_init_regs +_init_reg_sets_1 +_reg_class_subset_p +_init_reg_modes +_choose_hard_reg_mode +_gen_rtx_MEM +_gen_rtx_fmt_e0 +_init_alias_once +_init_stmt +_init_loop +_address_cost +_memory_address_p +_rs6000_legitimate_address +_init_reload +_gen_rtx_fmt_ee +_gen_rtx_fmt_s +_pfe_savestring +_plus_constant_wide +_find_constant_term_loc +_init_varasm_once +_init_EXPR_INSN_LIST_cache +_init_dummy_function_start +_prepare_function_start +_ggc_alloc_cleared +_init_stmt_for_function +_init_eh_for_function +_init_emit +_clear_emit_caches +_init_virtual_regs +_init_expr +_init_varasm_status +_init_temp_slots +_init_pending_stack_adjust +_rs6000_init_machine_status +_init_expmed +_start_sequence +_rtx_cost +_emit_insn +_make_insn_raw +_add_insn +_init_recog +_recog +_recog_13 +_gpc_reg_operand +_register_operand +_recog_4 +_reg_or_cint_operand +_recog_5 +_nonimmediate_operand +_general_operand +_input_operand +_memory_operand +_toc_relative_expr_p +_constant_pool_expr_1 +_reg_or_short_operand +_short_cint_operand +_htab_find_slot_with_hash +_const_int_htab_eq +_init_expr_once +_boolean_or_operator +_boolean_operator +_recog_1 +_reg_or_mem_operand +_recog_7 +_recog_10 +_recog_9 +_altivec_register_operand +_zero_constant +_strict_memory_address_p +_init_caller_save +_recog_memoized_1 +_extract_insn +_insn_extract +_constrain_operands +_reg_fits_class_p +_recog_6 +_cc_reg_operand +_ht_lookup +_alloc_node +_make_node +_tree_size +_get_identifier +_init_reswords +_calc_hash +_cxx_init +_init_spew +_init_tree +_set_dump_tree_p +_init_cplus_expand +_init_cp_semantics +_add_c_tree_codes +_add_cpp_tree_codes +_init_operators +_init_method +_init_mangle +_varray_init +_init_error +_init_output_buffer +_output_set_prefix +_clear_diagnostic_info +_build_int_2_wide +_cxx_init_decl_processing +_initialize_predefined_identifiers +_cp_parse_init +_init_decl2 +_ggc_add_tree_varray_root +_init_pt +_push_to_top_level +_maybe_push_to_top_level +_push_namespace +_build_lang_decl +_build_decl +_retrofit_lang_decl +_build_common_tree_nodes +_initialize_sizetypes +_default_set_default_type_attributes +_get_mode_alignment +_copy_node +_make_signed_type +_fixup_signed_type +_layout_type +_tree_int_cst_sgn +_smallest_mode_for_size +_size_int_wide +_size_int_type_wide +_force_fit_type +_htab_find_slot +_size_htab_hash +_finalize_type_size +_round_type_align +_round_up +_size_htab_eq +_size_binop +_int_const_binop +_integer_onep +_tree_cons +_make_unsigned_type +_fixup_unsigned_type +_pushlevel +_make_binding_level +_push_binding_level +_declare_namespace_level +_namespace_binding +_pushdecl +_lookup_name_current_level +_check_template_shadow +_namespace_bindings_p +_innermost_nonclass_level +_set_namespace_binding +_add_decl_to_level +_pop_namespace +_suspend_binding_level +_find_class_binding_level +_c_common_nodes_and_builtins +_record_builtin_type +_set_identifier_type_value_with_scope +_binding_for_name +_find_binding +_set_identifier_type_value +_identifier_global_value +_signed_type +_set_sizetype +_build_common_tree_nodes_2 +_build_pointer_type +_build_qualified_type +_get_qualified_type +_build_type_copy +_set_type_quals +_mul_double +_encode +_decode +_rs6000_build_va_list +_make_vector +_finish_vector_type +_build_index_type +_convert +_ocp_convert +_complete_type +_decl_constant_value +_convert_to_integer +_build1 +_first_rtl_op +_fold +_fold_convert +_compare_tree_int +_host_integerp +_tree_low_cst +_type_hash_canon +_type_hash_lookup +_htab_find_with_hash +_type_hash_add +_build_array_type +_build +_integer_zerop +_comptypes +_non_lvalue +_add_double +_simple_cst_equal +_mode_for_size_tree +_start_record_layout +_place_field +_layout_decl +_default_ms_bitfield_layout_p +_normalize_rli +_normalize_offset +_finish_record_layout +_finalize_record_size +_get_inner_array_type +_rli_size_so_far +_bit_from_pos +_rli_size_unit_so_far +_byte_from_pos +_compute_record_mode +_type_hash_eq +_attribute_list_equal +_attribute_list_contained +_bit_position +_int_bit_position +_build_function_type +_type_hash_list +_type_list_equal +_builtin_function_2 +_builtin_function +_builtin_function_1 +_build_library_fn_1 +_push_overloaded_decl +_decls_match +_warn_extern_redeclared_static +_check_default_args +_make_decl_rtl +_decode_reg_name +_darwin_encode_section_info +_ggc_alloc_string +_update_stubs +_decl_attributes +_init_attributes +_default_insert_attributes +_insert_default_attributes +_c_common_insert_default_attributes +_c_init_attributes +_builtin_function_disabled_p +_mangle_decl +_mangle_decl_string +_resume_binding_level +_strip_array_types +_cp_type_quals +_build_cplus_array_type +_build_cplus_array_type_1 +_uses_template_parms +_for_each_template_parm +_walk_tree +_for_each_template_parm_r +_cp_walk_subtrees +_statement_code_p +_cp_statement_code_p +_cp_is_overload_p +_record_unknown_type +_xref_tag +_identifier_type_value +_add_exception_specifier +_build_tree_list +_build_exception_variant +_comp_except_specs +_push_cp_library_fn +_build_cp_library_fn +_set_mangled_name_for_decl +_write_encoding +_write_name +_decl_is_template_id +_write_unscoped_name +_write_unqualified_name +_write_bare_function_type +_write_method_parms +_write_type +_find_substitution +_canonical_type_variant +_cp_build_qualified_type_real +_write_CV_qualifiers_for_type +_write_builtin_type +_add_substitution +_build_library_fn_ptr +_build_library_fn +_init_class_processing +_init_one_libfunc +_init_exception_processing +_supports_one_only +_start_fname_decls +_using_eh_for_cleanups +_type_for_size +_init_cpp_parse +_c_common_init +_init_c_lex +_get_fileinfo +_splay_tree_lookup +_splay_tree_splay +_splay_tree_insert +_cpp_get_callbacks +_cpp_read_main_file +__cpp_init_hashtable +__cpp_init_directives +_cpp_lookup +__cpp_init_internal_pragmas +_cpp_register_pragma +_lookup_pragma_entry +_insert_pragma_entry +__cpp_aligned_alloc +_init_standard_includes +_update_path +_concat +_translate_name +_get_key_value +_merge_include_chains +_remove_dup_dirs +_remove_dup_dir +_cpp_warning +__cpp_begin_message +__cpp_read_file +_open_file +_find_or_create_entry +_splay_tree_foreach +_splay_tree_foreach_helper +_inode_finder +_stack_include_file +_read_include_file +_cpp_push_buffer +__cpp_do_file_change +_add_line_map +_cb_file_change +_update_header_times +_extract_interface_info +_splay_tree_splay_helper +_init_pragma +_init_cp_pragma +_init_repo +_lang_dependent_init +_init_asm_output +_init_eh +_init_optabs +_init_all_optabs +_init_integral_libfuncs +_init_libfuncs +_init_floating_libfuncs +__obstack_newchunk +_dwarf2out_do_frame +_dwarf2out_frame_init +_dwarf2out_def_cfa +_def_cfa_1 +_lookup_cfa +_add_fde_cfi +_initial_return_save +_reg_save +_dbxout_init +_getdecls +_getpwd +_output_quoted_string +_assemble_name +_maybe_get_identifier +_text_section +_dbxout_typedefs +_dbxout_symbol +_timevar_pop +_compile_file +_init_final +_init_branch_prob +_timevar_push +_yyparse +_dbxout_start_source_file +_cpp_finish_options +_init_builtins +__cpp_define_builtin +_run_directive +_start_directive +_do_define +_lex_macro_node +__cpp_lex_token +__cpp_lex_direct +_parse_identifier +__cpp_create_definition +_skip_whitespace +_parse_string +_unescaped_terminator_p +_alloc_expansion_token +_lex_expansion_token +_handle_newline +_pfe_is_cmd_ln_processing +_end_directive +_skip_rest_of_line +__cpp_pop_buffer +_parse_number +_pfe_set_cmd_ln_processing +_cpp_define +_warn_of_redefinition +__cpp_equiv_tokens +__cpp_free_definition +_pfe_reset_cmd_ln_processing +_free_chain +__cpp_push_next_buffer +_push_include +__cpp_execute_include +_find_include_file +_search_from +_push_srcloc +_yyparse_1 +_yylex +_read_token +_c_lex +_cpp_get_token +_get_effective_char +_skip_block_comment +_adjust_column +_skip_line_comment +__cpp_handle_directive +_directive_diagnostics +_do_ifndef +_check_eol +_push_conditional +_do_else +_do_endif +___udivmoddi4 +_parse_number +_lex +__cpp_parse_expr +__cpp_pop_context +_do_if +_do_include +_do_include_common +_parse_include +_find_framework_file +_skip_escaped_newlines +_enter_macro_context +_push_token_context +_next_context +___udivdi3 +_parse_defined +_do_elif +__cpp_pop_file_buffer +_purge_cache +_pop_srcloc +_dbxout_end_source_file +_lbasename +_parse_params +_save_parameter +_read_process_identifier +_altivec_treat_as_keyword +_padding_token +__cpp_temp_token +_hash_tree_cons +_list_hash_pieces +_scan_tokens +_frob_id +_lookup_name +_lookup_name_real +_lookup_flags +_unqualified_namespace_lookup +_current_decl_namespace +_lookup_using_namespace +_select_decl +_chainon +_parse_decl0 +_frob_specs +_save_type_access_control +_split_specs_attrs +_parse_decl +_start_decl +_grokdeclarator +_toplevel_bindings_p +_bad_specifiers +_cplus_decl_attributes +_maybe_apply_pragma_weak +_maybe_push_decl +_start_decl_1 +_maybe_push_cleanup_level +_parse_end_decl +_decl_type_access_control +_deferred_type_access_control +_cp_finish_decl +_maybe_apply_renaming_pragma +_cp_has_mutable_p +_rest_of_decl_compilation +_note_list_got_semicolon +_clear_anon_tags +_do_pending_inlines +_ggc_collect +_cb_line_change +_list_hash_eq +_identifier_type +_maybe_note_name_used_in_class +_note_got_semicolon +_do_aggr +_yyungetc +_handle_class_head +_current_scope +_lookup_tag +_make_aggr_type +_cp_make_lang_type +_make_binfo +_make_tree_vec +_pushtag +_create_implicit_typedef +_maybe_process_template_type_declaration +_maybe_check_template_type +_pushdecl_with_scope +_begin_class_definition +_reset_type_access_control +_maybe_process_partial_specialization +_pushclass +_pushlevel_class +_push_class_decls +_push_search_level +_push_stack_level +_dfs_walk +_dfs_walk_real +_dfs_push_type_decls +_dfs_push_decls +_storetags +_reset_specialization +_build_self_reference +_constructor_name +_constructor_name_full +_finish_member_declaration +_pushdecl_class_level +_push_class_level_binding +_push_class_binding +_note_name_declared_in_class +_push_binding +_context_for_name_lookup +_is_properly_derived_from +_check_class_key +_decl_namespace +_parse_field0 +_parse_field +_grokfield +_c_apply_type_quals_to_decl +_target_type +_check_initializer +_maybe_deduce_size_from_array_init +_current_stmt_tree +_template_class_depth +_template_class_depth_real +_splay_tree_compare_pointers +_finish_class_definition +_finish_struct +_unreverse_member_declarations +_nreverse +_finish_struct_1 +_fixup_inline_methods +_check_bases_and_members +_check_bases +_check_field_decls +_delete_duplicate_fields +_delete_duplicate_fields_1 +_pod_type_p +_check_field_decl +_finish_struct_anon +_check_methods +_add_implicitly_declared_members +_implicitly_declare_fn +_synthesize_exception_spec +_make_call_declarator +_build_nt +_parmlist_is_exprlist +_check_special_function_return_type +_member_function_or_else +_grokparms +_build_cplus_method_type +_decl_function_context +_grokfndecl +_no_linkage_check +_walk_tree_without_duplicates +_htab_find +_hash_pointer +_no_linkage_helper +_eq_pointer +_htab_delete +_get_containing_scope +_grokclassfn +_build_artificial_parm +_abstract_virtuals_error +_defer_fn +_build_reference_type +_hash_tree_chain +_type_promotes_to +_c_promoting_integer_type_p +_maybe_retrofit_in_chrg +_check_explicit_specialization +_current_tmpl_spec_kind +_grok_ctor_properties +_copy_fn_p +_skip_artificial_parms_for +_grok_special_member_properties +_make_rtl_for_nonlocal_decl +_assemble_variable +_grok_op_properties +_ambi_op_p +_unary_op_p +_add_method +_build_overload +_compparms +_ovl_cons +_clone_constructors_and_destructors +_clone_function_decl +_build_clone +_copy_decl +_copy_lang_decl +_copy_list +_finish_struct_methods +_maybe_warn_about_overly_private_class +_method_name_cmp +_type_requires_array_cookie +_lookup_fnfields +_lookup_member +_bfs_walk +_lookup_field_r +_lookup_fnfields_1 +_lookup_field_1 +_layout_class_type +_determine_primary_base +_create_vtable_ptr +_build_base_fields +_layout_nonempty_base_or_field +_byte_position +_layout_conflict_p +_splay_tree_max +_end_of_class +_aggregate_value_p +_finish_struct_bits +_count_fields +_finish_vtbls +_accumulate_vtbl_inits +_build_vtt +_build_vtt_inits +_complete_vars +_maybe_suppress_debug_info +_dump_class_hierarchy +_dump_begin +_rest_of_type_compilation +_popclass +_poplevel_class +_pop_binding +_pop_binding_level +_pop_class_decls +_pop_search_level +_pop_stack_level +_splay_tree_delete +_splay_tree_delete_helper +_splay_tree_xmalloc_deallocate +_do_pending_defargs +_done_pending_defargs +_begin_inline_definitions +_finish_inline_definitions +_clear_inline_text_obstack +_shadow_tag +_check_tag_decl +_follow_tag_typedef +_original_type +_duplicate_decls +_redeclaration_error_message +_invalidate_class_lookup_cache +_sufficient_parms_p +_make_pointer_declarator +_create_array_type_for_decl +_compute_array_index_type +_constant_expression_warning +_cp_convert +_build_binary_op +_really_overloaded_fn +_default_conversion +_decay_conversion +_type_unknown_p +_is_overloaded_fn +_common_type +_type_after_usual_arithmetic_conversions +_merge_type_attributes +_merge_attributes +_build_type_attribute_variant +_operand_equal_p +_tree_int_cst_equal +_const_binop +_neg_double +_lex_number +_remove_zero_width_bit_fields +_layout_virtual_bases +_warn_about_ambiguous_direct_bases +_modify_all_vtables +_dfs_modify_vtables +_dfs_unmark +_int_fits_type_p +_do_ifdef +_check_for_new_type +_finish_parmlist +_begin_function_definition +_start_function +_nothrow_libfn_p +_libc_name_p +_lookup_attribute +_check_function_type +_require_complete_types_for_parms +_complete_type_or_else +_init_function_start +_push_cp_function_context +_lang_printable_name +_lang_decl_name +_decl_as_string +_output_clear_message_text +_dump_decl +_dump_function_decl +_dump_type_prefix +_dump_type +_dump_qualifiers +_output_add_string +_maybe_wrap_text +_output_append +_output_emit_prefix +_output_append_r +_output_add_space +_dump_scope +_dump_function_name +_dump_parameters +_output_add_character +_dump_type_suffix +_output_finalize_message +_emit_line_note +_set_file_and_line_for_stmt +_emit_note +_hard_function_value +_begin_stmt_tree +_announce_function +_store_parm_decls +_storedecls +_push_local_binding +_gettags +_begin_function_body +_keep_next_level +_begin_compound_stmt +_build_stmt +_add_stmt +_stmts_are_full_exprs_p +_do_pushlevel +_add_scope_stmt +_current_scope_stmt_stack +_build_expr_from_tree +_do_identifier +_qualify_lookup +_objcp_lookup_identifier +_hack_identifier +_mark_used +_assemble_external +_convert_from_reference +_build_x_indirect_ref +_build_opfncall +_build_new_op +_build_indirect_ref +_reparse_decl_as_expr +_finish_parenthesized_expr +_finish_return_stmt +_check_return_expr +_convert_for_initialization +_convert_for_assignment +_dubious_conversion_warnings +_overflow_warning +_can_convert_arg_bad +_implicit_conversion +_standard_conversion +_strip_top_quals +_lvalue_p +_lvalue_p_1 +_build_conv +_perform_implicit_conversion +_convert_like_real +_maybe_warn_about_returning_address_of_local +_finish_stmt +_finish_compound_stmt +_finish_function_body +_do_poplevel +_kept_level_p +_poplevel +_warn_about_unused_variables +_finish_function +_finish_fname_decls +_finish_stmt_tree +_pop_labels +_save_function_data +_calls_setjmp_p +_calls_setjmp_r +_free_after_parsing +_pop_cp_function_context +_free_stmt_status +_free_after_compilation +_free_eh_status +_free_expr_status +_free_emit_status +_free_varasm_status +_rs6000_free_machine_status +_expand_body +_simplify_aggr_init_exprs_r +_maybe_clone_body +_debug_nothing_tree +_lex_string +_build_string +_push_lang_context +_grokvardecl +_set_decl_namespace +_is_namespace_ancestor +_maybe_register_incomplete_var +_layout_var_decl +_maybe_commonize_var +_make_anon_name +_start_enum +_finish_unary_op_expr +_build_x_unary_op +_build_unary_op +_build_expr_type_conversion +_build_enumerator +_check_for_missing_semicolon +_dump_aggr_type +_class_key_or_enum +_check_for_uninitialized_const_var +_at_function_scope_p +_add_decl_stmt +_maybe_inject_for_scope_var +_initialize_local_var +_destroy_local_var +_finish_id_expr +_dependent_base_p +_currently_open_class +_type_access_control +_build_x_component_ref +_build_component_ref +_lookup_field +_enforce_access +_accessible_p +_friend_accessible_p +_access_in_type +_dfs_access_in_type +_assert_canonical_unmarked +_dfs_assert_unmarked_p +_dfs_accessible_p +_build_x_modify_expr +_build_modify_expr +_require_complete_type +_lvalue_or_else +_get_unwidened +_finish_expr_stmt +_convert_to_void +_lookup_base +_lookup_base_r +_build_method_call +_build_new_method_call +_resolve_args +_add_function_candidate +_list_length +_lvalue_type +_reference_binding +_real_lvalue_p +_reference_related_p +_reference_compatible_p +_at_least_as_qualified_p +_direct_reference_binding +_add_candidate +_any_viable +_splice_viable +_tourney +_is_dummy_object +_build_over_call +_unary_complex_lvalue +_mark_addressable +_staticp +_cp_convert_to_pointer +_is_friend +_build_base_path +_resolves_to_fixed_type_p +_fixed_type_or_null +_check_function_format +_build_target_expr_with_type +_build_target_expr +_maybe_build_cleanup +_build_cplus_new +_nullify_returns_r +_htab_expand +_list_hash +_find_empty_slot_for_expand +_finish_decl_parsing +_pop_lang_context +_lookup_tag_reverse +_finish_enum +_tree_int_cst_lt +_min_precision +_tree_floor_log2 +_do_undef +_get_inner_reference +_optimize_bit_field_compare +_condition_conversion +_has_cleanups +_finish_if_stmt_cond +_build_x_arrow +_build_x_binary_op +_split_tree +_grok_array_decl +_build_array_ref +_cp_pointer_int_sum +_pointer_int_sum +_size_in_bytes +_extract_muldiv +_finish_then_clause +_finish_if_stmt +_begin_if_stmt +_shorten_compare +_get_narrower +_invert_tree_comparison +_fold_range_test +_make_range +_cp_truthvalue_conversion +_truthvalue_conversion +_fold_truthop +_maybe_convert_cond +_negate_expr +_finish_call_expr +_is_global +_lookup_arg_dependent +_arg_assoc_args +_arg_assoc +_arg_assoc_type +_build_x_function_call +_build_function_call +_build_function_call_real +_decl_target_overloaded_intrinsic_p +_inline_conversion +_convert_arguments +_build_call +_build_addr_func +_is_empty_class +_arg_assoc_class +_purpose_member +_arg_assoc_namespace +_convert_class_to_reference +_lookup_conversions +_add_conversions +_build_component_addr +_decl_type_context +_convert_force +_convert_to_pointer_force +_parse_bitfield0 +_parse_bitfield +_grokbitfield +_locate_ctor +_merge_exception_specifiers +_locate_copy +_funlike_invocation_p +_collect_args +_replace_args +_expand_arg +_push_ptoken_context +__cpp_release_buff +_merge_decl_attributes +_merge_types +_type_hash_hash +_lshift_double +_add_fields_to_vec +_field_decl_cmp +__cpp_extend_buff +_twoval_comparison_p +_swap_tree_comparison +_merge_ranges +_range_binop +_build_range_check +_unsigned_type +_invert_truthvalue +_build_x_conditional_expr +_build_conditional_expr +_operand_equal_for_comparison_p +_truth_value_p +_fold_binary_op_with_conditional_arg +_global_bindings_p +_integer_all_onesp +_distribute_bit_expr +_default_comp_type_attributes +_setjmp_call_p +_special_function_p +_warn_about_long_double +_reparse_absdcl_as_casts +_altivec_is_vector_constant_element +_groktypename +_build_c_cast +_convert_to_real +_handle_aligned_attribute +_tree_log2 +_is_attribute_p +_finish_sizeof +_c_sizeof +_place_union_field +_complete_array_type +_handle_format_attribute +_decode_format_attr +_decode_format_type +_attribute_hash_list +_value_member +_commonparms +_tree_last +_lookup_function_nonclass +_lookup_name_nonclass +_add_builtin_candidates +_non_reference +_type_decays_to +_add_builtin_candidate +_build_builtin_candidate +_store_init_value +_digest_init +_combine_strings +_choose_string_type +_finish_asm_stmt +_parse_output_constraint +_check_multiple_declarators +_varray_grow +_pfe_s_realloc +_pfe_realloc +_build_this +_stabilize_reference +_stabilize_reference_1 +_lex_charconst +_cpp_interpret_charconst +_do_pragma +_darwin_pragma_options +_pop_field_alignment +_build_x_compound_expr +_build_compound_expr +_null_ptr_cst_p +_integer_pow2p +_tree_expr_nonnegative_p +_push_field_alignment +__cpp_backup_tokens +_ht_expand +_clear_identifier_class_values +_expand_tree_builtin +_fold_builtin +_trigraph_p +_parse_method +_start_method +_snarf_method +_snarf_block +_finish_method +_fixup_pending_inline +_check_for_override +_protected_accessible_p +_pop_nested_class +_enter_scope_of +_push_nested_class +_set_class_shadows +_unuse_fields +_dfs_unuse_fields +_is_aggr_type +_check_classfn +_finish_this_expr +_maybe_end_member_template_processing +_process_next_inline +_end_input +_obstack_free +_begin_parsing_inclass_inline +_feed_input +_maybe_begin_member_template_processing +_inline_needs_template_parms +_dump_exception_spec +_see_typename +_finish_base_specifier +_xref_basetypes +_unshare_base_binfos +_get_vbase_types +_unmarkedp +_dfs_get_vbase_types +_markedp +_dfs_build_inheritance_graph_order +_unmarked_pushdecls_p +_template_self_reference_p +_setup_class_bindings +_lookup_field_queue_p +_marked_pushdecls_p +_mark_primary_bases +_dfs_unshared_virtual_bases +_build_base_field +_propagate_binfo_offsets +_get_primary_binfo +_record_subobject_offsets +_walk_subobject_offsets +_record_subobject_offset +_dfs_set_offset_for_unshared_vbases +_dfs_unmarked_real_bases_queue_p +_dfs_marked_real_bases_queue_p +_feed_defarg +_grok_method_quals +_cp_type_qual_from_rid +_make_reference_declarator +_comp_ptr_ttypes +_comp_ptr_ttypes_real +_string_conv_p +_frob_opname +_maybe_dummy_object +_build_field_call +_finish_object_call_expr +_initializer_constant_valid_p +_cplus_expand_constant +_layout_vtable_decl +_get_vtbl_decl_for_binfo +_initialize_vtable +_initialize_array +_char_type_p +_process_init_constructor +_dump_vtable +_adjust_clone_args +_begin_eh_spec_block +_begin_constructor_body +_finish_mem_initializers +_emit_base_init +_sort_member_init +_build_field_list +_sort_base_init +_initialize_vtbl_ptrs +_dfs_initialize_vtbl_ptrs +_expand_virtual_init +_build_vtbl_address +_build_vfield_ref +_perform_member_init +_finish_constructor_body +_finish_eh_spec_block +_update_cloned_parm +_store_bindings +_clone_body +_copy_body +_copy_body_r +_cp_auto_var_in_fn_p +_copy_tree_r +_copy_scope_stmt +_remap_block +_insert_block +_nonstatic_local_decl_p +_local_variable_p +_remap_decl +_pop_from_top_level +_pfe_varray_free +_handle_noreturn_attribute +_check_default_argument +_add_defarg_fn +_shared_unmarked_p +_canonical_binfo +_shared_marked_p +_dfs_canonical_queue +_dfs_accessible_queue_p +_is_subobject_of_p +_revert_static_member_fn +_begin_template_parm_list +_begin_scope +_note_template_header +_finish_template_type_parm +_process_template_parm +_build_template_parm_index +_end_template_parm_list +_push_template_decl_real +_template_parm_scope_p +_check_default_tmpl_args +_current_template_args +_build_template_decl +_pushdecl_namespace_level +_classtype_mangled_name +_most_general_template +_mangle_class_name_for_template +_get_innermost_template_args +_type_as_string +_finish_template_decl +_end_template_decl +_finish_scope +_write_nested_name +_write_prefix +_write_source_name +_write_number +_hwint_to_ascii +_write_identifier +_joust +_compare_ics +_maybe_handle_implicit_object +_maybe_handle_ref_bind +_qualified_lookup_using_namespace +_ambiguous_decl +_do_scoped_id +_finish_else_clause +_build_functional_cast +_build_user_type_conversion_1 +_build_ptr_wrapper +_convert_default_arg +_break_out_target_exprs +_bot_manip +_bot_replace +_write_special_name_constructor +_build_delete +_build_dtor_call +_write_special_name_destructor +_build_throw +_is_admissible_throw_operand +_complete_ptr_ref_or_void_ptr_p +_doing_eh +_decl_is_java_type +_push_throw_library_fn +_push_library_fn +_pushdecl_top_level +_push_function_context_to +_pop_function_context_from +_restore_emit_status +_begin_init_stmts +_begin_stmt_expr +_create_temporary_var +_obscure_complex_init +_build_aggr_init +_expand_aggr_init_1 +_expand_default_init +_build_new_function_call +_ptr_reasonably_similar +_begin_else_clause +_finish_init_stmts +_finish_stmt_expr +_build_min +_finish_decl_cleanup +_do_allocate_exception +_prepare_eh_type +_build_eh_type_type +_get_tinfo_decl +_mangle_typeinfo_for_type +_mangle_special_for_type +_write_class_enum_type +_check_bitfield_decl |