Attachment 48740 Details for Bug 95700 – preprocessed output

preprocessed output

read-md.i (text/plain), 467.01 KB, created by Ilya Leoshkevich on 2020-06-16 16:29:25 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ilya Leoshkevich

Created: 2020-06-16 16:29:25 UTC

Size: 467.01 KB

patch

obsolete

># 1 "../../gcc/read-md.c"
># 1 "/home/iii/mac/ibm/gcc/regtest-f8a59086423e/build/gcc//"
># 1 "<built-in>"
># 1 "<command-line>"
># 1 "/usr/include/stdc-predef.h" 1 3 4
># 1 "<command-line>" 2
># 1 "../../gcc/read-md.c"
># 23 "../../gcc/read-md.c"
># 1 "./bconfig.h" 1
>
>
># 1 "./auto-host.h" 1
># 4 "./bconfig.h" 2
>
># 1 "../../gcc/../include/ansidecl.h" 1
># 40 "../../gcc/../include/ansidecl.h"
>extern "C" {
># 433 "../../gcc/../include/ansidecl.h"
>}
># 6 "./bconfig.h" 2
># 24 "../../gcc/read-md.c" 2
>
>
>
># 1 "../../gcc/system.h" 1
># 32 "../../gcc/system.h"
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stdarg.h" 1 3 4
># 40 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stdarg.h" 3 4
>
># 40 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 99 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stdarg.h" 3 4
>typedef __gnuc_va_list va_list;
># 33 "../../gcc/system.h" 2
># 43 "../../gcc/system.h"
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stddef.h" 1 3 4
># 143 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stddef.h" 3 4
>typedef long int ptrdiff_t;
># 209 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stddef.h" 3 4
>typedef long unsigned int size_t;
># 415 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stddef.h" 3 4
>typedef struct {
> long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
> long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
># 426 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stddef.h" 3 4
>} max_align_t;
>
>
>
>
>
>
> typedef decltype(nullptr) nullptr_t;
># 44 "../../gcc/system.h" 2
>
>
># 1 "/usr/include/stdio.h" 1 3 4
>
>
>
>
>extern "C" {
>
>
># 1 "/usr/include/features.h" 1 3 4
># 9 "/usr/include/stdio.h" 2 3 4
># 26 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
>
>
>
>
>
>typedef __builtin_va_list va_list;
>
>
>
>
>typedef __builtin_va_list __isoc_va_list;
># 101 "/usr/include/bits/alltypes.h" 3 4
>typedef unsigned long size_t;
># 116 "/usr/include/bits/alltypes.h" 3 4
>typedef long ssize_t;
># 203 "/usr/include/bits/alltypes.h" 3 4
>typedef long off_t;
># 356 "/usr/include/bits/alltypes.h" 3 4
>struct _IO_FILE { char __x; };
>
>
>
>
>typedef struct _IO_FILE FILE;
># 27 "/usr/include/stdio.h" 2 3 4
># 54 "/usr/include/stdio.h" 3 4
>typedef union _G_fpos64_t {
> char __opaque[16];
> long long __lldata;
> double __align;
>} fpos_t;
>
>extern FILE *const stdin;
>extern FILE *const stdout;
>extern FILE *const stderr;
>
>
>
>
>
>FILE *fopen(const char *__restrict, const char *__restrict);
>FILE *freopen(const char *__restrict, const char *__restrict, FILE *__restrict);
>int fclose(FILE *);
>
>int remove(const char *);
>int rename(const char *, const char *);
>
>int feof(FILE *);
>int ferror(FILE *);
>int fflush(FILE *);
>void clearerr(FILE *);
>
>int fseek(FILE *, long, int);
>long ftell(FILE *);
>void rewind(FILE *);
>
>int fgetpos(FILE *__restrict, fpos_t *__restrict);
>int fsetpos(FILE *, const fpos_t *);
>
>size_t fread(void *__restrict, size_t, size_t, FILE *__restrict);
>size_t fwrite(const void *__restrict, size_t, size_t, FILE *__restrict);
>
>int fgetc(FILE *);
>int getc(FILE *);
>int getchar(void);
>int ungetc(int, FILE *);
>
>int fputc(int, FILE *);
>int putc(int, FILE *);
>int putchar(int);
>
>char *fgets(char *__restrict, int, FILE *__restrict);
>
>char *gets(char *);
>
>
>int fputs(const char *__restrict, FILE *__restrict);
>int puts(const char *);
>
>int printf(const char *__restrict, ...);
>int fprintf(FILE *__restrict, const char *__restrict, ...);
>int sprintf(char *__restrict, const char *__restrict, ...);
>int snprintf(char *__restrict, size_t, const char *__restrict, ...);
>
>int vprintf(const char *__restrict, __isoc_va_list);
>int vfprintf(FILE *__restrict, const char *__restrict, __isoc_va_list);
>int vsprintf(char *__restrict, const char *__restrict, __isoc_va_list);
>int vsnprintf(char *__restrict, size_t, const char *__restrict, __isoc_va_list);
>
>int scanf(const char *__restrict, ...);
>int fscanf(FILE *__restrict, const char *__restrict, ...);
>int sscanf(const char *__restrict, const char *__restrict, ...);
>int vscanf(const char *__restrict, __isoc_va_list);
>int vfscanf(FILE *__restrict, const char *__restrict, __isoc_va_list);
>int vsscanf(const char *__restrict, const char *__restrict, __isoc_va_list);
>
>void perror(const char *);
>
>int setvbuf(FILE *__restrict, char *__restrict, int, size_t);
>void setbuf(FILE *__restrict, char *__restrict);
>
>char *tmpnam(char *);
>FILE *tmpfile(void);
>
>
>
>
>FILE *fmemopen(void *__restrict, size_t, const char *__restrict);
>FILE *open_memstream(char **, size_t *);
>FILE *fdopen(int, const char *);
>FILE *popen(const char *, const char *);
>int pclose(FILE *);
>int fileno(FILE *);
>int fseeko(FILE *, off_t, int);
>off_t ftello(FILE *);
>int dprintf(int, const char *__restrict, ...);
>int vdprintf(int, const char *__restrict, __isoc_va_list);
>void flockfile(FILE *);
>int ftrylockfile(FILE *);
>void funlockfile(FILE *);
>int getc_unlocked(FILE *);
>int getchar_unlocked(void);
>int putc_unlocked(int, FILE *);
>int putchar_unlocked(int);
>ssize_t getdelim(char **__restrict, size_t *__restrict, int, FILE *__restrict);
>ssize_t getline(char **__restrict, size_t *__restrict, FILE *__restrict);
>int renameat(int, const char *, int, const char *);
>char *ctermid(char *);
>
>
>
>
>
>
>
>char *tempnam(const char *, const char *);
>
>
>
>
>char *cuserid(char *);
>void setlinebuf(FILE *);
>void setbuffer(FILE *, char *, size_t);
>int fgetc_unlocked(FILE *);
>int fputc_unlocked(int, FILE *);
>int fflush_unlocked(FILE *);
>size_t fread_unlocked(void *, size_t, size_t, FILE *);
>size_t fwrite_unlocked(const void *, size_t, size_t, FILE *);
>void clearerr_unlocked(FILE *);
>int feof_unlocked(FILE *);
>int ferror_unlocked(FILE *);
>int fileno_unlocked(FILE *);
>int getw(FILE *);
>int putw(int, FILE *);
>char *fgetln(FILE *, size_t *);
>int asprintf(char **, const char *, ...);
>int vasprintf(char **, const char *, __isoc_va_list);
>
>
>
>char *fgets_unlocked(char *, int, FILE *);
>int fputs_unlocked(const char *, FILE *);
>
>typedef ssize_t (cookie_read_function_t)(void *, char *, size_t);
>typedef ssize_t (cookie_write_function_t)(void *, const char *, size_t);
>typedef int (cookie_seek_function_t)(void *, off_t *, int);
>typedef int (cookie_close_function_t)(void *);
>
>typedef struct _IO_cookie_io_functions_t {
> cookie_read_function_t *read;
> cookie_write_function_t *write;
> cookie_seek_function_t *seek;
> cookie_close_function_t *close;
>} cookie_io_functions_t;
>
>FILE *fopencookie(void *, const char *, cookie_io_functions_t);
># 219 "/usr/include/stdio.h" 3 4
>}
># 47 "../../gcc/system.h" 2
># 103 "../../gcc/system.h"
>
># 103 "../../gcc/system.h"
>extern "C" {
># 187 "../../gcc/system.h"
>}
># 209 "../../gcc/system.h"
># 1 "../../gcc/../include/safe-ctype.h" 1
># 57 "../../gcc/../include/safe-ctype.h"
>enum {
>
> _sch_isblank = 0x0001,
> _sch_iscntrl = 0x0002,
> _sch_isdigit = 0x0004,
> _sch_islower = 0x0008,
> _sch_isprint = 0x0010,
> _sch_ispunct = 0x0020,
> _sch_isspace = 0x0040,
> _sch_isupper = 0x0080,
> _sch_isxdigit = 0x0100,
>
>
> _sch_isidst = 0x0200,
> _sch_isvsp = 0x0400,
> _sch_isnvsp = 0x0800,
>
>
> _sch_isalpha = _sch_isupper|_sch_islower,
> _sch_isalnum = _sch_isalpha|_sch_isdigit,
> _sch_isidnum = _sch_isidst|_sch_isdigit,
> _sch_isgraph = _sch_isalnum|_sch_ispunct,
> _sch_iscppsp = _sch_isvsp|_sch_isnvsp,
> _sch_isbasic = _sch_isprint|_sch_iscppsp
>
>};
>
>
>extern const unsigned short _sch_istable[256];
># 110 "../../gcc/../include/safe-ctype.h"
>extern const unsigned char _sch_toupper[256];
>extern const unsigned char _sch_tolower[256];
># 122 "../../gcc/../include/safe-ctype.h"
># 1 "/usr/include/ctype.h" 1 3 4
>
>
>
>
>
># 5 "/usr/include/ctype.h" 3 4
>extern "C" {
>
>
>
>
>int isalnum(int);
>int isalpha(int);
>int isblank(int);
>int iscntrl(int);
>int isdigit(int);
>int isgraph(int);
>int islower(int);
>int isprint(int);
>int ispunct(int);
>int isspace(int);
>int isupper(int);
>int isxdigit(int);
>int tolower(int);
>int toupper(int);
># 46 "/usr/include/ctype.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 373 "/usr/include/bits/alltypes.h" 3 4
>typedef struct __locale_struct * locale_t;
># 47 "/usr/include/ctype.h" 2 3 4
>
>int isalnum_l(int, locale_t);
>int isalpha_l(int, locale_t);
>int isblank_l(int, locale_t);
>int iscntrl_l(int, locale_t);
>int isdigit_l(int, locale_t);
>int isgraph_l(int, locale_t);
>int islower_l(int, locale_t);
>int isprint_l(int, locale_t);
>int ispunct_l(int, locale_t);
>int isspace_l(int, locale_t);
>int isupper_l(int, locale_t);
>int isxdigit_l(int, locale_t);
>int tolower_l(int, locale_t);
>int toupper_l(int, locale_t);
>
>int isascii(int);
>int toascii(int);
>
>
>
>
>
>
>
>}
># 123 "../../gcc/../include/safe-ctype.h" 2
># 210 "../../gcc/system.h" 2
>
># 1 "/usr/include/sys/types.h" 1 3 4
>
>
>
>extern "C" {
># 57 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 55 "/usr/include/bits/alltypes.h" 3 4
>typedef long time_t;
>
>
>
>
>typedef long suseconds_t;
>
>
>
>
>
>typedef struct { union { int __i[14]; volatile int __vi[14]; unsigned long __s[7]; } __u; } pthread_attr_t;
>
>
>
>
>typedef struct { union { int __i[10]; volatile int __vi[10]; volatile void *volatile __p[5]; } __u; } pthread_mutex_t;
># 81 "/usr/include/bits/alltypes.h" 3 4
>typedef struct { union { int __i[12]; volatile int __vi[12]; void *__p[6]; } __u; } pthread_cond_t;
># 91 "/usr/include/bits/alltypes.h" 3 4
>typedef struct { union { int __i[14]; volatile int __vi[14]; void *__p[7]; } __u; } pthread_rwlock_t;
>
>
>
>
>typedef struct { union { int __i[8]; volatile int __vi[8]; void *__p[4]; } __u; } pthread_barrier_t;
># 131 "/usr/include/bits/alltypes.h" 3 4
>typedef long register_t;
>
>
>
>
>
>typedef signed char int8_t;
>
>
>
>
>typedef signed short int16_t;
>
>
>
>
>typedef signed int int32_t;
>
>
>
>
>typedef signed long int64_t;
># 182 "/usr/include/bits/alltypes.h" 3 4
>typedef unsigned long u_int64_t;
># 193 "/usr/include/bits/alltypes.h" 3 4
>typedef unsigned mode_t;
>
>
>
>
>typedef unsigned long nlink_t;
># 208 "/usr/include/bits/alltypes.h" 3 4
>typedef unsigned long ino_t;
>
>
>
>
>typedef unsigned long dev_t;
>
>
>
>
>typedef long blksize_t;
>
>
>
>
>typedef long blkcnt_t;
>
>
>
>
>typedef unsigned long fsblkcnt_t;
>
>
>
>
>typedef unsigned long fsfilcnt_t;
># 250 "/usr/include/bits/alltypes.h" 3 4
>typedef void * timer_t;
>
>
>
>
>typedef int clockid_t;
>
>
>
>
>typedef long clock_t;
># 276 "/usr/include/bits/alltypes.h" 3 4
>typedef int pid_t;
>
>
>
>
>typedef unsigned id_t;
>
>
>
>
>typedef unsigned uid_t;
>
>
>
>
>typedef unsigned gid_t;
>
>
>
>
>typedef int key_t;
>
>
>
>
>typedef unsigned useconds_t;
>
>
>
>
>
>
>typedef unsigned long pthread_t;
># 320 "/usr/include/bits/alltypes.h" 3 4
>typedef int pthread_once_t;
>
>
>
>
>typedef unsigned pthread_key_t;
>
>
>
>
>typedef int pthread_spinlock_t;
>
>
>
>
>typedef struct { unsigned __attr; } pthread_mutexattr_t;
>
>
>
>
>typedef struct { unsigned __attr; } pthread_condattr_t;
>
>
>
>
>typedef struct { unsigned __attr; } pthread_barrierattr_t;
>
>
>
>
>typedef struct { unsigned __attr[2]; } pthread_rwlockattr_t;
># 58 "/usr/include/sys/types.h" 2 3 4
>
>
>typedef unsigned char u_int8_t;
>typedef unsigned short u_int16_t;
>typedef unsigned u_int32_t;
>typedef char *caddr_t;
>typedef unsigned char u_char;
>typedef unsigned short u_short, ushort;
>typedef unsigned u_int, uint;
>typedef unsigned long u_long, ulong;
>typedef long long quad_t;
>typedef unsigned long long u_quad_t;
># 1 "/usr/include/endian.h" 1 3 4
># 23 "/usr/include/endian.h" 3 4
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stdint.h" 1 3 4
># 9 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stdint.h" 3 4
># 1 "/usr/include/stdint.h" 1 3 4
># 20 "/usr/include/stdint.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 106 "/usr/include/bits/alltypes.h" 3 4
>typedef unsigned long uintptr_t;
># 121 "/usr/include/bits/alltypes.h" 3 4
>typedef long intptr_t;
># 157 "/usr/include/bits/alltypes.h" 3 4
>typedef signed long intmax_t;
>
>
>
>
>typedef unsigned char uint8_t;
>
>
>
>
>typedef unsigned short uint16_t;
>
>
>
>
>typedef unsigned int uint32_t;
>
>
>
>
>typedef unsigned long uint64_t;
># 187 "/usr/include/bits/alltypes.h" 3 4
>typedef unsigned long uintmax_t;
># 21 "/usr/include/stdint.h" 2 3 4
>
>typedef int8_t int_fast8_t;
>typedef int64_t int_fast64_t;
>
>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_fast8_t;
>typedef uint64_t uint_fast64_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;
># 95 "/usr/include/stdint.h" 3 4
># 1 "/usr/include/bits/stdint.h" 1 3 4
>typedef int32_t int_fast16_t;
>typedef int32_t int_fast32_t;
>typedef uint32_t uint_fast16_t;
>typedef uint32_t uint_fast32_t;
># 96 "/usr/include/stdint.h" 2 3 4
># 10 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stdint.h" 2 3 4
># 24 "/usr/include/endian.h" 2 3 4
>
>static inline uint16_t __bswap16(uint16_t __x)
>{
> return __x<<8 | __x>>8;
>}
>
>static inline uint32_t __bswap32(uint32_t __x)
>{
> return __x>>24 | __x>>8&0xff00 | __x<<8&0xff0000 | __x<<24;
>}
>
>static inline uint64_t __bswap64(uint64_t __x)
>{
> return __bswap32(__x)+0ULL<<32 | __bswap32(__x>>32);
>}
># 71 "/usr/include/sys/types.h" 2 3 4
># 1 "/usr/include/sys/select.h" 1 3 4
>
>
>
>extern "C" {
># 16 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 265 "/usr/include/bits/alltypes.h" 3 4
>struct timeval { time_t tv_sec; suseconds_t tv_usec; };
>
>
>
>
>struct timespec { time_t tv_sec; long tv_nsec; };
># 379 "/usr/include/bits/alltypes.h" 3 4
>typedef struct __sigset_t { unsigned long __bits[128/sizeof(long)]; } sigset_t;
># 17 "/usr/include/sys/select.h" 2 3 4
>
>
>
>typedef unsigned long fd_mask;
>
>typedef struct {
> unsigned long fds_bits[1024 / 8 / sizeof(long)];
>} fd_set;
>
>
>
>
>
>
>int select (int, fd_set *__restrict, fd_set *__restrict, fd_set *__restrict, struct timeval *__restrict);
>int pselect (int, fd_set *__restrict, fd_set *__restrict, fd_set *__restrict, const struct timespec *__restrict, const sigset_t *__restrict);
>
>
>
>
>
>
>}
># 72 "/usr/include/sys/types.h" 2 3 4
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 73 "/usr/include/sys/types.h" 2 3 4
># 84 "/usr/include/sys/types.h" 3 4
>}
># 212 "../../gcc/system.h" 2
>
># 1 "/usr/include/errno.h" 1 3 4
>
>
>
>
>extern "C" {
>
>
>
>
># 1 "/usr/include/bits/errno.h" 1 3 4
># 11 "/usr/include/errno.h" 2 3 4
>
>
>__attribute__((const))
>
>int *__errno_location(void);
>
>
>
>extern char *program_invocation_short_name, *program_invocation_name;
>
>
>
>}
># 214 "../../gcc/system.h" 2
># 235 "../../gcc/system.h"
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstring" 1
># 39 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstring"
> 
># 40 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstring" 3
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/x86_64-alpine-linux-musl/bits/c++config.h" 1 3
># 258 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/x86_64-alpine-linux-musl/bits/c++config.h" 3
>namespace std
>{
> typedef long unsigned int size_t;
> typedef long int ptrdiff_t;
>
>
> typedef decltype(nullptr) nullptr_t;
>
>}
># 280 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/x86_64-alpine-linux-musl/bits/c++config.h" 3
>namespace std
>{
> inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
>}
>namespace __gnu_cxx
>{
> inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
>}
># 518 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/x86_64-alpine-linux-musl/bits/c++config.h" 3
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/x86_64-alpine-linux-musl/bits/os_defines.h" 1 3
># 519 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/x86_64-alpine-linux-musl/bits/c++config.h" 2 3
>
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/x86_64-alpine-linux-musl/bits/cpu_defines.h" 1 3
># 522 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/x86_64-alpine-linux-musl/bits/c++config.h" 2 3
># 42 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstring" 2 3
># 1 "/usr/include/string.h" 1 3 4
>
>
>
>
>extern "C" {
># 23 "/usr/include/string.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 24 "/usr/include/string.h" 2 3 4
>
>void *memcpy (void *__restrict, const void *__restrict, size_t);
>void *memmove (void *, const void *, size_t);
>void *memset (void *, int, size_t);
>int memcmp (const void *, const void *, size_t);
>void *memchr (const void *, int, size_t);
>
>char *strcpy (char *__restrict, const char *__restrict);
>char *strncpy (char *__restrict, const char *__restrict, size_t);
>
>char *strcat (char *__restrict, const char *__restrict);
>char *strncat (char *__restrict, const char *__restrict, size_t);
>
>int strcmp (const char *, const char *);
>int strncmp (const char *, const char *, size_t);
>
>int strcoll (const char *, const char *);
>size_t strxfrm (char *__restrict, const char *__restrict, size_t);
>
>char *strchr (const char *, int);
>char *strrchr (const char *, int);
>
>size_t strcspn (const char *, const char *);
>size_t strspn (const char *, const char *);
>char *strpbrk (const char *, const char *);
>char *strstr (const char *, const char *);
>char *strtok (char *__restrict, const char *__restrict);
>
>size_t strlen (const char *);
>
>char *strerror (int);
>
>
># 1 "/usr/include/strings.h" 1 3 4
>
>
>
>
>extern "C" {
>
>
>
>
>
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 12 "/usr/include/strings.h" 2 3 4
>
>
>
>
>int bcmp (const void *, const void *, size_t);
>void bcopy (const void *, void *, size_t);
>void bzero (void *, size_t);
>char *index (const char *, int);
>char *rindex (const char *, int);
>
>
>
>int ffs (int);
>int ffsl (long);
>int ffsll (long long);
>
>
>int strcasecmp (const char *, const char *);
>int strncasecmp (const char *, const char *, size_t);
>
>int strcasecmp_l (const char *, const char *, locale_t);
>int strncasecmp_l (const char *, const char *, size_t, locale_t);
>
>
>}
># 58 "/usr/include/string.h" 2 3 4
>
>
>
>
>
>char *strtok_r (char *__restrict, const char *__restrict, char **__restrict);
>int strerror_r (int, char *, size_t);
>char *stpcpy(char *__restrict, const char *__restrict);
>char *stpncpy(char *__restrict, const char *__restrict, size_t);
>size_t strnlen (const char *, size_t);
>char *strdup (const char *);
>char *strndup (const char *, size_t);
>char *strsignal(int);
>char *strerror_l (int, locale_t);
>int strcoll_l (const char *, const char *, locale_t);
>size_t strxfrm_l (char *__restrict, const char *__restrict, size_t, locale_t);
>
>
>
>
>void *memccpy (void *__restrict, const void *__restrict, int, size_t);
>
>
>
>char *strsep(char **, const char *);
>size_t strlcat (char *, const char *, size_t);
>size_t strlcpy (char *, const char *, size_t);
>void explicit_bzero (void *, size_t);
>
>
>
>
>int strverscmp (const char *, const char *);
>char *strchrnul(const char *, int);
>char *strcasestr(const char *, const char *);
>void *memmem(const void *, size_t, const void *, size_t);
>void *memrchr(const void *, int, size_t);
>void *mempcpy(void *, const void *, size_t);
>
>
>
>
>
>
>}
># 43 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstring" 2 3
># 71 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstring" 3
>extern "C++"
>{
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> using ::memchr;
> using ::memcmp;
> using ::memcpy;
> using ::memmove;
> using ::memset;
> using ::strcat;
> using ::strcmp;
> using ::strcoll;
> using ::strcpy;
> using ::strcspn;
> using ::strerror;
> using ::strlen;
> using ::strncat;
> using ::strncmp;
> using ::strncpy;
> using ::strspn;
> using ::strtok;
> using ::strxfrm;
> using ::strchr;
> using ::strpbrk;
> using ::strrchr;
> using ::strstr;
>
>
> inline void*
> memchr(void* __s, int __c, size_t __n)
> { return __builtin_memchr(__s, __c, __n); }
>
> inline char*
> strchr(char* __s, int __n)
> { return __builtin_strchr(__s, __n); }
>
> inline char*
> strpbrk(char* __s1, const char* __s2)
> { return __builtin_strpbrk(__s1, __s2); }
>
> inline char*
> strrchr(char* __s, int __n)
> { return __builtin_strrchr(__s, __n); }
>
> inline char*
> strstr(char* __s1, const char* __s2)
> { return __builtin_strstr(__s1, __s2); }
>
>
>
>}
>}
># 236 "../../gcc/system.h" 2
># 1 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/new" 1
># 38 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/new"
> 
># 39 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/new" 3
>
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/exception" 1 3
># 33 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/exception" 3
> 
># 34 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/exception" 3
>
>#pragma GCC visibility push(default)
>
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception.h" 1 3
># 34 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception.h" 3
> 
># 35 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception.h" 3
>
>#pragma GCC visibility push(default)
>
>
>
>extern "C++" {
>
>namespace std
>{
># 60 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception.h" 3
> class exception
> {
> public:
> exception() noexcept { }
> virtual ~exception() noexcept;
>
> exception(const exception&) = default;
> exception& operator=(const exception&) = default;
> exception(exception&&) = default;
> exception& operator=(exception&&) = default;
>
>
>
>
> virtual const char*
> what() const noexcept;
> };
>
>}
>
>}
>
>#pragma GCC visibility pop
># 39 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/exception" 2 3
>
>extern "C++" {
>
>namespace std
>{
>
>
>
>
>
>
> class bad_exception : public exception
> {
> public:
> bad_exception() noexcept { }
>
>
>
> virtual ~bad_exception() noexcept;
>
>
> virtual const char*
> what() const noexcept;
> };
>
>
> typedef void (*terminate_handler) ();
>
>
> typedef void (*unexpected_handler) ();
>
>
> terminate_handler set_terminate(terminate_handler) noexcept;
>
>
>
> terminate_handler get_terminate() noexcept;
>
>
>
>
> void terminate() noexcept __attribute__ ((__noreturn__));
>
>
> unexpected_handler set_unexpected(unexpected_handler) noexcept;
>
>
>
> unexpected_handler get_unexpected() noexcept;
>
>
>
>
> void unexpected() __attribute__ ((__noreturn__));
># 105 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/exception" 3
> 
> bool uncaught_exception() noexcept __attribute__ ((__pure__));
>
>
>
>
> int uncaught_exceptions() noexcept __attribute__ ((__pure__));
>
>
>
>}
>
>namespace __gnu_cxx
>{
>
># 137 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/exception" 3
> void __verbose_terminate_handler();
>
>
>}
>
>}
>
>#pragma GCC visibility pop
>
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception_ptr.h" 1 3
># 34 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception_ptr.h" 3
>#pragma GCC visibility push(default)
>
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception_defines.h" 1 3
># 38 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception_ptr.h" 2 3
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/cxxabi_init_exception.h" 1 3
># 34 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/cxxabi_init_exception.h" 3
> 
># 35 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/cxxabi_init_exception.h" 3
>
>#pragma GCC visibility push(default)
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stddef.h" 1 3 4
># 39 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/cxxabi_init_exception.h" 2 3
># 50 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/cxxabi_init_exception.h" 3
>namespace std
>{
> class type_info;
>}
>
>namespace __cxxabiv1
>{
> struct __cxa_refcounted_exception;
>
> extern "C"
> {
>
> void*
> __cxa_allocate_exception(size_t) noexcept;
>
> void
> __cxa_free_exception(void*) noexcept;
>
>
> __cxa_refcounted_exception*
> __cxa_init_primary_exception(void *object, std::type_info *tinfo,
> void ( *dest) (void *)) noexcept;
>
> }
>}
>
>
>
>#pragma GCC visibility pop
># 39 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception_ptr.h" 2 3
># 1 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/typeinfo" 1 3
># 32 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/typeinfo" 3
> 
># 33 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/typeinfo" 3
>
>
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/hash_bytes.h" 1 3
># 33 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/hash_bytes.h" 3
> 
># 34 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/hash_bytes.h" 3
>
>
>
>namespace std
>{
>
>
>
>
>
>
>
> size_t
> _Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
>
>
>
>
>
> size_t
> _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
>
>
>}
># 37 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/typeinfo" 2 3
>
>
>#pragma GCC visibility push(default)
>
>extern "C++" {
>
>namespace __cxxabiv1
>{
> class __class_type_info;
>}
># 80 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/typeinfo" 3
>namespace std
>{
>
>
>
>
>
>
> class type_info
> {
> public:
>
>
>
>
> virtual ~type_info();
>
>
>
> const char* name() const noexcept
> { return __name[0] == '*' ? __name + 1 : __name; }
># 115 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/typeinfo" 3
> bool before(const type_info& __arg) const noexcept
> { return (__name[0] == '*' && __arg.__name[0] == '*')
> ? __name < __arg.__name
> : __builtin_strcmp (__name, __arg.__name) < 0; }
>
> bool operator==(const type_info& __arg) const noexcept
> {
> return ((__name == __arg.__name)
> || (__name[0] != '*' &&
> __builtin_strcmp (__name, __arg.__name) == 0));
> }
># 138 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/typeinfo" 3
> bool operator!=(const type_info& __arg) const noexcept
> { return !operator==(__arg); }
>
>
>
> size_t hash_code() const noexcept
> {
>
> return _Hash_bytes(name(), __builtin_strlen(name()),
> static_cast<size_t>(0xc70f6907UL));
>
>
>
> }
>
>
>
> virtual bool __is_pointer_p() const;
>
>
> virtual bool __is_function_p() const;
>
>
>
>
>
>
>
> virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
> unsigned __outer) const;
>
>
> virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
> void **__obj_ptr) const;
>
> protected:
> const char *__name;
>
> explicit type_info(const char *__n): __name(__n) { }
>
> private:
>
> type_info& operator=(const type_info&);
> type_info(const type_info&);
> };
>
>
>
>
>
>
>
> class bad_cast : public exception
> {
> public:
> bad_cast() noexcept { }
>
>
>
> virtual ~bad_cast() noexcept;
>
>
> virtual const char* what() const noexcept;
> };
>
>
>
>
>
> class bad_typeid : public exception
> {
> public:
> bad_typeid () noexcept { }
>
>
>
> virtual ~bad_typeid() noexcept;
>
>
> virtual const char* what() const noexcept;
> };
>}
>
>}
>
>#pragma GCC visibility pop
># 40 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception_ptr.h" 2 3
># 1 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/new" 1 3
># 41 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception_ptr.h" 2 3
>
>extern "C++" {
>
>namespace std
>{
> class type_info;
>
>
>
>
>
>
> namespace __exception_ptr
> {
> class exception_ptr;
> }
>
> using __exception_ptr::exception_ptr;
>
>
>
>
>
> exception_ptr current_exception() noexcept;
>
> template<typename _Ex>
> exception_ptr make_exception_ptr(_Ex) noexcept;
>
>
> void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
>
> namespace __exception_ptr
> {
> using std::rethrow_exception;
>
>
>
>
>
> class exception_ptr
> {
> void* _M_exception_object;
>
> explicit exception_ptr(void* __e) noexcept;
>
> void _M_addref() noexcept;
> void _M_release() noexcept;
>
> void *_M_get() const noexcept __attribute__ ((__pure__));
>
> friend exception_ptr std::current_exception() noexcept;
> friend void std::rethrow_exception(exception_ptr);
> template<typename _Ex>
> friend exception_ptr std::make_exception_ptr(_Ex) noexcept;
>
> public:
> exception_ptr() noexcept;
>
> exception_ptr(const exception_ptr&) noexcept;
>
>
> exception_ptr(nullptr_t) noexcept
> : _M_exception_object(0)
> { }
>
> exception_ptr(exception_ptr&& __o) noexcept
> : _M_exception_object(__o._M_exception_object)
> { __o._M_exception_object = 0; }
># 118 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception_ptr.h" 3
> exception_ptr&
> operator=(const exception_ptr&) noexcept;
>
>
> exception_ptr&
> operator=(exception_ptr&& __o) noexcept
> {
> exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
> return *this;
> }
>
>
> ~exception_ptr() noexcept;
>
> void
> swap(exception_ptr&) noexcept;
># 145 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception_ptr.h" 3
> explicit operator bool() const
> { return _M_exception_object; }
>
>
> friend bool
> operator==(const exception_ptr&, const exception_ptr&)
> noexcept __attribute__ ((__pure__));
>
> const class std::type_info*
> __cxa_exception_type() const noexcept
> __attribute__ ((__pure__));
> };
>
>
>
> bool
> operator==(const exception_ptr&, const exception_ptr&)
> noexcept __attribute__ ((__pure__));
>
> bool
> operator!=(const exception_ptr&, const exception_ptr&)
> noexcept __attribute__ ((__pure__));
>
> inline void
> swap(exception_ptr& __lhs, exception_ptr& __rhs)
> { __lhs.swap(__rhs); }
>
>
>
>
> template<typename _Ex>
> inline void
> __dest_thunk(void* __x)
> { static_cast<_Ex*>(__x)->~_Ex(); }
>
>
> }
>
>
> template<typename _Ex>
> exception_ptr
> make_exception_ptr(_Ex __ex) noexcept
> {
># 213 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/exception_ptr.h" 3
> return exception_ptr();
>
> }
>
>
>}
>
>}
>
>#pragma GCC visibility pop
># 148 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/exception" 2 3
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/nested_exception.h" 1 3
># 33 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/nested_exception.h" 3
>#pragma GCC visibility push(default)
>
>
>
>
>
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/move.h" 1 3
># 38 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/move.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename _Tp>
> inline constexpr _Tp*
> __addressof(_Tp& __r) noexcept
> { return __builtin_addressof(__r); }
>
>
>
>
>}
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 1 3
># 32 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> 
># 33 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
>
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 56 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<typename _Tp, _Tp __v>
> struct integral_constant
> {
> static constexpr _Tp value = __v;
> typedef _Tp value_type;
> typedef integral_constant<_Tp, __v> type;
> constexpr operator value_type() const noexcept { return value; }
>
>
>
>
> constexpr value_type operator()() const noexcept { return value; }
>
> };
>
> template<typename _Tp, _Tp __v>
> constexpr _Tp integral_constant<_Tp, __v>::value;
>
>
> typedef integral_constant<bool, true> true_type;
>
>
> typedef integral_constant<bool, false> false_type;
>
> template<bool __v>
> using __bool_constant = integral_constant<bool, __v>;
># 91 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<bool, typename, typename>
> struct conditional;
>
> template <typename _Type>
> struct __type_identity
> { using type = _Type; };
>
> template<typename _Tp>
> using __type_identity_t = typename __type_identity<_Tp>::type;
>
> template<typename...>
> struct __or_;
>
> template<>
> struct __or_<>
> : public false_type
> { };
>
> template<typename _B1>
> struct __or_<_B1>
> : public _B1
> { };
>
> template<typename _B1, typename _B2>
> struct __or_<_B1, _B2>
> : public conditional<_B1::value, _B1, _B2>::type
> { };
>
> template<typename _B1, typename _B2, typename _B3, typename... _Bn>
> struct __or_<_B1, _B2, _B3, _Bn...>
> : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
> { };
>
> template<typename...>
> struct __and_;
>
> template<>
> struct __and_<>
> : public true_type
> { };
>
> template<typename _B1>
> struct __and_<_B1>
> : public _B1
> { };
>
> template<typename _B1, typename _B2>
> struct __and_<_B1, _B2>
> : public conditional<_B1::value, _B2, _B1>::type
> { };
>
> template<typename _B1, typename _B2, typename _B3, typename... _Bn>
> struct __and_<_B1, _B2, _B3, _Bn...>
> : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
> { };
>
> template<typename _Pp>
> struct __not_
> : public __bool_constant<!bool(_Pp::value)>
> { };
># 188 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<typename>
> struct is_reference;
> template<typename>
> struct is_function;
> template<typename>
> struct is_void;
> template<typename>
> struct __is_array_unknown_bounds;
>
>
>
>
> template <typename _Tp, size_t = sizeof(_Tp)>
> constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>)
> { return {}; }
>
> template <typename _TypeIdentity,
> typename _NestedType = typename _TypeIdentity::type>
> constexpr typename __or_<
> is_reference<_NestedType>,
> is_function<_NestedType>,
> is_void<_NestedType>,
> __is_array_unknown_bounds<_NestedType>
> >::type __is_complete_or_unbounded(_TypeIdentity)
> { return {}; }
>
>
>
>
>
>
> template<typename _Tp>
> struct __success_type
> { typedef _Tp type; };
>
> struct __failure_type
> { };
>
> template<typename>
> struct remove_cv;
>
>
> template<typename _Tp>
> using __remove_cv_t = typename remove_cv<_Tp>::type;
>
> template<typename>
> struct is_const;
>
>
>
> template<typename>
> struct __is_void_helper
> : public false_type { };
>
> template<>
> struct __is_void_helper<void>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_void
> : public __is_void_helper<__remove_cv_t<_Tp>>::type
> { };
>
> template<typename>
> struct __is_integral_helper
> : public false_type { };
>
> template<>
> struct __is_integral_helper<bool>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<char>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<signed char>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned char>
> : public true_type { };
>
>
> template<>
> struct __is_integral_helper<wchar_t>
> : public true_type { };
># 284 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<>
> struct __is_integral_helper<char16_t>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<char32_t>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<short>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned short>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<int>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned int>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<long>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned long>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<long long>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned long long>
> : public true_type { };
>
>
>
>
> template<>
> struct __is_integral_helper<__int128>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned __int128>
> : public true_type { };
># 364 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<typename _Tp>
> struct is_integral
> : public __is_integral_helper<__remove_cv_t<_Tp>>::type
> { };
>
> template<typename>
> struct __is_floating_point_helper
> : public false_type { };
>
> template<>
> struct __is_floating_point_helper<float>
> : public true_type { };
>
> template<>
> struct __is_floating_point_helper<double>
> : public true_type { };
>
> template<>
> struct __is_floating_point_helper<long double>
> : public true_type { };
>
>
> template<>
> struct __is_floating_point_helper<__float128>
> : public true_type { };
>
>
>
> template<typename _Tp>
> struct is_floating_point
> : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type
> { };
>
>
> template<typename>
> struct is_array
> : public false_type { };
>
> template<typename _Tp, std::size_t _Size>
> struct is_array<_Tp[_Size]>
> : public true_type { };
>
> template<typename _Tp>
> struct is_array<_Tp[]>
> : public true_type { };
>
> template<typename>
> struct __is_pointer_helper
> : public false_type { };
>
> template<typename _Tp>
> struct __is_pointer_helper<_Tp*>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_pointer
> : public __is_pointer_helper<__remove_cv_t<_Tp>>::type
> { };
>
>
> template<typename>
> struct is_lvalue_reference
> : public false_type { };
>
> template<typename _Tp>
> struct is_lvalue_reference<_Tp&>
> : public true_type { };
>
>
> template<typename>
> struct is_rvalue_reference
> : public false_type { };
>
> template<typename _Tp>
> struct is_rvalue_reference<_Tp&&>
> : public true_type { };
>
> template<typename>
> struct __is_member_object_pointer_helper
> : public false_type { };
>
> template<typename _Tp, typename _Cp>
> struct __is_member_object_pointer_helper<_Tp _Cp::*>
> : public __not_<is_function<_Tp>>::type { };
>
>
> template<typename _Tp>
> struct is_member_object_pointer
> : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type
> { };
>
> template<typename>
> struct __is_member_function_pointer_helper
> : public false_type { };
>
> template<typename _Tp, typename _Cp>
> struct __is_member_function_pointer_helper<_Tp _Cp::*>
> : public is_function<_Tp>::type { };
>
>
> template<typename _Tp>
> struct is_member_function_pointer
> : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_enum
> : public integral_constant<bool, __is_enum(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_union
> : public integral_constant<bool, __is_union(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_class
> : public integral_constant<bool, __is_class(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_function
> : public __bool_constant<!is_const<const _Tp>::value> { };
>
> template<typename _Tp>
> struct is_function<_Tp&>
> : public false_type { };
>
> template<typename _Tp>
> struct is_function<_Tp&&>
> : public false_type { };
>
>
>
> template<typename>
> struct __is_null_pointer_helper
> : public false_type { };
>
> template<>
> struct __is_null_pointer_helper<std::nullptr_t>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_null_pointer
> : public __is_null_pointer_helper<__remove_cv_t<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct __is_nullptr_t
> : public is_null_pointer<_Tp>
> { } __attribute__ ((__deprecated__));
>
>
>
>
> template<typename _Tp>
> struct is_reference
> : public __or_<is_lvalue_reference<_Tp>,
> is_rvalue_reference<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_arithmetic
> : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_fundamental
> : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
> is_null_pointer<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_object
> : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
> is_void<_Tp>>>::type
> { };
>
> template<typename>
> struct is_member_pointer;
>
>
> template<typename _Tp>
> struct is_scalar
> : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
> is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_compound
> : public __not_<is_fundamental<_Tp>>::type { };
>
> template<typename _Tp>
> struct __is_member_pointer_helper
> : public false_type { };
>
> template<typename _Tp, typename _Cp>
> struct __is_member_pointer_helper<_Tp _Cp::*>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_member_pointer
> : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type
> { };
>
> template<typename, typename>
> struct is_same;
>
> template<typename _Tp, typename... _Types>
> using __is_one_of = __or_<is_same<_Tp, _Types>...>;
>
>
> template<typename _Tp>
> using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>,
> signed char, signed short, signed int, signed long,
> signed long long
>
> , signed __int128
># 604 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> >;
>
>
> template<typename _Tp>
> using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
> unsigned char, unsigned short, unsigned int, unsigned long,
> unsigned long long
>
> , unsigned __int128
># 623 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> >;
>
>
> template<typename _Tp>
> using __is_standard_integer
> = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>;
>
>
> template<typename...> using __void_t = void;
>
>
>
> template<typename _Tp, typename = void>
> struct __is_referenceable
> : public false_type
> { };
>
> template<typename _Tp>
> struct __is_referenceable<_Tp, __void_t<_Tp&>>
> : public true_type
> { };
>
>
>
>
> template<typename>
> struct is_const
> : public false_type { };
>
> template<typename _Tp>
> struct is_const<_Tp const>
> : public true_type { };
>
>
> template<typename>
> struct is_volatile
> : public false_type { };
>
> template<typename _Tp>
> struct is_volatile<_Tp volatile>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_trivial
> : public integral_constant<bool, __is_trivial(_Tp)>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp>
> struct is_trivially_copyable
> : public integral_constant<bool, __is_trivially_copyable(_Tp)>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp>
> struct is_standard_layout
> : public integral_constant<bool, __is_standard_layout(_Tp)>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
>
> template<typename _Tp>
> struct
> 
> is_pod
> : public integral_constant<bool, __is_pod(_Tp)>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp>
> struct is_literal_type
> : public integral_constant<bool, __is_literal_type(_Tp)>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp>
> struct is_empty
> : public integral_constant<bool, __is_empty(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_polymorphic
> : public integral_constant<bool, __is_polymorphic(_Tp)>
> { };
>
>
>
>
> template<typename _Tp>
> struct is_final
> : public integral_constant<bool, __is_final(_Tp)>
> { };
>
>
>
> template<typename _Tp>
> struct is_abstract
> : public integral_constant<bool, __is_abstract(_Tp)>
> { };
>
> template<typename _Tp,
> bool = is_arithmetic<_Tp>::value>
> struct __is_signed_helper
> : public false_type { };
>
> template<typename _Tp>
> struct __is_signed_helper<_Tp, true>
> : public integral_constant<bool, _Tp(-1) < _Tp(0)>
> { };
>
>
> template<typename _Tp>
> struct is_signed
> : public __is_signed_helper<_Tp>::type
> { };
>
>
> template<typename _Tp>
> struct is_unsigned
> : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
> { };
># 770 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<typename _Tp, typename _Up = _Tp&&>
> _Up
> __declval(int);
>
> template<typename _Tp>
> _Tp
> __declval(long);
>
> template<typename _Tp>
> auto declval() noexcept -> decltype(__declval<_Tp>(0));
>
> template<typename, unsigned = 0>
> struct extent;
>
> template<typename>
> struct remove_all_extents;
>
> template<typename _Tp>
> struct __is_array_known_bounds
> : public integral_constant<bool, (extent<_Tp>::value > 0)>
> { };
>
> template<typename _Tp>
> struct __is_array_unknown_bounds
> : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
> { };
>
>
>
>
>
>
> struct __do_is_destructible_impl
> {
> template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_destructible_impl
> : public __do_is_destructible_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp,
> bool = __or_<is_void<_Tp>,
> __is_array_unknown_bounds<_Tp>,
> is_function<_Tp>>::value,
> bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
> struct __is_destructible_safe;
>
> template<typename _Tp>
> struct __is_destructible_safe<_Tp, false, false>
> : public __is_destructible_impl<typename
> remove_all_extents<_Tp>::type>::type
> { };
>
> template<typename _Tp>
> struct __is_destructible_safe<_Tp, true, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_destructible_safe<_Tp, false, true>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_destructible
> : public __is_destructible_safe<_Tp>::type
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
>
>
>
> struct __do_is_nt_destructible_impl
> {
> template<typename _Tp>
> static __bool_constant<noexcept(declval<_Tp&>().~_Tp())>
> __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_nt_destructible_impl
> : public __do_is_nt_destructible_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp,
> bool = __or_<is_void<_Tp>,
> __is_array_unknown_bounds<_Tp>,
> is_function<_Tp>>::value,
> bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
> struct __is_nt_destructible_safe;
>
> template<typename _Tp>
> struct __is_nt_destructible_safe<_Tp, false, false>
> : public __is_nt_destructible_impl<typename
> remove_all_extents<_Tp>::type>::type
> { };
>
> template<typename _Tp>
> struct __is_nt_destructible_safe<_Tp, true, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nt_destructible_safe<_Tp, false, true>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_nothrow_destructible
> : public __is_nt_destructible_safe<_Tp>::type
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<typename _Tp, typename... _Args>
> struct __is_constructible_impl
> : public __bool_constant<__is_constructible(_Tp, _Args...)>
> { };
>
>
> template<typename _Tp, typename... _Args>
> struct is_constructible
> : public __is_constructible_impl<_Tp, _Args...>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp>
> struct is_default_constructible
> : public __is_constructible_impl<_Tp>::type
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_copy_constructible_impl;
>
> template<typename _Tp>
> struct __is_copy_constructible_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_copy_constructible_impl<_Tp, true>
> : public __is_constructible_impl<_Tp, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_copy_constructible
> : public __is_copy_constructible_impl<_Tp>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_move_constructible_impl;
>
> template<typename _Tp>
> struct __is_move_constructible_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_move_constructible_impl<_Tp, true>
> : public __is_constructible_impl<_Tp, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_move_constructible
> : public __is_move_constructible_impl<_Tp>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<bool, typename _Tp, typename... _Args>
> struct __is_nt_constructible_impl
> : public false_type
> { };
>
> template<typename _Tp, typename... _Args>
> struct __is_nt_constructible_impl<true, _Tp, _Args...>
> : public __bool_constant<noexcept(_Tp(std::declval<_Args>()...))>
> { };
>
> template<typename _Tp, typename _Arg>
> struct __is_nt_constructible_impl<true, _Tp, _Arg>
> : public __bool_constant<noexcept(static_cast<_Tp>(std::declval<_Arg>()))>
> { };
>
> template<typename _Tp>
> struct __is_nt_constructible_impl<true, _Tp>
> : public __bool_constant<noexcept(_Tp())>
> { };
>
> template<typename _Tp, size_t _Num>
> struct __is_nt_constructible_impl<true, _Tp[_Num]>
> : public __bool_constant<noexcept(typename remove_all_extents<_Tp>::type())>
> { };
># 1001 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<typename _Tp, typename... _Args>
> using __is_nothrow_constructible_impl
> = __is_nt_constructible_impl<__is_constructible(_Tp, _Args...),
> _Tp, _Args...>;
>
>
> template<typename _Tp, typename... _Args>
> struct is_nothrow_constructible
> : public __is_nothrow_constructible_impl<_Tp, _Args...>::type
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp>
> struct is_nothrow_default_constructible
> : public __is_nothrow_constructible_impl<_Tp>::type
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_nothrow_copy_constructible_impl;
>
> template<typename _Tp>
> struct __is_nothrow_copy_constructible_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nothrow_copy_constructible_impl<_Tp, true>
> : public __is_nothrow_constructible_impl<_Tp, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_copy_constructible
> : public __is_nothrow_copy_constructible_impl<_Tp>::type
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_nothrow_move_constructible_impl;
>
> template<typename _Tp>
> struct __is_nothrow_move_constructible_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nothrow_move_constructible_impl<_Tp, true>
> : public __is_nothrow_constructible_impl<_Tp, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_move_constructible
> : public __is_nothrow_move_constructible_impl<_Tp>::type
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp, typename _Up>
> struct is_assignable
> : public __bool_constant<__is_assignable(_Tp, _Up)>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_copy_assignable_impl;
>
> template<typename _Tp>
> struct __is_copy_assignable_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_copy_assignable_impl<_Tp, true>
> : public __bool_constant<__is_assignable(_Tp&, const _Tp&)>
> { };
>
>
> template<typename _Tp>
> struct is_copy_assignable
> : public __is_copy_assignable_impl<_Tp>::type
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_move_assignable_impl;
>
> template<typename _Tp>
> struct __is_move_assignable_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_move_assignable_impl<_Tp, true>
> : public __bool_constant<__is_assignable(_Tp&, _Tp&&)>
> { };
>
>
> template<typename _Tp>
> struct is_move_assignable
> : public __is_move_assignable_impl<_Tp>::type
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<typename _Tp, typename _Up>
> struct __is_nt_assignable_impl
> : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
> { };
>
> template<typename _Tp, typename _Up>
> struct __is_nothrow_assignable_impl
> : public __and_<__bool_constant<__is_assignable(_Tp, _Up)>,
> __is_nt_assignable_impl<_Tp, _Up>>
> { };
>
>
> template<typename _Tp, typename _Up>
> struct is_nothrow_assignable
> : public __is_nothrow_assignable_impl<_Tp, _Up>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_nt_copy_assignable_impl;
>
> template<typename _Tp>
> struct __is_nt_copy_assignable_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nt_copy_assignable_impl<_Tp, true>
> : public __is_nothrow_assignable_impl<_Tp&, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_copy_assignable
> : public __is_nt_copy_assignable_impl<_Tp>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_nt_move_assignable_impl;
>
> template<typename _Tp>
> struct __is_nt_move_assignable_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nt_move_assignable_impl<_Tp, true>
> : public __is_nothrow_assignable_impl<_Tp&, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_move_assignable
> : public __is_nt_move_assignable_impl<_Tp>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp, typename... _Args>
> struct is_trivially_constructible
> : public __bool_constant<__is_trivially_constructible(_Tp, _Args...)>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp>
> struct is_trivially_default_constructible
> : public __bool_constant<__is_trivially_constructible(_Tp)>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> struct __do_is_implicitly_default_constructible_impl
> {
> template <typename _Tp>
> static void __helper(const _Tp&);
>
> template <typename _Tp>
> static true_type __test(const _Tp&,
> decltype(__helper<const _Tp&>({}))* = 0);
>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_implicitly_default_constructible_impl
> : public __do_is_implicitly_default_constructible_impl
> {
> typedef decltype(__test(declval<_Tp>())) type;
> };
>
> template<typename _Tp>
> struct __is_implicitly_default_constructible_safe
> : public __is_implicitly_default_constructible_impl<_Tp>::type
> { };
>
> template <typename _Tp>
> struct __is_implicitly_default_constructible
> : public __and_<__is_constructible_impl<_Tp>,
> __is_implicitly_default_constructible_safe<_Tp>>
> { };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_trivially_copy_constructible_impl;
>
> template<typename _Tp>
> struct __is_trivially_copy_constructible_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_trivially_copy_constructible_impl<_Tp, true>
> : public __and_<__is_copy_constructible_impl<_Tp>,
> integral_constant<bool,
> __is_trivially_constructible(_Tp, const _Tp&)>>
> { };
>
>
> template<typename _Tp>
> struct is_trivially_copy_constructible
> : public __is_trivially_copy_constructible_impl<_Tp>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_trivially_move_constructible_impl;
>
> template<typename _Tp>
> struct __is_trivially_move_constructible_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_trivially_move_constructible_impl<_Tp, true>
> : public __and_<__is_move_constructible_impl<_Tp>,
> integral_constant<bool,
> __is_trivially_constructible(_Tp, _Tp&&)>>
> { };
>
>
> template<typename _Tp>
> struct is_trivially_move_constructible
> : public __is_trivially_move_constructible_impl<_Tp>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp, typename _Up>
> struct is_trivially_assignable
> : public __bool_constant<__is_trivially_assignable(_Tp, _Up)>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_trivially_copy_assignable_impl;
>
> template<typename _Tp>
> struct __is_trivially_copy_assignable_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_trivially_copy_assignable_impl<_Tp, true>
> : public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)>
> { };
>
>
> template<typename _Tp>
> struct is_trivially_copy_assignable
> : public __is_trivially_copy_assignable_impl<_Tp>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_trivially_move_assignable_impl;
>
> template<typename _Tp>
> struct __is_trivially_move_assignable_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_trivially_move_assignable_impl<_Tp, true>
> : public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)>
> { };
>
>
> template<typename _Tp>
> struct is_trivially_move_assignable
> : public __is_trivially_move_assignable_impl<_Tp>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp>
> struct is_trivially_destructible
> : public __and_<__is_destructible_safe<_Tp>,
> __bool_constant<__has_trivial_destructor(_Tp)>>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
>
> template<typename _Tp>
> struct has_virtual_destructor
> : public integral_constant<bool, __has_virtual_destructor(_Tp)>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
>
>
>
> template<typename _Tp>
> struct alignment_of
> : public integral_constant<std::size_t, alignof(_Tp)>
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename>
> struct rank
> : public integral_constant<std::size_t, 0> { };
>
> template<typename _Tp, std::size_t _Size>
> struct rank<_Tp[_Size]>
> : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
>
> template<typename _Tp>
> struct rank<_Tp[]>
> : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
>
>
> template<typename, unsigned _Uint>
> struct extent
> : public integral_constant<std::size_t, 0> { };
>
> template<typename _Tp, unsigned _Uint, std::size_t _Size>
> struct extent<_Tp[_Size], _Uint>
> : public integral_constant<std::size_t,
> _Uint == 0 ? _Size : extent<_Tp,
> _Uint - 1>::value>
> { };
>
> template<typename _Tp, unsigned _Uint>
> struct extent<_Tp[], _Uint>
> : public integral_constant<std::size_t,
> _Uint == 0 ? 0 : extent<_Tp,
> _Uint - 1>::value>
> { };
>
>
>
>
>
> template<typename _Tp, typename _Up>
> struct is_same
>
> : public integral_constant<bool, __is_same_as(_Tp, _Up)>
>
>
>
> { };
># 1410 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<typename _Base, typename _Derived>
> struct is_base_of
> : public integral_constant<bool, __is_base_of(_Base, _Derived)>
> { };
>
> template<typename _From, typename _To,
> bool = __or_<is_void<_From>, is_function<_To>,
> is_array<_To>>::value>
> struct __is_convertible_helper
> {
> typedef typename is_void<_To>::type type;
> };
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
> template<typename _From, typename _To>
> class __is_convertible_helper<_From, _To, false>
> {
> template<typename _To1>
> static void __test_aux(_To1) noexcept;
>
> template<typename _From1, typename _To1,
> typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
> static true_type
> __test(int);
>
> template<typename, typename>
> static false_type
> __test(...);
>
> public:
> typedef decltype(__test<_From, _To>(0)) type;
> };
>#pragma GCC diagnostic pop
>
>
> template<typename _From, typename _To>
> struct is_convertible
> : public __is_convertible_helper<_From, _To>::type
> { };
>
>
> template<typename _ToElementType, typename _FromElementType>
> using __is_array_convertible
> = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;
>
> template<typename _From, typename _To,
> bool = __or_<is_void<_From>, is_function<_To>,
> is_array<_To>>::value>
> struct __is_nt_convertible_helper
> : is_void<_To>
> { };
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
> template<typename _From, typename _To>
> class __is_nt_convertible_helper<_From, _To, false>
> {
> template<typename _To1>
> static void __test_aux(_To1) noexcept;
>
> template<typename _From1, typename _To1>
> static
> __bool_constant<noexcept(__test_aux<_To1>(std::declval<_From1>()))>
> __test(int);
>
> template<typename, typename>
> static false_type
> __test(...);
>
> public:
> using type = decltype(__test<_From, _To>(0));
> };
>#pragma GCC diagnostic pop
>
>
> template<typename _From, typename _To>
> struct __is_nothrow_convertible
> : public __is_nt_convertible_helper<_From, _To>::type
> { };
># 1508 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<typename _Tp>
> struct remove_const
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_const<_Tp const>
> { typedef _Tp type; };
>
>
> template<typename _Tp>
> struct remove_volatile
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_volatile<_Tp volatile>
> { typedef _Tp type; };
>
>
> template<typename _Tp>
> struct remove_cv
> { using type = _Tp; };
>
> template<typename _Tp>
> struct remove_cv<const _Tp>
> { using type = _Tp; };
>
> template<typename _Tp>
> struct remove_cv<volatile _Tp>
> { using type = _Tp; };
>
> template<typename _Tp>
> struct remove_cv<const volatile _Tp>
> { using type = _Tp; };
>
>
> template<typename _Tp>
> struct add_const
> { typedef _Tp const type; };
>
>
> template<typename _Tp>
> struct add_volatile
> { typedef _Tp volatile type; };
>
>
> template<typename _Tp>
> struct add_cv
> {
> typedef typename
> add_const<typename add_volatile<_Tp>::type>::type type;
> };
>
>
>
>
>
>
> template<typename _Tp>
> using remove_const_t = typename remove_const<_Tp>::type;
>
>
> template<typename _Tp>
> using remove_volatile_t = typename remove_volatile<_Tp>::type;
>
>
> template<typename _Tp>
> using remove_cv_t = typename remove_cv<_Tp>::type;
>
>
> template<typename _Tp>
> using add_const_t = typename add_const<_Tp>::type;
>
>
> template<typename _Tp>
> using add_volatile_t = typename add_volatile<_Tp>::type;
>
>
> template<typename _Tp>
> using add_cv_t = typename add_cv<_Tp>::type;
>
>
>
>
>
> template<typename _Tp>
> struct remove_reference
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_reference<_Tp&>
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_reference<_Tp&&>
> { typedef _Tp type; };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __add_lvalue_reference_helper
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct __add_lvalue_reference_helper<_Tp, true>
> { typedef _Tp& type; };
>
>
> template<typename _Tp>
> struct add_lvalue_reference
> : public __add_lvalue_reference_helper<_Tp>
> { };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __add_rvalue_reference_helper
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct __add_rvalue_reference_helper<_Tp, true>
> { typedef _Tp&& type; };
>
>
> template<typename _Tp>
> struct add_rvalue_reference
> : public __add_rvalue_reference_helper<_Tp>
> { };
>
>
>
> template<typename _Tp>
> using remove_reference_t = typename remove_reference<_Tp>::type;
>
>
> template<typename _Tp>
> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
>
>
> template<typename _Tp>
> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
>
>
>
>
>
> template<typename _Unqualified, bool _IsConst, bool _IsVol>
> struct __cv_selector;
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, false, false>
> { typedef _Unqualified __type; };
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, false, true>
> { typedef volatile _Unqualified __type; };
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, true, false>
> { typedef const _Unqualified __type; };
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, true, true>
> { typedef const volatile _Unqualified __type; };
>
> template<typename _Qualified, typename _Unqualified,
> bool _IsConst = is_const<_Qualified>::value,
> bool _IsVol = is_volatile<_Qualified>::value>
> class __match_cv_qualifiers
> {
> typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
>
> public:
> typedef typename __match::__type __type;
> };
>
>
> template<typename _Tp>
> struct __make_unsigned
> { typedef _Tp __type; };
>
> template<>
> struct __make_unsigned<char>
> { typedef unsigned char __type; };
>
> template<>
> struct __make_unsigned<signed char>
> { typedef unsigned char __type; };
>
> template<>
> struct __make_unsigned<short>
> { typedef unsigned short __type; };
>
> template<>
> struct __make_unsigned<int>
> { typedef unsigned int __type; };
>
> template<>
> struct __make_unsigned<long>
> { typedef unsigned long __type; };
>
> template<>
> struct __make_unsigned<long long>
> { typedef unsigned long long __type; };
>
>
> template<>
> struct __make_unsigned<__int128>
> { typedef unsigned __int128 __type; };
># 1730 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<typename _Tp,
> bool _IsInt = is_integral<_Tp>::value,
> bool _IsEnum = is_enum<_Tp>::value>
> class __make_unsigned_selector;
>
> template<typename _Tp>
> class __make_unsigned_selector<_Tp, true, false>
> {
> using __unsigned_type
> = typename __make_unsigned<__remove_cv_t<_Tp>>::__type;
>
> public:
> using __type
> = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
> };
>
> class __make_unsigned_selector_base
> {
> protected:
> template<typename...> struct _List { };
>
> template<typename _Tp, typename... _Up>
> struct _List<_Tp, _Up...> : _List<_Up...>
> { static constexpr size_t __size = sizeof(_Tp); };
>
> template<size_t _Sz, typename _Tp, bool = (_Sz <= _Tp::__size)>
> struct __select;
>
> template<size_t _Sz, typename _Uint, typename... _UInts>
> struct __select<_Sz, _List<_Uint, _UInts...>, true>
> { using __type = _Uint; };
>
> template<size_t _Sz, typename _Uint, typename... _UInts>
> struct __select<_Sz, _List<_Uint, _UInts...>, false>
> : __select<_Sz, _List<_UInts...>>
> { };
> };
>
>
> template<typename _Tp>
> class __make_unsigned_selector<_Tp, false, true>
> : __make_unsigned_selector_base
> {
>
> using _UInts = _List<unsigned char, unsigned short, unsigned int,
> unsigned long, unsigned long long>;
>
> using __unsigned_type = typename __select<sizeof(_Tp), _UInts>::__type;
>
> public:
> using __type
> = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
> };
>
>
>
>
>
>
> template<>
> struct __make_unsigned<wchar_t>
> {
> using __type
> = typename __make_unsigned_selector<wchar_t, false, true>::__type;
> };
># 1806 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<>
> struct __make_unsigned<char16_t>
> {
> using __type
> = typename __make_unsigned_selector<char16_t, false, true>::__type;
> };
>
> template<>
> struct __make_unsigned<char32_t>
> {
> using __type
> = typename __make_unsigned_selector<char32_t, false, true>::__type;
> };
>
>
>
>
>
> template<typename _Tp>
> struct make_unsigned
> { typedef typename __make_unsigned_selector<_Tp>::__type type; };
>
>
> template<>
> struct make_unsigned<bool>;
>
>
>
> template<typename _Tp>
> struct __make_signed
> { typedef _Tp __type; };
>
> template<>
> struct __make_signed<char>
> { typedef signed char __type; };
>
> template<>
> struct __make_signed<unsigned char>
> { typedef signed char __type; };
>
> template<>
> struct __make_signed<unsigned short>
> { typedef signed short __type; };
>
> template<>
> struct __make_signed<unsigned int>
> { typedef signed int __type; };
>
> template<>
> struct __make_signed<unsigned long>
> { typedef signed long __type; };
>
> template<>
> struct __make_signed<unsigned long long>
> { typedef signed long long __type; };
>
>
> template<>
> struct __make_signed<unsigned __int128>
> { typedef __int128 __type; };
># 1884 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<typename _Tp,
> bool _IsInt = is_integral<_Tp>::value,
> bool _IsEnum = is_enum<_Tp>::value>
> class __make_signed_selector;
>
> template<typename _Tp>
> class __make_signed_selector<_Tp, true, false>
> {
> using __signed_type
> = typename __make_signed<__remove_cv_t<_Tp>>::__type;
>
> public:
> using __type
> = typename __match_cv_qualifiers<_Tp, __signed_type>::__type;
> };
>
>
> template<typename _Tp>
> class __make_signed_selector<_Tp, false, true>
> {
> typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
>
> public:
> typedef typename __make_signed_selector<__unsigned_type>::__type __type;
> };
>
>
>
>
>
>
> template<>
> struct __make_signed<wchar_t>
> {
> using __type
> = typename __make_signed_selector<wchar_t, false, true>::__type;
> };
># 1932 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<>
> struct __make_signed<char16_t>
> {
> using __type
> = typename __make_signed_selector<char16_t, false, true>::__type;
> };
>
> template<>
> struct __make_signed<char32_t>
> {
> using __type
> = typename __make_signed_selector<char32_t, false, true>::__type;
> };
>
>
>
>
>
> template<typename _Tp>
> struct make_signed
> { typedef typename __make_signed_selector<_Tp>::__type type; };
>
>
> template<>
> struct make_signed<bool>;
>
>
>
> template<typename _Tp>
> using make_signed_t = typename make_signed<_Tp>::type;
>
>
> template<typename _Tp>
> using make_unsigned_t = typename make_unsigned<_Tp>::type;
>
>
>
>
>
> template<typename _Tp>
> struct remove_extent
> { typedef _Tp type; };
>
> template<typename _Tp, std::size_t _Size>
> struct remove_extent<_Tp[_Size]>
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_extent<_Tp[]>
> { typedef _Tp type; };
>
>
> template<typename _Tp>
> struct remove_all_extents
> { typedef _Tp type; };
>
> template<typename _Tp, std::size_t _Size>
> struct remove_all_extents<_Tp[_Size]>
> { typedef typename remove_all_extents<_Tp>::type type; };
>
> template<typename _Tp>
> struct remove_all_extents<_Tp[]>
> { typedef typename remove_all_extents<_Tp>::type type; };
>
>
>
> template<typename _Tp>
> using remove_extent_t = typename remove_extent<_Tp>::type;
>
>
> template<typename _Tp>
> using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
>
>
>
>
> template<typename _Tp, typename>
> struct __remove_pointer_helper
> { typedef _Tp type; };
>
> template<typename _Tp, typename _Up>
> struct __remove_pointer_helper<_Tp, _Up*>
> { typedef _Up type; };
>
>
> template<typename _Tp>
> struct remove_pointer
> : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>>
> { };
>
>
> template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
> is_void<_Tp>>::value>
> struct __add_pointer_helper
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct __add_pointer_helper<_Tp, true>
> { typedef typename remove_reference<_Tp>::type* type; };
>
> template<typename _Tp>
> struct add_pointer
> : public __add_pointer_helper<_Tp>
> { };
>
>
>
> template<typename _Tp>
> using remove_pointer_t = typename remove_pointer<_Tp>::type;
>
>
> template<typename _Tp>
> using add_pointer_t = typename add_pointer<_Tp>::type;
>
>
> template<std::size_t _Len>
> struct __aligned_storage_msa
> {
> union __type
> {
> unsigned char __data[_Len];
> struct __attribute__((__aligned__)) { } __align;
> };
> };
># 2067 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<std::size_t _Len, std::size_t _Align =
> __alignof__(typename __aligned_storage_msa<_Len>::__type)>
> struct aligned_storage
> {
> union type
> {
> unsigned char __data[_Len];
> struct __attribute__((__aligned__((_Align)))) { } __align;
> };
> };
>
> template <typename... _Types>
> struct __strictest_alignment
> {
> static const size_t _S_alignment = 0;
> static const size_t _S_size = 0;
> };
>
> template <typename _Tp, typename... _Types>
> struct __strictest_alignment<_Tp, _Types...>
> {
> static const size_t _S_alignment =
> alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
> ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
> static const size_t _S_size =
> sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
> ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
> };
># 2106 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template <size_t _Len, typename... _Types>
> struct aligned_union
> {
> private:
> static_assert(sizeof...(_Types) != 0, "At least one type is required");
>
> using __strictest = __strictest_alignment<_Types...>;
> static const size_t _S_len = _Len > __strictest::_S_size
> ? _Len : __strictest::_S_size;
> public:
>
> static const size_t alignment_value = __strictest::_S_alignment;
>
> typedef typename aligned_storage<_S_len, alignment_value>::type type;
> };
>
> template <size_t _Len, typename... _Types>
> const size_t aligned_union<_Len, _Types...>::alignment_value;
>
>
>
> template<typename _Up,
> bool _IsArray = is_array<_Up>::value,
> bool _IsFunction = is_function<_Up>::value>
> struct __decay_selector;
>
>
> template<typename _Up>
> struct __decay_selector<_Up, false, false>
> { typedef __remove_cv_t<_Up> __type; };
>
> template<typename _Up>
> struct __decay_selector<_Up, true, false>
> { typedef typename remove_extent<_Up>::type* __type; };
>
> template<typename _Up>
> struct __decay_selector<_Up, false, true>
> { typedef typename add_pointer<_Up>::type __type; };
>
>
> template<typename _Tp>
> class decay
> {
> typedef typename remove_reference<_Tp>::type __remove_type;
>
> public:
> typedef typename __decay_selector<__remove_type>::__type type;
> };
>
>
> template<typename _Tp>
> using __decay_t = typename decay<_Tp>::type;
>
> template<typename _Tp>
> class reference_wrapper;
>
>
> template<typename _Tp>
> struct __strip_reference_wrapper
> {
> typedef _Tp __type;
> };
>
> template<typename _Tp>
> struct __strip_reference_wrapper<reference_wrapper<_Tp> >
> {
> typedef _Tp& __type;
> };
>
> template<typename _Tp>
> using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>;
>
>
>
>
> template<bool, typename _Tp = void>
> struct enable_if
> { };
>
>
> template<typename _Tp>
> struct enable_if<true, _Tp>
> { typedef _Tp type; };
>
>
> template<bool _Cond, typename _Tp = void>
> using __enable_if_t = typename enable_if<_Cond, _Tp>::type;
>
> template<typename... _Cond>
> using _Require = __enable_if_t<__and_<_Cond...>::value>;
>
>
>
> template<bool _Cond, typename _Iftrue, typename _Iffalse>
> struct conditional
> { typedef _Iftrue type; };
>
>
> template<typename _Iftrue, typename _Iffalse>
> struct conditional<false, _Iftrue, _Iffalse>
> { typedef _Iffalse type; };
>
>
> template<typename _Tp>
> using __remove_cvref_t
> = typename remove_cv<typename remove_reference<_Tp>::type>::type;
>
>
> template<typename... _Tp>
> struct common_type;
>
>
>
> struct __do_common_type_impl
> {
> template<typename _Tp, typename _Up>
> using __cond_t
> = decltype(true ? std::declval<_Tp>() : std::declval<_Up>());
>
>
>
> template<typename _Tp, typename _Up>
> static __success_type<__decay_t<__cond_t<_Tp, _Up>>>
> _S_test(int);
># 2239 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template<typename, typename>
> static __failure_type
> _S_test_2(...);
>
> template<typename _Tp, typename _Up>
> static decltype(_S_test_2<_Tp, _Up>(0))
> _S_test(...);
> };
>
>
> template<>
> struct common_type<>
> { };
>
>
> template<typename _Tp0>
> struct common_type<_Tp0>
> : public common_type<_Tp0, _Tp0>
> { };
>
>
> template<typename _Tp1, typename _Tp2,
> typename _Dp1 = __decay_t<_Tp1>, typename _Dp2 = __decay_t<_Tp2>>
> struct __common_type_impl
> {
>
>
> using type = common_type<_Dp1, _Dp2>;
> };
>
> template<typename _Tp1, typename _Tp2>
> struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2>
> : private __do_common_type_impl
> {
>
>
> using type = decltype(_S_test<_Tp1, _Tp2>(0));
> };
>
>
> template<typename _Tp1, typename _Tp2>
> struct common_type<_Tp1, _Tp2>
> : public __common_type_impl<_Tp1, _Tp2>::type
> { };
>
> template<typename...>
> struct __common_type_pack
> { };
>
> template<typename, typename, typename = void>
> struct __common_type_fold;
>
>
> template<typename _Tp1, typename _Tp2, typename... _Rp>
> struct common_type<_Tp1, _Tp2, _Rp...>
> : public __common_type_fold<common_type<_Tp1, _Tp2>,
> __common_type_pack<_Rp...>>
> { };
>
>
>
>
> template<typename _CTp, typename... _Rp>
> struct __common_type_fold<_CTp, __common_type_pack<_Rp...>,
> __void_t<typename _CTp::type>>
> : public common_type<typename _CTp::type, _Rp...>
> { };
>
>
> template<typename _CTp, typename _Rp>
> struct __common_type_fold<_CTp, _Rp, void>
> { };
>
> template<typename _Tp, bool = is_enum<_Tp>::value>
> struct __underlying_type_impl
> {
> using type = __underlying_type(_Tp);
> };
>
> template<typename _Tp>
> struct __underlying_type_impl<_Tp, false>
> { };
>
>
> template<typename _Tp>
> struct underlying_type
> : public __underlying_type_impl<_Tp>
> { };
>
> template<typename _Tp>
> struct __declval_protector
> {
> static const bool __stop = false;
> };
>
> template<typename _Tp>
> auto declval() noexcept -> decltype(__declval<_Tp>(0))
> {
> static_assert(__declval_protector<_Tp>::__stop,
> "declval() must not be used!");
> return __declval<_Tp>(0);
> }
>
>
> template<typename _Signature>
> class result_of;
>
>
>
>
>
> struct __invoke_memfun_ref { };
> struct __invoke_memfun_deref { };
> struct __invoke_memobj_ref { };
> struct __invoke_memobj_deref { };
> struct __invoke_other { };
>
>
> template<typename _Tp, typename _Tag>
> struct __result_of_success : __success_type<_Tp>
> { using __invoke_type = _Tag; };
>
>
> struct __result_of_memfun_ref_impl
> {
> template<typename _Fp, typename _Tp1, typename... _Args>
> static __result_of_success<decltype(
> (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
> ), __invoke_memfun_ref> _S_test(int);
>
> template<typename...>
> static __failure_type _S_test(...);
> };
>
> template<typename _MemPtr, typename _Arg, typename... _Args>
> struct __result_of_memfun_ref
> : private __result_of_memfun_ref_impl
> {
> typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
> };
>
>
> struct __result_of_memfun_deref_impl
> {
> template<typename _Fp, typename _Tp1, typename... _Args>
> static __result_of_success<decltype(
> ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
> ), __invoke_memfun_deref> _S_test(int);
>
> template<typename...>
> static __failure_type _S_test(...);
> };
>
> template<typename _MemPtr, typename _Arg, typename... _Args>
> struct __result_of_memfun_deref
> : private __result_of_memfun_deref_impl
> {
> typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
> };
>
>
> struct __result_of_memobj_ref_impl
> {
> template<typename _Fp, typename _Tp1>
> static __result_of_success<decltype(
> std::declval<_Tp1>().*std::declval<_Fp>()
> ), __invoke_memobj_ref> _S_test(int);
>
> template<typename, typename>
> static __failure_type _S_test(...);
> };
>
> template<typename _MemPtr, typename _Arg>
> struct __result_of_memobj_ref
> : private __result_of_memobj_ref_impl
> {
> typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
> };
>
>
> struct __result_of_memobj_deref_impl
> {
> template<typename _Fp, typename _Tp1>
> static __result_of_success<decltype(
> (*std::declval<_Tp1>()).*std::declval<_Fp>()
> ), __invoke_memobj_deref> _S_test(int);
>
> template<typename, typename>
> static __failure_type _S_test(...);
> };
>
> template<typename _MemPtr, typename _Arg>
> struct __result_of_memobj_deref
> : private __result_of_memobj_deref_impl
> {
> typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
> };
>
> template<typename _MemPtr, typename _Arg>
> struct __result_of_memobj;
>
> template<typename _Res, typename _Class, typename _Arg>
> struct __result_of_memobj<_Res _Class::*, _Arg>
> {
> typedef __remove_cvref_t<_Arg> _Argval;
> typedef _Res _Class::* _MemPtr;
> typedef typename conditional<__or_<is_same<_Argval, _Class>,
> is_base_of<_Class, _Argval>>::value,
> __result_of_memobj_ref<_MemPtr, _Arg>,
> __result_of_memobj_deref<_MemPtr, _Arg>
> >::type::type type;
> };
>
> template<typename _MemPtr, typename _Arg, typename... _Args>
> struct __result_of_memfun;
>
> template<typename _Res, typename _Class, typename _Arg, typename... _Args>
> struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
> {
> typedef typename remove_reference<_Arg>::type _Argval;
> typedef _Res _Class::* _MemPtr;
> typedef typename conditional<is_base_of<_Class, _Argval>::value,
> __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
> __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
> >::type::type type;
> };
>
>
>
>
>
>
> template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>>
> struct __inv_unwrap
> {
> using type = _Tp;
> };
>
> template<typename _Tp, typename _Up>
> struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
> {
> using type = _Up&;
> };
>
> template<bool, bool, typename _Functor, typename... _ArgTypes>
> struct __result_of_impl
> {
> typedef __failure_type type;
> };
>
> template<typename _MemPtr, typename _Arg>
> struct __result_of_impl<true, false, _MemPtr, _Arg>
> : public __result_of_memobj<__decay_t<_MemPtr>,
> typename __inv_unwrap<_Arg>::type>
> { };
>
> template<typename _MemPtr, typename _Arg, typename... _Args>
> struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
> : public __result_of_memfun<__decay_t<_MemPtr>,
> typename __inv_unwrap<_Arg>::type, _Args...>
> { };
>
>
> struct __result_of_other_impl
> {
> template<typename _Fn, typename... _Args>
> static __result_of_success<decltype(
> std::declval<_Fn>()(std::declval<_Args>()...)
> ), __invoke_other> _S_test(int);
>
> template<typename...>
> static __failure_type _S_test(...);
> };
>
> template<typename _Functor, typename... _ArgTypes>
> struct __result_of_impl<false, false, _Functor, _ArgTypes...>
> : private __result_of_other_impl
> {
> typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
> };
>
>
> template<typename _Functor, typename... _ArgTypes>
> struct __invoke_result
> : public __result_of_impl<
> is_member_object_pointer<
> typename remove_reference<_Functor>::type
> >::value,
> is_member_function_pointer<
> typename remove_reference<_Functor>::type
> >::value,
> _Functor, _ArgTypes...
> >::type
> { };
>
> template<typename _Functor, typename... _ArgTypes>
> struct result_of<_Functor(_ArgTypes...)>
> : public __invoke_result<_Functor, _ArgTypes...>
> { };
>
>
>
> template<size_t _Len, size_t _Align =
> __alignof__(typename __aligned_storage_msa<_Len>::__type)>
> using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
>
> template <size_t _Len, typename... _Types>
> using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
>
>
> template<typename _Tp>
> using decay_t = typename decay<_Tp>::type;
>
>
> template<bool _Cond, typename _Tp = void>
> using enable_if_t = typename enable_if<_Cond, _Tp>::type;
>
>
> template<bool _Cond, typename _Iftrue, typename _Iffalse>
> using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
>
>
> template<typename... _Tp>
> using common_type_t = typename common_type<_Tp...>::type;
>
>
> template<typename _Tp>
> using underlying_type_t = typename underlying_type<_Tp>::type;
>
>
> template<typename _Tp>
> using result_of_t = typename result_of<_Tp>::type;
>
>
>
>
>
> template<typename...> using void_t = void;
>
>
>
> template<typename _Default, typename _AlwaysVoid,
> template<typename...> class _Op, typename... _Args>
> struct __detector
> {
> using value_t = false_type;
> using type = _Default;
> };
>
>
> template<typename _Default, template<typename...> class _Op,
> typename... _Args>
> struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
> {
> using value_t = true_type;
> using type = _Op<_Args...>;
> };
>
>
> template<typename _Default, template<typename...> class _Op,
> typename... _Args>
> using __detected_or = __detector<_Default, void, _Op, _Args...>;
>
>
> template<typename _Default, template<typename...> class _Op,
> typename... _Args>
> using __detected_or_t
> = typename __detected_or<_Default, _Op, _Args...>::type;
># 2624 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
> template <typename _Tp>
> struct __is_swappable;
>
> template <typename _Tp>
> struct __is_nothrow_swappable;
>
> template<typename... _Elements>
> class tuple;
>
> template<typename>
> struct __is_tuple_like_impl : false_type
> { };
>
> template<typename... _Tps>
> struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
> { };
>
>
> template<typename _Tp>
> struct __is_tuple_like
> : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type
> { };
>
> template<typename _Tp>
> 
> inline
> _Require<__not_<__is_tuple_like<_Tp>>,
> is_move_constructible<_Tp>,
> is_move_assignable<_Tp>>
> swap(_Tp&, _Tp&)
> noexcept(__and_<is_nothrow_move_constructible<_Tp>,
> is_nothrow_move_assignable<_Tp>>::value);
>
> template<typename _Tp, size_t _Nm>
> 
> inline
> __enable_if_t<__is_swappable<_Tp>::value>
> swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
> noexcept(__is_nothrow_swappable<_Tp>::value);
>
> namespace __swappable_details {
> using std::swap;
>
> struct __do_is_swappable_impl
> {
> template<typename _Tp, typename
> = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> struct __do_is_nothrow_swappable_impl
> {
> template<typename _Tp>
> static __bool_constant<
> noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
> > __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> }
>
> template<typename _Tp>
> struct __is_swappable_impl
> : public __swappable_details::__do_is_swappable_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp>
> struct __is_nothrow_swappable_impl
> : public __swappable_details::__do_is_nothrow_swappable_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp>
> struct __is_swappable
> : public __is_swappable_impl<_Tp>::type
> { };
>
> template<typename _Tp>
> struct __is_nothrow_swappable
> : public __is_nothrow_swappable_impl<_Tp>::type
> { };
>
>
>
>
>
>
> template<typename _Tp>
> struct is_swappable
> : public __is_swappable_impl<_Tp>::type
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
> template<typename _Tp>
> struct is_nothrow_swappable
> : public __is_nothrow_swappable_impl<_Tp>::type
> {
> static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
> "template argument must be a complete class or an unbounded array");
> };
>
>
>
> template<typename _Tp>
> constexpr bool is_swappable_v =
> is_swappable<_Tp>::value;
>
>
> template<typename _Tp>
> constexpr bool is_nothrow_swappable_v =
> is_nothrow_swappable<_Tp>::value;
>
>
> namespace __swappable_with_details {
> using std::swap;
>
> struct __do_is_swappable_with_impl
> {
> template<typename _Tp, typename _Up, typename
> = decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
> typename
> = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
> static true_type __test(int);
>
> template<typename, typename>
> static false_type __test(...);
> };
>
> struct __do_is_nothrow_swappable_with_impl
> {
> template<typename _Tp, typename _Up>
> static __bool_constant<
> noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
> &&
> noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
> > __test(int);
>
> template<typename, typename>
> static false_type __test(...);
> };
>
> }
>
> template<typename _Tp, typename _Up>
> struct __is_swappable_with_impl
> : public __swappable_with_details::__do_is_swappable_with_impl
> {
> typedef decltype(__test<_Tp, _Up>(0)) type;
> };
>
>
> template<typename _Tp>
> struct __is_swappable_with_impl<_Tp&, _Tp&>
> : public __swappable_details::__do_is_swappable_impl
> {
> typedef decltype(__test<_Tp&>(0)) type;
> };
>
> template<typename _Tp, typename _Up>
> struct __is_nothrow_swappable_with_impl
> : public __swappable_with_details::__do_is_nothrow_swappable_with_impl
> {
> typedef decltype(__test<_Tp, _Up>(0)) type;
> };
>
>
> template<typename _Tp>
> struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
> : public __swappable_details::__do_is_nothrow_swappable_impl
> {
> typedef decltype(__test<_Tp&>(0)) type;
> };
>
>
> template<typename _Tp, typename _Up>
> struct is_swappable_with
> : public __is_swappable_with_impl<_Tp, _Up>::type
> { };
>
>
> template<typename _Tp, typename _Up>
> struct is_nothrow_swappable_with
> : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
> { };
>
>
>
> template<typename _Tp, typename _Up>
> constexpr bool is_swappable_with_v =
> is_swappable_with<_Tp, _Up>::value;
>
>
> template<typename _Tp, typename _Up>
> constexpr bool is_nothrow_swappable_with_v =
> is_nothrow_swappable_with<_Tp, _Up>::value;
>
>
>
>
>
>
>
> template<typename _Result, typename _Ret,
> bool = is_void<_Ret>::value, typename = void>
> struct __is_invocable_impl : false_type { };
>
>
> template<typename _Result, typename _Ret>
> struct __is_invocable_impl<_Result, _Ret,
> true,
> __void_t<typename _Result::type>>
> : true_type
> { };
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
>
> template<typename _Result, typename _Ret>
> struct __is_invocable_impl<_Result, _Ret,
> false,
> __void_t<typename _Result::type>>
> {
> private:
>
>
> static typename _Result::type _S_get();
>
> template<typename _Tp>
> static void _S_conv(_Tp);
>
>
> template<typename _Tp, typename = decltype(_S_conv<_Tp>(_S_get()))>
> static true_type
> _S_test(int);
>
> template<typename _Tp>
> static false_type
> _S_test(...);
>
> public:
> using type = decltype(_S_test<_Ret>(1));
> };
>#pragma GCC diagnostic pop
>
> template<typename _Fn, typename... _ArgTypes>
> struct __is_invocable
> : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
> { };
>
> template<typename _Fn, typename _Tp, typename... _Args>
> constexpr bool __call_is_nt(__invoke_memfun_ref)
> {
> using _Up = typename __inv_unwrap<_Tp>::type;
> return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
> std::declval<_Args>()...));
> }
>
> template<typename _Fn, typename _Tp, typename... _Args>
> constexpr bool __call_is_nt(__invoke_memfun_deref)
> {
> return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
> std::declval<_Args>()...));
> }
>
> template<typename _Fn, typename _Tp>
> constexpr bool __call_is_nt(__invoke_memobj_ref)
> {
> using _Up = typename __inv_unwrap<_Tp>::type;
> return noexcept(std::declval<_Up>().*std::declval<_Fn>());
> }
>
> template<typename _Fn, typename _Tp>
> constexpr bool __call_is_nt(__invoke_memobj_deref)
> {
> return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
> }
>
> template<typename _Fn, typename... _Args>
> constexpr bool __call_is_nt(__invoke_other)
> {
> return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
> }
>
> template<typename _Result, typename _Fn, typename... _Args>
> struct __call_is_nothrow
> : __bool_constant<
> std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
> >
> { };
>
> template<typename _Fn, typename... _Args>
> using __call_is_nothrow_
> = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
>
>
> template<typename _Fn, typename... _Args>
> struct __is_nothrow_invocable
> : __and_<__is_invocable<_Fn, _Args...>,
> __call_is_nothrow_<_Fn, _Args...>>::type
> { };
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
> struct __nonesuchbase {};
> struct __nonesuch : private __nonesuchbase {
> ~__nonesuch() = delete;
> __nonesuch(__nonesuch const&) = delete;
> void operator=(__nonesuch const&) = delete;
> };
>#pragma GCC diagnostic pop
># 3455 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/type_traits" 3
>
>}
># 58 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/move.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 74 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/move.h" 3
> template<typename _Tp>
> constexpr _Tp&&
> forward(typename std::remove_reference<_Tp>::type& __t) noexcept
> { return static_cast<_Tp&&>(__t); }
>
>
>
>
>
>
>
> template<typename _Tp>
> constexpr _Tp&&
> forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
> {
> static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
> " substituting _Tp is an lvalue reference type");
> return static_cast<_Tp&&>(__t);
> }
>
>
>
>
>
>
> template<typename _Tp>
> constexpr typename std::remove_reference<_Tp>::type&&
> move(_Tp&& __t) noexcept
> { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
>
>
> template<typename _Tp>
> struct __move_if_noexcept_cond
> : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
> is_copy_constructible<_Tp>>::type { };
># 118 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/move.h" 3
> template<typename _Tp>
> constexpr typename
> conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
> move_if_noexcept(_Tp& __x) noexcept
> { return std::move(__x); }
># 138 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/move.h" 3
> template<typename _Tp>
> inline _Tp*
> addressof(_Tp& __r) noexcept
> { return std::__addressof(__r); }
>
>
>
> template<typename _Tp>
> const _Tp* addressof(const _Tp&&) = delete;
>
>
> template <typename _Tp, typename _Up = _Tp>
> 
> inline _Tp
> __exchange(_Tp& __obj, _Up&& __new_val)
> {
> _Tp __old_val = std::move(__obj);
> __obj = std::forward<_Up>(__new_val);
> return __old_val;
> }
># 179 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/move.h" 3
> template<typename _Tp>
> 
> inline
>
> typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
> is_move_constructible<_Tp>,
> is_move_assignable<_Tp>>::value>::type
>
>
>
> swap(_Tp& __a, _Tp& __b)
> noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable<_Tp>>::value)
>
> {
>
>
>
>
> _Tp __tmp = std::move(__a);
> __a = std::move(__b);
> __b = std::move(__tmp);
> }
>
>
>
>
> template<typename _Tp, size_t _Nm>
> 
> inline
>
> typename enable_if<__is_swappable<_Tp>::value>::type
>
>
>
> swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
> noexcept(__is_nothrow_swappable<_Tp>::value)
> {
> for (size_t __n = 0; __n < _Nm; ++__n)
> swap(__a[__n], __b[__n]);
> }
>
>
>
>}
># 41 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/nested_exception.h" 2 3
>
>extern "C++" {
>
>namespace std
>{
>
>
>
>
>
>
> class nested_exception
> {
> exception_ptr _M_ptr;
>
> public:
> nested_exception() noexcept : _M_ptr(current_exception()) { }
>
> nested_exception(const nested_exception&) noexcept = default;
>
> nested_exception& operator=(const nested_exception&) noexcept = default;
>
> virtual ~nested_exception() noexcept;
>
> [[noreturn]]
> void
> rethrow_nested() const
> {
> if (_M_ptr)
> rethrow_exception(_M_ptr);
> std::terminate();
> }
>
> exception_ptr
> nested_ptr() const noexcept
> { return _M_ptr; }
> };
>
>
>
> template<typename _Except>
> struct _Nested_exception : public _Except, public nested_exception
> {
> explicit _Nested_exception(const _Except& __ex)
> : _Except(__ex)
> { }
>
> explicit _Nested_exception(_Except&& __ex)
> : _Except(static_cast<_Except&&>(__ex))
> { }
> };
>
>
>
>
> template<typename _Tp>
> [[noreturn]]
> inline void
> __throw_with_nested_impl(_Tp&& __t, true_type)
> {
> using _Up = typename remove_reference<_Tp>::type;
> throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
> }
>
> template<typename _Tp>
> [[noreturn]]
> inline void
> __throw_with_nested_impl(_Tp&& __t, false_type)
> { throw std::forward<_Tp>(__t); }
>
>
>
>
>
> template<typename _Tp>
> [[noreturn]]
> inline void
> throw_with_nested(_Tp&& __t)
> {
> using _Up = typename decay<_Tp>::type;
> using _CopyConstructible
> = __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
> static_assert(_CopyConstructible::value,
> "throw_with_nested argument must be CopyConstructible");
> using __nest = __and_<is_class<_Up>, __bool_constant<!__is_final(_Up)>,
> __not_<is_base_of<nested_exception, _Up>>>;
> std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{});
> }
>
>
>
>
> template<typename _Tp>
> using __rethrow_if_nested_cond = typename enable_if<
> __and_<is_polymorphic<_Tp>,
> __or_<__not_<is_base_of<nested_exception, _Tp>>,
> is_convertible<_Tp*, nested_exception*>>>::value
> >::type;
>
>
> template<typename _Ex>
> inline __rethrow_if_nested_cond<_Ex>
> __rethrow_if_nested_impl(const _Ex* __ptr)
> {
> if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
> __ne_ptr->rethrow_nested();
> }
>
>
> inline void
> __rethrow_if_nested_impl(const void*)
> { }
>
>
>
>
> template<typename _Ex>
> inline void
> rethrow_if_nested(const _Ex& __ex)
> { std::__rethrow_if_nested_impl(std::__addressof(__ex)); }
>
>
>}
>
>}
>
>
>
>#pragma GCC visibility pop
># 149 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/exception" 2 3
># 42 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/new" 2 3
>
>#pragma GCC visibility push(default)
>
>extern "C++" {
>
>namespace std
>{
>
>
>
>
>
>
> class bad_alloc : public exception
> {
> public:
> bad_alloc() throw() { }
>
>
> bad_alloc(const bad_alloc&) = default;
> bad_alloc& operator=(const bad_alloc&) = default;
>
>
>
>
> virtual ~bad_alloc() throw();
>
>
> virtual const char* what() const throw();
> };
>
>
> class bad_array_new_length : public bad_alloc
> {
> public:
> bad_array_new_length() throw() { }
>
>
>
> virtual ~bad_array_new_length() throw();
>
>
> virtual const char* what() const throw();
> };
>
>
>
>
>
>
> struct nothrow_t
> {
>
> explicit nothrow_t() = default;
>
> };
>
> extern const nothrow_t nothrow;
>
>
>
> typedef void (*new_handler)();
>
>
>
> new_handler set_new_handler(new_handler) throw();
>
>
>
> new_handler get_new_handler() noexcept;
>
>}
># 126 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/new" 3
> void* operator new(std::size_t)
> __attribute__((__externally_visible__));
> void* operator new[](std::size_t)
> __attribute__((__externally_visible__));
>void operator delete(void*) noexcept
> __attribute__((__externally_visible__));
>void operator delete[](void*) noexcept
> __attribute__((__externally_visible__));
>
>void operator delete(void*, std::size_t) noexcept
> __attribute__((__externally_visible__));
>void operator delete[](void*, std::size_t) noexcept
> __attribute__((__externally_visible__));
>
> void* operator new(std::size_t, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__, __malloc__));
> void* operator new[](std::size_t, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__, __malloc__));
>void operator delete(void*, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>void operator delete[](void*, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
># 174 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/new" 3
> inline void* operator new(std::size_t, void* __p) noexcept
>{ return __p; }
> inline void* operator new[](std::size_t, void* __p) noexcept
>{ return __p; }
>
>
>inline void operator delete (void*, void*) noexcept { }
>inline void operator delete[](void*, void*) noexcept { }
>
>}
># 230 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/new" 3
>#pragma GCC visibility pop
># 237 "../../gcc/system.h" 2
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/utility" 1
># 58 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/utility"
> 
># 59 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/utility" 3
># 69 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/utility" 3
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_relops.h" 1 3
># 67 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_relops.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> namespace rel_ops
> {
># 85 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator!=(const _Tp& __x, const _Tp& __y)
> { return !(__x == __y); }
># 98 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator>(const _Tp& __x, const _Tp& __y)
> { return __y < __x; }
># 111 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator<=(const _Tp& __x, const _Tp& __y)
> { return !(__y < __x); }
># 124 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator>=(const _Tp& __x, const _Tp& __y)
> { return !(__x < __y); }
> }
>
>
>}
># 70 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/utility" 2 3
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_pair.h" 1 3
># 69 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_pair.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 80 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_pair.h" 3
> struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
>
>
> constexpr piecewise_construct_t piecewise_construct =
> piecewise_construct_t();
>
>
>
>
> template<typename...>
> class tuple;
>
> template<std::size_t...>
> struct _Index_tuple;
>
>
>
>
>
>
> template <bool, typename _T1, typename _T2>
> struct _PCC
> {
> template <typename _U1, typename _U2>
> static constexpr bool _ConstructiblePair()
> {
> return __and_<is_constructible<_T1, const _U1&>,
> is_constructible<_T2, const _U2&>>::value;
> }
>
> template <typename _U1, typename _U2>
> static constexpr bool _ImplicitlyConvertiblePair()
> {
> return __and_<is_convertible<const _U1&, _T1>,
> is_convertible<const _U2&, _T2>>::value;
> }
>
> template <typename _U1, typename _U2>
> static constexpr bool _MoveConstructiblePair()
> {
> return __and_<is_constructible<_T1, _U1&&>,
> is_constructible<_T2, _U2&&>>::value;
> }
>
> template <typename _U1, typename _U2>
> static constexpr bool _ImplicitlyMoveConvertiblePair()
> {
> return __and_<is_convertible<_U1&&, _T1>,
> is_convertible<_U2&&, _T2>>::value;
> }
>
> template <bool __implicit, typename _U1, typename _U2>
> static constexpr bool _CopyMovePair()
> {
> using __do_converts = __and_<is_convertible<const _U1&, _T1>,
> is_convertible<_U2&&, _T2>>;
> using __converts = typename conditional<__implicit,
> __do_converts,
> __not_<__do_converts>>::type;
> return __and_<is_constructible<_T1, const _U1&>,
> is_constructible<_T2, _U2&&>,
> __converts
> >::value;
> }
>
> template <bool __implicit, typename _U1, typename _U2>
> static constexpr bool _MoveCopyPair()
> {
> using __do_converts = __and_<is_convertible<_U1&&, _T1>,
> is_convertible<const _U2&, _T2>>;
> using __converts = typename conditional<__implicit,
> __do_converts,
> __not_<__do_converts>>::type;
> return __and_<is_constructible<_T1, _U1&&>,
> is_constructible<_T2, const _U2&&>,
> __converts
> >::value;
> }
> };
>
> template <typename _T1, typename _T2>
> struct _PCC<false, _T1, _T2>
> {
> template <typename _U1, typename _U2>
> static constexpr bool _ConstructiblePair()
> {
> return false;
> }
>
> template <typename _U1, typename _U2>
> static constexpr bool _ImplicitlyConvertiblePair()
> {
> return false;
> }
>
> template <typename _U1, typename _U2>
> static constexpr bool _MoveConstructiblePair()
> {
> return false;
> }
>
> template <typename _U1, typename _U2>
> static constexpr bool _ImplicitlyMoveConvertiblePair()
> {
> return false;
> }
> };
>
>
> template<typename _U1, typename _U2> class __pair_base
> {
>
> template<typename _T1, typename _T2> friend struct pair;
> __pair_base() = default;
> ~__pair_base() = default;
> __pair_base(const __pair_base&) = default;
> __pair_base& operator=(const __pair_base&) = delete;
>
> };
># 210 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_pair.h" 3
> template<typename _T1, typename _T2>
> struct pair
> : private __pair_base<_T1, _T2>
> {
> typedef _T1 first_type;
> typedef _T2 second_type;
>
> _T1 first;
> _T2 second;
>
>
>
>
>
>
> template <typename _U1 = _T1,
> typename _U2 = _T2,
> typename enable_if<__and_<
> __is_implicitly_default_constructible<_U1>,
> __is_implicitly_default_constructible<_U2>>
> ::value, bool>::type = true>
>
> constexpr pair()
> : first(), second() { }
>
>
> template <typename _U1 = _T1,
> typename _U2 = _T2,
> typename enable_if<__and_<
> is_default_constructible<_U1>,
> is_default_constructible<_U2>,
> __not_<
> __and_<__is_implicitly_default_constructible<_U1>,
> __is_implicitly_default_constructible<_U2>>>>
> ::value, bool>::type = false>
> explicit constexpr pair()
> : first(), second() { }
># 256 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_pair.h" 3
> using _PCCP = _PCC<true, _T1, _T2>;
>
>
>
> template<typename _U1 = _T1, typename _U2=_T2, typename
> enable_if<_PCCP::template
> _ConstructiblePair<_U1, _U2>()
> && _PCCP::template
> _ImplicitlyConvertiblePair<_U1, _U2>(),
> bool>::type=true>
> constexpr pair(const _T1& __a, const _T2& __b)
> : first(__a), second(__b) { }
>
>
> template<typename _U1 = _T1, typename _U2=_T2, typename
> enable_if<_PCCP::template
> _ConstructiblePair<_U1, _U2>()
> && !_PCCP::template
> _ImplicitlyConvertiblePair<_U1, _U2>(),
> bool>::type=false>
> explicit constexpr pair(const _T1& __a, const _T2& __b)
> : first(__a), second(__b) { }
># 288 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_pair.h" 3
> template <typename _U1, typename _U2>
> using _PCCFP = _PCC<!is_same<_T1, _U1>::value
> || !is_same<_T2, _U2>::value,
> _T1, _T2>;
>
>
> template<typename _U1, typename _U2, typename
> enable_if<_PCCFP<_U1, _U2>::template
> _ConstructiblePair<_U1, _U2>()
> && _PCCFP<_U1, _U2>::template
> _ImplicitlyConvertiblePair<_U1, _U2>(),
> bool>::type=true>
> constexpr pair(const pair<_U1, _U2>& __p)
> : first(__p.first), second(__p.second) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_PCCFP<_U1, _U2>::template
> _ConstructiblePair<_U1, _U2>()
> && !_PCCFP<_U1, _U2>::template
> _ImplicitlyConvertiblePair<_U1, _U2>(),
> bool>::type=false>
> explicit constexpr pair(const pair<_U1, _U2>& __p)
> : first(__p.first), second(__p.second) { }
>
>
>
> constexpr pair(const pair&) = default;
> constexpr pair(pair&&) = default;
>
>
> template<typename _U1, typename
> enable_if<_PCCP::template
> _MoveCopyPair<true, _U1, _T2>(),
> bool>::type=true>
> constexpr pair(_U1&& __x, const _T2& __y)
> : first(std::forward<_U1>(__x)), second(__y) { }
>
> template<typename _U1, typename
> enable_if<_PCCP::template
> _MoveCopyPair<false, _U1, _T2>(),
> bool>::type=false>
> explicit constexpr pair(_U1&& __x, const _T2& __y)
> : first(std::forward<_U1>(__x)), second(__y) { }
>
> template<typename _U2, typename
> enable_if<_PCCP::template
> _CopyMovePair<true, _T1, _U2>(),
> bool>::type=true>
> constexpr pair(const _T1& __x, _U2&& __y)
> : first(__x), second(std::forward<_U2>(__y)) { }
>
> template<typename _U2, typename
> enable_if<_PCCP::template
> _CopyMovePair<false, _T1, _U2>(),
> bool>::type=false>
> explicit pair(const _T1& __x, _U2&& __y)
> : first(__x), second(std::forward<_U2>(__y)) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_PCCP::template
> _MoveConstructiblePair<_U1, _U2>()
> && _PCCP::template
> _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
> bool>::type=true>
> constexpr pair(_U1&& __x, _U2&& __y)
> : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_PCCP::template
> _MoveConstructiblePair<_U1, _U2>()
> && !_PCCP::template
> _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
> bool>::type=false>
> explicit constexpr pair(_U1&& __x, _U2&& __y)
> : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
>
>
> template<typename _U1, typename _U2, typename
> enable_if<_PCCFP<_U1, _U2>::template
> _MoveConstructiblePair<_U1, _U2>()
> && _PCCFP<_U1, _U2>::template
> _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
> bool>::type=true>
> constexpr pair(pair<_U1, _U2>&& __p)
> : first(std::forward<_U1>(__p.first)),
> second(std::forward<_U2>(__p.second)) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_PCCFP<_U1, _U2>::template
> _MoveConstructiblePair<_U1, _U2>()
> && !_PCCFP<_U1, _U2>::template
> _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
> bool>::type=false>
> explicit constexpr pair(pair<_U1, _U2>&& __p)
> : first(std::forward<_U1>(__p.first)),
> second(std::forward<_U2>(__p.second)) { }
>
> template<typename... _Args1, typename... _Args2>
>
> pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
>
> pair&
> operator=(typename conditional<
> __and_<is_copy_assignable<_T1>,
> is_copy_assignable<_T2>>::value,
> const pair&, const __nonesuch&>::type __p)
> {
> first = __p.first;
> second = __p.second;
> return *this;
> }
>
> pair&
> operator=(typename conditional<
> __and_<is_move_assignable<_T1>,
> is_move_assignable<_T2>>::value,
> pair&&, __nonesuch&&>::type __p)
> noexcept(__and_<is_nothrow_move_assignable<_T1>,
> is_nothrow_move_assignable<_T2>>::value)
> {
> first = std::forward<first_type>(__p.first);
> second = std::forward<second_type>(__p.second);
> return *this;
> }
>
> template<typename _U1, typename _U2>
>
> typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
> is_assignable<_T2&, const _U2&>>::value,
> pair&>::type
> operator=(const pair<_U1, _U2>& __p)
> {
> first = __p.first;
> second = __p.second;
> return *this;
> }
>
> template<typename _U1, typename _U2>
>
> typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
> is_assignable<_T2&, _U2&&>>::value,
> pair&>::type
> operator=(pair<_U1, _U2>&& __p)
> {
> first = std::forward<_U1>(__p.first);
> second = std::forward<_U2>(__p.second);
> return *this;
> }
>
>
> void
> swap(pair& __p)
> noexcept(__and_<__is_nothrow_swappable<_T1>,
> __is_nothrow_swappable<_T2>>::value)
> {
> using std::swap;
> swap(first, __p.first);
> swap(second, __p.second);
> }
>
> private:
> template<typename... _Args1, std::size_t... _Indexes1,
> typename... _Args2, std::size_t... _Indexes2>
>
> pair(tuple<_Args1...>&, tuple<_Args2...>&,
> _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
>
> };
># 464 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_pair.h" 3
> template<typename _T1, typename _T2>
> inline constexpr bool
> operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __x.first == __y.first && __x.second == __y.second; }
># 487 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_pair.h" 3
> template<typename _T1, typename _T2>
> inline constexpr bool
> operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __x.first < __y.first
> || (!(__y.first < __x.first) && __x.second < __y.second); }
>
>
> template<typename _T1, typename _T2>
> inline constexpr bool
> operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__x == __y); }
>
>
> template<typename _T1, typename _T2>
> inline constexpr bool
> operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __y < __x; }
>
>
> template<typename _T1, typename _T2>
> inline constexpr bool
> operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__y < __x); }
>
>
> template<typename _T1, typename _T2>
> inline constexpr bool
> operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__x < __y); }
># 524 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_pair.h" 3
> template<typename _T1, typename _T2>
> inline
>
>
> typename enable_if<__and_<__is_swappable<_T1>,
> __is_swappable<_T2>>::value>::type
>
>
>
> swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
>
> template<typename _T1, typename _T2>
> typename enable_if<!__and_<__is_swappable<_T1>,
> __is_swappable<_T2>>::value>::type
> swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
># 564 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_pair.h" 3
> template<typename _T1, typename _T2>
> constexpr pair<typename __decay_and_strip<_T1>::__type,
> typename __decay_and_strip<_T2>::__type>
> make_pair(_T1&& __x, _T2&& __y)
> {
> typedef typename __decay_and_strip<_T1>::__type __ds_type1;
> typedef typename __decay_and_strip<_T2>::__type __ds_type2;
> typedef pair<__ds_type1, __ds_type2> __pair_type;
> return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
> }
># 583 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/stl_pair.h" 3
>
>}
># 71 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/utility" 2 3
>
>
>
>
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/initializer_list" 1 3
># 33 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/initializer_list" 3
> 
># 34 "/home/iii/gcc/regtest-f8a59086423e/libstdc++-v3/libsupc++/initializer_list" 3
>
>
>
>
>
>#pragma GCC visibility push(default)
>
>
>
>namespace std
>{
>
> template<class _E>
> class initializer_list
> {
> public:
> typedef _E value_type;
> typedef const _E& reference;
> typedef const _E& const_reference;
> typedef size_t size_type;
> typedef const _E* iterator;
> typedef const _E* const_iterator;
>
> private:
> iterator _M_array;
> size_type _M_len;
>
>
> constexpr initializer_list(const_iterator __a, size_type __l)
> : _M_array(__a), _M_len(__l) { }
>
> public:
> constexpr initializer_list() noexcept
> : _M_array(0), _M_len(0) { }
>
>
> constexpr size_type
> size() const noexcept { return _M_len; }
>
>
> constexpr const_iterator
> begin() const noexcept { return _M_array; }
>
>
> constexpr const_iterator
> end() const noexcept { return begin() + size(); }
> };
>
>
>
>
>
>
>
> template<class _Tp>
> constexpr const _Tp*
> begin(initializer_list<_Tp> __ils) noexcept
> { return __ils.begin(); }
>
>
>
>
>
>
>
> template<class _Tp>
> constexpr const _Tp*
> end(initializer_list<_Tp> __ils) noexcept
> { return __ils.end(); }
>}
>
>#pragma GCC visibility pop
># 77 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/utility" 2 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _Tp>
> struct tuple_size;
>
>
>
>
>
> template<typename _Tp,
> typename _Up = typename remove_cv<_Tp>::type,
> typename = typename enable_if<is_same<_Tp, _Up>::value>::type,
> size_t = tuple_size<_Tp>::value>
> using __enable_if_has_tuple_size = _Tp;
>
> template<typename _Tp>
> struct tuple_size<const __enable_if_has_tuple_size<_Tp>>
> : public tuple_size<_Tp> { };
>
> template<typename _Tp>
> struct tuple_size<volatile __enable_if_has_tuple_size<_Tp>>
> : public tuple_size<_Tp> { };
>
> template<typename _Tp>
> struct tuple_size<const volatile __enable_if_has_tuple_size<_Tp>>
> : public tuple_size<_Tp> { };
>
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element;
>
>
> template<std::size_t __i, typename _Tp>
> using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element<__i, const _Tp>
> {
> typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
> };
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element<__i, volatile _Tp>
> {
> typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
> };
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element<__i, const volatile _Tp>
> {
> typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
> };
>
>
>
>
>
>
>
> template<std::size_t __i, typename _Tp>
> using tuple_element_t = typename tuple_element<__i, _Tp>::type;
>
>
>
>
>
> template<typename _T1, typename _T2>
> struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
> { };
>
>
> template<class _Tp1, class _Tp2>
> struct tuple_size<std::pair<_Tp1, _Tp2>>
> : public integral_constant<std::size_t, 2> { };
>
>
> template<class _Tp1, class _Tp2>
> struct tuple_element<0, std::pair<_Tp1, _Tp2>>
> { typedef _Tp1 type; };
>
>
> template<class _Tp1, class _Tp2>
> struct tuple_element<1, std::pair<_Tp1, _Tp2>>
> { typedef _Tp2 type; };
>
> template<std::size_t _Int>
> struct __pair_get;
>
> template<>
> struct __pair_get<0>
> {
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp1&
> __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.first; }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp1&&
> __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
> { return std::forward<_Tp1>(__pair.first); }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr const _Tp1&
> __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.first; }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr const _Tp1&&
> __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
> { return std::forward<const _Tp1>(__pair.first); }
> };
>
> template<>
> struct __pair_get<1>
> {
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp2&
> __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.second; }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp2&&
> __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
> { return std::forward<_Tp2>(__pair.second); }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr const _Tp2&
> __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.second; }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr const _Tp2&&
> __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
> { return std::forward<const _Tp2>(__pair.second); }
> };
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
> get(std::pair<_Tp1, _Tp2>& __in) noexcept
> { return __pair_get<_Int>::__get(__in); }
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
> get(std::pair<_Tp1, _Tp2>&& __in) noexcept
> { return __pair_get<_Int>::__move_get(std::move(__in)); }
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
> get(const std::pair<_Tp1, _Tp2>& __in) noexcept
> { return __pair_get<_Int>::__const_get(__in); }
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
> get(const std::pair<_Tp1, _Tp2>&& __in) noexcept
> { return __pair_get<_Int>::__const_move_get(std::move(__in)); }
>
>
>
>
>
> template <typename _Tp, typename _Up>
> constexpr _Tp&
> get(pair<_Tp, _Up>& __p) noexcept
> { return __p.first; }
>
> template <typename _Tp, typename _Up>
> constexpr const _Tp&
> get(const pair<_Tp, _Up>& __p) noexcept
> { return __p.first; }
>
> template <typename _Tp, typename _Up>
> constexpr _Tp&&
> get(pair<_Tp, _Up>&& __p) noexcept
> { return std::move(__p.first); }
>
> template <typename _Tp, typename _Up>
> constexpr const _Tp&&
> get(const pair<_Tp, _Up>&& __p) noexcept
> { return std::move(__p.first); }
>
> template <typename _Tp, typename _Up>
> constexpr _Tp&
> get(pair<_Up, _Tp>& __p) noexcept
> { return __p.second; }
>
> template <typename _Tp, typename _Up>
> constexpr const _Tp&
> get(const pair<_Up, _Tp>& __p) noexcept
> { return __p.second; }
>
> template <typename _Tp, typename _Up>
> constexpr _Tp&&
> get(pair<_Up, _Tp>&& __p) noexcept
> { return std::move(__p.second); }
>
> template <typename _Tp, typename _Up>
> constexpr const _Tp&&
> get(const pair<_Up, _Tp>&& __p) noexcept
> { return std::move(__p.second); }
>
>
>
>
> template <typename _Tp, typename _Up = _Tp>
> 
> inline _Tp
> exchange(_Tp& __obj, _Up&& __new_val)
> { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
>
>
>
>
>
> template<size_t... _Indexes> struct _Index_tuple { };
># 307 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/utility" 3
> template<size_t _Num>
> struct _Build_index_tuple
> {
>
>
>
>
>
>
> using __type = _Index_tuple<__integer_pack(_Num)...>;
>
> };
>
>
>
>
>
>
> template<typename _Tp, _Tp... _Idx>
> struct integer_sequence
> {
> typedef _Tp value_type;
> static constexpr size_t size() noexcept { return sizeof...(_Idx); }
> };
>
>
> template<typename _Tp, _Tp _Num>
> using make_integer_sequence
>
>
>
> = integer_sequence<_Tp, __integer_pack(_Num)...>;
>
>
>
>
>
> template<size_t... _Idx>
> using index_sequence = integer_sequence<size_t, _Idx...>;
>
>
> template<size_t _Num>
> using make_index_sequence = make_integer_sequence<size_t, _Num>;
>
>
> template<typename... _Types>
> using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
># 473 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/utility" 3
>
>}
># 238 "../../gcc/system.h" 2
># 258 "../../gcc/system.h"
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/stdlib.h" 1
># 36 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/stdlib.h"
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstdlib" 1
># 39 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstdlib"
> 
># 40 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstdlib" 3
># 75 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstdlib" 3
># 1 "/usr/include/stdlib.h" 1 3 4
>
>
>
>
>extern "C" {
># 19 "/usr/include/stdlib.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 20 "/usr/include/stdlib.h" 2 3 4
>
>int atoi (const char *);
>long atol (const char *);
>long long atoll (const char *);
>double atof (const char *);
>
>float strtof (const char *__restrict, char **__restrict);
>double strtod (const char *__restrict, char **__restrict);
>long double strtold (const char *__restrict, char **__restrict);
>
>long strtol (const char *__restrict, char **__restrict, int);
>unsigned long strtoul (const char *__restrict, char **__restrict, int);
>long long strtoll (const char *__restrict, char **__restrict, int);
>unsigned long long strtoull (const char *__restrict, char **__restrict, int);
>
>int rand (void);
>void srand (unsigned);
>
>void *malloc (size_t);
>void *calloc (size_t, size_t);
>void *realloc (void *, size_t);
>void free (void *);
>void *aligned_alloc(size_t, size_t);
>
>__attribute__((__noreturn__)) void abort (void);
>int atexit (void (*) (void));
>__attribute__((__noreturn__)) void exit (int);
>__attribute__((__noreturn__)) void _Exit (int);
>int at_quick_exit (void (*) (void));
>__attribute__((__noreturn__)) void quick_exit (int);
>
>char *getenv (const char *);
>
>int system (const char *);
>
>void *bsearch (const void *, const void *, size_t, size_t, int (*)(const void *, const void *));
>void qsort (void *, size_t, size_t, int (*)(const void *, const void *));
>
>int abs (int);
>long labs (long);
>long long llabs (long long);
>
>typedef struct { int quot, rem; } div_t;
>typedef struct { long quot, rem; } ldiv_t;
>typedef struct { long long quot, rem; } lldiv_t;
>
>div_t div (int, int);
>ldiv_t ldiv (long, long);
>lldiv_t lldiv (long long, long long);
>
>int mblen (const char *, size_t);
>int mbtowc (wchar_t *__restrict, const char *__restrict, size_t);
>int wctomb (char *, wchar_t);
>size_t mbstowcs (wchar_t *__restrict, const char *__restrict, size_t);
>size_t wcstombs (char *__restrict, const wchar_t *__restrict, size_t);
>
>
>
>
>size_t __ctype_get_mb_cur_max(void);
># 99 "/usr/include/stdlib.h" 3 4
>int posix_memalign (void **, size_t, size_t);
>int setenv (const char *, const char *, int);
>int unsetenv (const char *);
>int mkstemp (char *);
>int mkostemp (char *, int);
>char *mkdtemp (char *);
>int getsubopt (char **, char *const *, char **);
>int rand_r (unsigned *);
>
>
>
>
>
>
>char *realpath (const char *__restrict, char *__restrict);
>long int random (void);
>void srandom (unsigned int);
>char *initstate (unsigned int, char *, size_t);
>char *setstate (char *);
>int putenv (char *);
>int posix_openpt (int);
>int grantpt (int);
>int unlockpt (int);
>char *ptsname (int);
>char *l64a (long);
>long a64l (const char *);
>void setkey (const char *);
>double drand48 (void);
>double erand48 (unsigned short [3]);
>long int lrand48 (void);
>long int nrand48 (unsigned short [3]);
>long mrand48 (void);
>long jrand48 (unsigned short [3]);
>void srand48 (long);
>unsigned short *seed48 (unsigned short [3]);
>void lcong48 (unsigned short [7]);
>
>
>
># 1 "/usr/include/alloca.h" 1 3 4
>
>
>
>
>extern "C" {
>
>
>
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 10 "/usr/include/alloca.h" 2 3 4
>
>void *alloca(size_t);
>
>
>
>
>
>
>}
># 139 "/usr/include/stdlib.h" 2 3 4
>char *mktemp (char *);
>int mkstemps (char *, int);
>int mkostemps (char *, int, int);
>void *valloc (size_t);
>void *memalign(size_t, size_t);
>int getloadavg(double *, int);
>int clearenv(void);
>
>
>
>
>
>int ptsname_r(int, char *, size_t);
>char *ecvt(double, int, int *, int *);
>char *fcvt(double, int, int *, int *);
>char *gcvt(double, int, char *);
>struct __locale_struct;
>float strtof_l(const char *__restrict, char **__restrict, struct __locale_struct *);
>double strtod_l(const char *__restrict, char **__restrict, struct __locale_struct *);
>long double strtold_l(const char *__restrict, char **__restrict, struct __locale_struct *);
># 171 "/usr/include/stdlib.h" 3 4
>}
># 76 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstdlib" 2 3
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/std_abs.h" 1 3
># 33 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/std_abs.h" 3
> 
># 34 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/std_abs.h" 3
># 46 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/std_abs.h" 3
>extern "C++"
>{
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> using ::abs;
>
>
> inline long
> abs(long __i) { return __builtin_labs(__i); }
>
>
>
> inline long long
> abs(long long __x) { return __builtin_llabs (__x); }
># 70 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/std_abs.h" 3
> inline constexpr double
> abs(double __x)
> { return __builtin_fabs(__x); }
>
> inline constexpr float
> abs(float __x)
> { return __builtin_fabsf(__x); }
>
> inline constexpr long double
> abs(long double __x)
> { return __builtin_fabsl(__x); }
>
>
>
> inline constexpr __int128
> abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
># 101 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/bits/std_abs.h" 3
> inline constexpr
> __float128
> abs(__float128 __x)
> { return __x < 0 ? -__x : __x; }
>
>
>
>}
>}
># 78 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstdlib" 2 3
># 121 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstdlib" 3
>extern "C++"
>{
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> using ::div_t;
> using ::ldiv_t;
>
> using ::abort;
>
>
>
> using ::atexit;
>
>
> using ::at_quick_exit;
>
>
> using ::atof;
> using ::atoi;
> using ::atol;
> using ::bsearch;
> using ::calloc;
> using ::div;
> using ::exit;
> using ::free;
> using ::getenv;
> using ::labs;
> using ::ldiv;
> using ::malloc;
>
> using ::mblen;
> using ::mbstowcs;
> using ::mbtowc;
>
> using ::qsort;
>
>
> using ::quick_exit;
>
>
> using ::rand;
> using ::realloc;
> using ::srand;
> using ::strtod;
> using ::strtol;
> using ::strtoul;
> using ::system;
>
> using ::wcstombs;
> using ::wctomb;
>
>
>
> inline ldiv_t
> div(long __i, long __j) { return ldiv(__i, __j); }
>
>
>
>
>}
># 195 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstdlib" 3
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> using ::lldiv_t;
>
>
>
>
>
> using ::_Exit;
>
>
>
> using ::llabs;
>
> inline lldiv_t
> div(long long __n, long long __d)
> { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
>
> using ::lldiv;
># 227 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstdlib" 3
> using ::atoll;
> using ::strtoll;
> using ::strtoull;
>
> using ::strtof;
> using ::strtold;
>
>
>}
>
>namespace std
>{
>
> using ::__gnu_cxx::lldiv_t;
>
> using ::__gnu_cxx::_Exit;
>
> using ::__gnu_cxx::llabs;
> using ::__gnu_cxx::div;
> using ::__gnu_cxx::lldiv;
>
> using ::__gnu_cxx::atoll;
> using ::__gnu_cxx::strtof;
> using ::__gnu_cxx::strtoll;
> using ::__gnu_cxx::strtoull;
> using ::__gnu_cxx::strtold;
>}
>
>
>
>}
># 37 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/stdlib.h" 2
>
>
># 38 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/stdlib.h"
>using std::abort;
>using std::atexit;
>using std::exit;
>
>
> using std::at_quick_exit;
>
>
> using std::quick_exit;
>
>
>
>
>using std::div_t;
>using std::ldiv_t;
>
>using std::abs;
>using std::atof;
>using std::atoi;
>using std::atol;
>using std::bsearch;
>using std::calloc;
>using std::div;
>using std::free;
>using std::getenv;
>using std::labs;
>using std::ldiv;
>using std::malloc;
>
>using std::mblen;
>using std::mbstowcs;
>using std::mbtowc;
>
>using std::qsort;
>using std::rand;
>using std::realloc;
>using std::srand;
>using std::strtod;
>using std::strtol;
>using std::strtoul;
>using std::system;
>
>using std::wcstombs;
>using std::wctomb;
># 259 "../../gcc/system.h" 2
>
>
>
>
>
>
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstdlib" 1
># 39 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstdlib"
> 
># 40 "/home/iii/gcc/regtest-f8a59086423e/build/prev-x86_64-alpine-linux-musl/libstdc++-v3/include/cstdlib" 3
># 267 "../../gcc/system.h" 2
># 294 "../../gcc/system.h"
># 1 "/usr/include/unistd.h" 1 3 4
>
>
>
>
>
># 5 "/usr/include/unistd.h" 3 4
>extern "C" {
># 33 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 34 "/usr/include/unistd.h" 2 3 4
>
>int pipe(int [2]);
>int pipe2(int [2], int);
>int close(int);
>int posix_close(int, int);
>int dup(int);
>int dup2(int, int);
>int dup3(int, int, int);
>off_t lseek(int, off_t, int);
>int fsync(int);
>int fdatasync(int);
>
>ssize_t read(int, void *, size_t);
>ssize_t write(int, const void *, size_t);
>ssize_t pread(int, void *, size_t, off_t);
>ssize_t pwrite(int, const void *, size_t, off_t);
>
>int chown(const char *, uid_t, gid_t);
>int fchown(int, uid_t, gid_t);
>int lchown(const char *, uid_t, gid_t);
>int fchownat(int, const char *, uid_t, gid_t, int);
>
>int link(const char *, const char *);
>int linkat(int, const char *, int, const char *, int);
>int symlink(const char *, const char *);
>int symlinkat(const char *, int, const char *);
>ssize_t readlink(const char *__restrict, char *__restrict, size_t);
>ssize_t readlinkat(int, const char *__restrict, char *__restrict, size_t);
>int unlink(const char *);
>int unlinkat(int, const char *, int);
>int rmdir(const char *);
>int truncate(const char *, off_t);
>int ftruncate(int, off_t);
>
>
>
>
>
>
>int access(const char *, int);
>int faccessat(int, const char *, int, int);
>
>int chdir(const char *);
>int fchdir(int);
>char *getcwd(char *, size_t);
>
>unsigned alarm(unsigned);
>unsigned sleep(unsigned);
>int pause(void);
>
>pid_t fork(void);
>int execve(const char *, char *const [], char *const []);
>int execv(const char *, char *const []);
>int execle(const char *, const char *, ...);
>int execl(const char *, const char *, ...);
>int execvp(const char *, char *const []);
>int execlp(const char *, const char *, ...);
>int fexecve(int, char *const [], char *const []);
>__attribute__((__noreturn__)) void _exit(int);
>
>pid_t getpid(void);
>pid_t getppid(void);
>pid_t getpgrp(void);
>pid_t getpgid(pid_t);
>int setpgid(pid_t, pid_t);
>pid_t setsid(void);
>pid_t getsid(pid_t);
>char *ttyname(int);
>int ttyname_r(int, char *, size_t);
>int isatty(int);
>pid_t tcgetpgrp(int);
>int tcsetpgrp(int, pid_t);
>
>uid_t getuid(void);
>uid_t geteuid(void);
>gid_t getgid(void);
>gid_t getegid(void);
>int getgroups(int, gid_t []);
>int setuid(uid_t);
>int seteuid(uid_t);
>int setgid(gid_t);
>int setegid(gid_t);
>
>char *getlogin(void);
>int getlogin_r(char *, size_t);
>int gethostname(char *, size_t);
>char *ctermid(char *);
>
>int getopt(int, char * const [], const char *);
>extern char *optarg;
>extern int optind, opterr, optopt;
>
>long pathconf(const char *, int);
>long fpathconf(int, int);
>long sysconf(int);
>size_t confstr(int, char *, size_t);
>
>
>
>
>
>
>int setreuid(uid_t, uid_t);
>int setregid(gid_t, gid_t);
>int lockf(int, int, off_t);
>long gethostid(void);
>int nice(int);
>void sync(void);
>pid_t setpgrp(void);
>char *crypt(const char *, const char *);
>void encrypt(char *, int);
>void swab(const void *__restrict, void *__restrict, ssize_t);
>
>
>
>
>int usleep(unsigned);
>unsigned ualarm(unsigned, unsigned);
>
>
>
>
>
>
>int brk(void *);
>void *sbrk(intptr_t);
>pid_t vfork(void);
>int vhangup(void);
>int chroot(const char *);
>int getpagesize(void);
>int getdtablesize(void);
>int sethostname(const char *, size_t);
>int getdomainname(char *, size_t);
>int setdomainname(const char *, size_t);
>int setgroups(size_t, const gid_t *);
>char *getpass(const char *);
>int daemon(int, int);
>void setusershell(void);
>void endusershell(void);
>char *getusershell(void);
>int acct(const char *);
>long syscall(long, ...);
>int execvpe(const char *, char *const [], char *const []);
>int issetugid(void);
>int getentropy(void *, size_t);
>
>
>
>extern char **environ;
>int setresuid(uid_t, uid_t, uid_t);
>int setresgid(gid_t, gid_t, gid_t);
>int getresuid(uid_t *, uid_t *, uid_t *);
>int getresgid(gid_t *, gid_t *, gid_t *);
>char *get_current_dir_name(void);
>int syncfs(int);
>int euidaccess(const char *, int);
>int eaccess(const char *, int);
># 252 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/posix.h" 1 3 4
># 253 "/usr/include/unistd.h" 2 3 4
># 464 "/usr/include/unistd.h" 3 4
>}
># 295 "../../gcc/system.h" 2
>
>
>
># 1 "/usr/include/sys/param.h" 1 3 4
># 31 "/usr/include/sys/param.h" 3 4
># 1 "/usr/include/sys/resource.h" 1 3 4
>
>
>
>
>extern "C" {
>
>
>
># 1 "/usr/include/sys/time.h" 1 3 4
>
>
>
>extern "C" {
>
>
>
>
>
>
>int gettimeofday (struct timeval *__restrict, void *__restrict);
>
>
>
>
>
>struct itimerval {
> struct timeval it_interval;
> struct timeval it_value;
>};
>
>int getitimer (int, struct itimerval *);
>int setitimer (int, const struct itimerval *__restrict, struct itimerval *__restrict);
>int utimes (const char *, const struct timeval [2]);
>
>
>struct timezone {
> int tz_minuteswest;
> int tz_dsttime;
>};
>int futimes(int, const struct timeval [2]);
>int futimesat(int, const char *, const struct timeval [2]);
>int lutimes(const char *, const struct timeval [2]);
>int settimeofday(const struct timeval *, const struct timezone *);
>int adjtime (const struct timeval *, struct timeval *);
># 60 "/usr/include/sys/time.h" 3 4
>}
># 10 "/usr/include/sys/resource.h" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 18 "/usr/include/sys/resource.h" 2 3 4
># 1 "/usr/include/bits/resource.h" 1 3 4
># 19 "/usr/include/sys/resource.h" 2 3 4
>
>typedef unsigned long long rlim_t;
>
>struct rlimit {
> rlim_t rlim_cur;
> rlim_t rlim_max;
>};
>
>struct rusage {
> struct timeval ru_utime;
> struct timeval ru_stime;
>
> long ru_maxrss;
> long ru_ixrss;
> long ru_idrss;
> long ru_isrss;
> long ru_minflt;
> long ru_majflt;
> long ru_nswap;
> long ru_inblock;
> long ru_oublock;
> long ru_msgsnd;
> long ru_msgrcv;
> long ru_nsignals;
> long ru_nvcsw;
> long ru_nivcsw;
>
> long __reserved[16];
>};
>
>int getrlimit (int, struct rlimit *);
>int setrlimit (int, const struct rlimit *);
>int getrusage (int, struct rusage *);
>
>int getpriority (int, id_t);
>int setpriority (int, id_t, int);
>
>
>int prlimit(pid_t, int, const struct rlimit *, struct rlimit *);
># 108 "/usr/include/sys/resource.h" 3 4
>}
># 32 "/usr/include/sys/param.h" 2 3 4
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include-fixed/limits.h" 1 3 4
># 34 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include-fixed/limits.h" 3 4
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include-fixed/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include-fixed/limits.h" 1 3 4
># 195 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include-fixed/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/bits/limits.h" 1 3 4
># 9 "/usr/include/limits.h" 2 3 4
># 196 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include-fixed/limits.h" 2 3 4
># 8 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include-fixed/syslimits.h" 2 3 4
># 35 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include-fixed/limits.h" 2 3 4
># 34 "/usr/include/sys/param.h" 2 3 4
># 299 "../../gcc/system.h" 2
>
>
>
>
>
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include-fixed/limits.h" 1 3 4
># 306 "../../gcc/system.h" 2
># 337 "../../gcc/system.h"
># 1 "/usr/include/time.h" 1 3 4
>
>
>
>
>extern "C" {
># 31 "/usr/include/time.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 32 "/usr/include/time.h" 2 3 4
>
>
>
>
>
>
>struct tm {
> int tm_sec;
> int tm_min;
> int tm_hour;
> int tm_mday;
> int tm_mon;
> int tm_year;
> int tm_wday;
> int tm_yday;
> int tm_isdst;
> long tm_gmtoff;
> const char *tm_zone;
>};
>
>clock_t clock (void);
>time_t time (time_t *);
>double difftime (time_t, time_t);
>time_t mktime (struct tm *);
>size_t strftime (char *__restrict, size_t, const char *__restrict, const struct tm *__restrict);
>struct tm *gmtime (const time_t *);
>struct tm *localtime (const time_t *);
>char *asctime (const struct tm *);
>char *ctime (const time_t *);
>int timespec_get(struct timespec *, int);
># 71 "/usr/include/time.h" 3 4
>size_t strftime_l (char * __restrict, size_t, const char * __restrict, const struct tm * __restrict, locale_t);
>
>struct tm *gmtime_r (const time_t *__restrict, struct tm *__restrict);
>struct tm *localtime_r (const time_t *__restrict, struct tm *__restrict);
>char *asctime_r (const struct tm *__restrict, char *__restrict);
>char *ctime_r (const time_t *, char *);
>
>void tzset (void);
>
>struct itimerspec {
> struct timespec it_interval;
> struct timespec it_value;
>};
># 100 "/usr/include/time.h" 3 4
>int nanosleep (const struct timespec *, struct timespec *);
>int clock_getres (clockid_t, struct timespec *);
>int clock_gettime (clockid_t, struct timespec *);
>int clock_settime (clockid_t, const struct timespec *);
>int clock_nanosleep (clockid_t, int, const struct timespec *, struct timespec *);
>int clock_getcpuclockid (pid_t, clockid_t *);
>
>struct sigevent;
>int timer_create (clockid_t, struct sigevent *__restrict, timer_t *__restrict);
>int timer_delete (timer_t);
>int timer_settime (timer_t, int, const struct itimerspec *__restrict, struct itimerspec *__restrict);
>int timer_gettime (timer_t, struct itimerspec *);
>int timer_getoverrun (timer_t);
>
>extern char *tzname[2];
>
>
>
>
>
>char *strptime (const char *__restrict, const char *__restrict, struct tm *__restrict);
>extern int daylight;
>extern long timezone;
>extern int getdate_err;
>struct tm *getdate (const char *);
>
>
>
>
>int stime(const time_t *);
>time_t timegm(struct tm *);
>
>
>
>}
># 338 "../../gcc/system.h" 2
># 349 "../../gcc/system.h"
># 1 "/usr/include/fcntl.h" 1 3 4
>
>
>
>
>extern "C" {
># 20 "/usr/include/fcntl.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 385 "/usr/include/bits/alltypes.h" 3 4
>struct iovec { void *iov_base; size_t iov_len; };
># 21 "/usr/include/fcntl.h" 2 3 4
>
># 1 "/usr/include/bits/fcntl.h" 1 3 4
># 23 "/usr/include/fcntl.h" 2 3 4
>
>struct flock {
> short l_type;
> short l_whence;
> off_t l_start;
> off_t l_len;
> pid_t l_pid;
>};
>
>int creat(const char *, mode_t);
>int fcntl(int, int, ...);
>int open(const char *, int, ...);
>int openat(int, const char *, int, ...);
>int posix_fadvise(int, off_t, off_t, int);
>int posix_fallocate(int, off_t, off_t);
># 152 "/usr/include/fcntl.h" 3 4
>int lockf(int, int, off_t);
>
>
>
>
>
>
>
>struct file_handle {
> unsigned handle_bytes;
> int handle_type;
> unsigned char f_handle[];
>};
>struct f_owner_ex {
> int type;
> pid_t pid;
>};
># 179 "/usr/include/fcntl.h" 3 4
>int fallocate(int, int, off_t, off_t);
>
>int name_to_handle_at(int, const char *, struct file_handle *, int *, int);
>int open_by_handle_at(int, struct file_handle *, int);
>ssize_t readahead(int, off_t, size_t);
>int sync_file_range(int, off_t, off_t, unsigned);
>ssize_t vmsplice(int, const struct iovec *, size_t, unsigned);
>ssize_t splice(int, off_t *, int, off_t *, size_t, unsigned);
>ssize_t tee(int, int, size_t, unsigned);
># 206 "/usr/include/fcntl.h" 3 4
>}
># 350 "../../gcc/system.h" 2
># 396 "../../gcc/system.h"
># 1 "/usr/include/sys/wait.h" 1 3 4
>
>
>
>extern "C" {
>
>
>
>
>
>
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 12 "/usr/include/sys/wait.h" 2 3 4
>
>typedef enum {
> P_ALL = 0,
> P_PID = 1,
> P_PGID = 2
>} idtype_t;
>
>pid_t wait (int *);
>pid_t waitpid (pid_t, int *, int );
>
>
>
>
># 1 "/usr/include/signal.h" 1 3 4
>
>
>
>
>extern "C" {
># 28 "/usr/include/signal.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 29 "/usr/include/signal.h" 2 3 4
># 44 "/usr/include/signal.h" 3 4
>typedef struct sigaltstack stack_t;
>
>
>
># 1 "/usr/include/bits/signal.h" 1 3 4
># 10 "/usr/include/bits/signal.h" 3 4
>enum { REG_R8 = 0 };
>
>enum { REG_R9 = 1 };
>
>enum { REG_R10 = 2 };
>
>enum { REG_R11 = 3 };
>
>enum { REG_R12 = 4 };
>
>enum { REG_R13 = 5 };
>
>enum { REG_R14 = 6 };
>
>enum { REG_R15 = 7 };
>
>enum { REG_RDI = 8 };
>
>enum { REG_RSI = 9 };
>
>enum { REG_RBP = 10 };
>
>enum { REG_RBX = 11 };
>
>enum { REG_RDX = 12 };
>
>enum { REG_RAX = 13 };
>
>enum { REG_RCX = 14 };
>
>enum { REG_RSP = 15 };
>
>enum { REG_RIP = 16 };
>
>enum { REG_EFL = 17 };
>
>enum { REG_CSGSFS = 18 };
>
>enum { REG_ERR = 19 };
>
>enum { REG_TRAPNO = 20 };
>
>enum { REG_OLDMASK = 21 };
>
>enum { REG_CR2 = 22 };
>
>
>
>
>typedef long long greg_t, gregset_t[23];
>typedef struct _fpstate {
> unsigned short cwd, swd, ftw, fop;
> unsigned long long rip, rdp;
> unsigned mxcsr, mxcr_mask;
> struct {
> unsigned short significand[4], exponent, padding[3];
> } _st[8];
> struct {
> unsigned element[4];
> } _xmm[16];
> unsigned padding[24];
>} *fpregset_t;
>struct sigcontext {
> unsigned long r8, r9, r10, r11, r12, r13, r14, r15;
> unsigned long rdi, rsi, rbp, rbx, rdx, rax, rcx, rsp, rip, eflags;
> unsigned short cs, gs, fs, __pad0;
> unsigned long err, trapno, oldmask, cr2;
> struct _fpstate *fpstate;
> unsigned long __reserved1[8];
>};
>typedef struct {
> gregset_t gregs;
> fpregset_t fpregs;
> unsigned long long __reserved1[8];
>} mcontext_t;
>
>
>
>
>
>
>struct sigaltstack {
> void *ss_sp;
> int ss_flags;
> size_t ss_size;
>};
>
>typedef struct ucontext {
> unsigned long uc_flags;
> struct ucontext *uc_link;
> stack_t uc_stack;
> mcontext_t uc_mcontext;
> sigset_t uc_sigmask;
> unsigned long __fpregs_mem[64];
>} ucontext_t;
># 49 "/usr/include/signal.h" 2 3 4
># 92 "/usr/include/signal.h" 3 4
>union sigval {
> int sival_int;
> void *sival_ptr;
>};
>
>typedef struct {
>
>
>
> int si_signo, si_errno, si_code;
>
> union {
> char __pad[128 - 2*sizeof(int) - sizeof(long)];
> struct {
> union {
> struct {
> pid_t si_pid;
> uid_t si_uid;
> } __piduid;
> struct {
> int si_timerid;
> int si_overrun;
> } __timer;
> } __first;
> union {
> union sigval si_value;
> struct {
> int si_status;
> clock_t si_utime, si_stime;
> } __sigchld;
> } __second;
> } __si_common;
> struct {
> void *si_addr;
> short si_addr_lsb;
> union {
> struct {
> void *si_lower;
> void *si_upper;
> } __addr_bnd;
> unsigned si_pkey;
> } __first;
> } __sigfault;
> struct {
> long si_band;
> int si_fd;
> } __sigpoll;
> struct {
> void *si_call_addr;
> int si_syscall;
> unsigned si_arch;
> } __sigsys;
> } __si_fields;
>} siginfo_t;
># 167 "/usr/include/signal.h" 3 4
>struct sigaction {
> union {
> void (*sa_handler)(int);
> void (*sa_sigaction)(int, siginfo_t *, void *);
> } __sa_handler;
> sigset_t sa_mask;
> int sa_flags;
> void (*sa_restorer)(void);
>};
>
>
>
>struct sigevent {
> union sigval sigev_value;
> int sigev_signo;
> int sigev_notify;
> void (*sigev_notify_function)(union sigval);
> pthread_attr_t *sigev_notify_attributes;
> char __pad[56-3*sizeof(long)];
>};
>
>
>
>
>
>int __libc_current_sigrtmin(void);
>int __libc_current_sigrtmax(void);
>
>
>
>
>int kill(pid_t, int);
>
>int sigemptyset(sigset_t *);
>int sigfillset(sigset_t *);
>int sigaddset(sigset_t *, int);
>int sigdelset(sigset_t *, int);
>int sigismember(const sigset_t *, int);
>
>int sigprocmask(int, const sigset_t *__restrict, sigset_t *__restrict);
>int sigsuspend(const sigset_t *);
>int sigaction(int, const struct sigaction *__restrict, struct sigaction *__restrict);
>int sigpending(sigset_t *);
>int sigwait(const sigset_t *__restrict, int *__restrict);
>int sigwaitinfo(const sigset_t *__restrict, siginfo_t *__restrict);
>int sigtimedwait(const sigset_t *__restrict, siginfo_t *__restrict, const struct timespec *__restrict);
>int sigqueue(pid_t, int, union sigval);
>
>int pthread_sigmask(int, const sigset_t *__restrict, sigset_t *__restrict);
>int pthread_kill(pthread_t, int);
>
>void psiginfo(const siginfo_t *, const char *);
>void psignal(int, const char *);
>
>
>
>
>int killpg(pid_t, int);
>int sigaltstack(const stack_t *__restrict, stack_t *__restrict);
>int sighold(int);
>int sigignore(int);
>int siginterrupt(int, int);
>int sigpause(int);
>int sigrelse(int);
>void (*sigset(int, void (*)(int)))(int);
># 251 "/usr/include/signal.h" 3 4
>typedef void (*sig_t)(int);
>
>
>
>typedef void (*sighandler_t)(int);
>void (*bsd_signal(int, void (*)(int)))(int);
>int sigisemptyset(const sigset_t *);
>int sigorset (sigset_t *, const sigset_t *, const sigset_t *);
>int sigandset(sigset_t *, const sigset_t *, const sigset_t *);
># 269 "/usr/include/signal.h" 3 4
>typedef int sig_atomic_t;
>
>void (*signal(int, void (*)(int)))(int);
>int raise(int);
>
>
>}
># 26 "/usr/include/sys/wait.h" 2 3 4
>int waitid (idtype_t, id_t, siginfo_t *, int);
>
>
>
>
>pid_t wait3 (int *, int, struct rusage *);
>pid_t wait4 (pid_t, int *, int, struct rusage *);
># 57 "/usr/include/sys/wait.h" 3 4
>}
># 397 "../../gcc/system.h" 2
># 427 "../../gcc/system.h"
># 1 "/usr/include/sys/mman.h" 1 3 4
>
>
>
>extern "C" {
># 17 "/usr/include/sys/mman.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 18 "/usr/include/sys/mman.h" 2 3 4
># 110 "/usr/include/sys/mman.h" 3 4
># 1 "/usr/include/bits/mman.h" 1 3 4
># 111 "/usr/include/sys/mman.h" 2 3 4
>
>void *mmap (void *, size_t, int, int, int, off_t);
>int munmap (void *, size_t);
>
>int mprotect (void *, size_t, int);
>int msync (void *, size_t, int);
>
>int posix_madvise (void *, size_t, int);
>
>int mlock (const void *, size_t);
>int munlock (const void *, size_t);
>int mlockall (int);
>int munlockall (void);
>
>
>void *mremap (void *, size_t, size_t, int, ...);
>int remap_file_pages (void *, size_t, int, size_t, int);
>int memfd_create (const char *, unsigned);
>int mlock2 (const void *, size_t, unsigned);
>
>
>
>int madvise (void *, size_t, int);
>int mincore (void *, size_t, unsigned char *);
>
>
>int shm_open (const char *, int, mode_t);
>int shm_unlink (const char *);
>
>
>
>
>
>
>
>}
># 428 "../../gcc/system.h" 2
># 443 "../../gcc/system.h"
># 1 "/usr/include/sys/times.h" 1 3 4
>
>
>
>
>extern "C" {
>
>
>
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 10 "/usr/include/sys/times.h" 2 3 4
>
>struct tms {
> clock_t tms_utime;
> clock_t tms_stime;
> clock_t tms_cutime;
> clock_t tms_cstime;
>};
>
>clock_t times (struct tms *);
>
>
>}
># 444 "../../gcc/system.h" 2
># 452 "../../gcc/system.h"
>
># 452 "../../gcc/system.h"
>extern "C" {
># 463 "../../gcc/system.h"
># 1 "../../gcc/../include/gcc-getopt.h" 1
># 28 "../../gcc/../include/gcc-getopt.h"
># 1 "/usr/include/getopt.h" 1 3 4
>
>
>
>
>
># 5 "/usr/include/getopt.h" 3 4
>extern "C" {
>
>
>int getopt(int, char * const [], const char *);
>extern char *optarg;
>extern int optind, opterr, optopt, optreset;
>
>struct option {
> const char *name;
> int has_arg;
> int *flag;
> int val;
>};
>
>int getopt_long(int, char *const *, const char *, const struct option *, int *);
>int getopt_long_only(int, char *const *, const char *, const struct option *, int *);
>
>
>
>
>
>
>}
># 29 "../../gcc/../include/gcc-getopt.h" 2
># 73 "../../gcc/../include/gcc-getopt.h"
>
># 73 "../../gcc/../include/gcc-getopt.h"
>extern int _getopt_internal (int argc, char *const *argv,
> const char *shortopts,
> const struct option *longopts, int *longind,
> int long_only);
># 464 "../../gcc/system.h" 2
># 482 "../../gcc/system.h"
>extern char *getwd (char *);
># 518 "../../gcc/system.h"
>}
>
>
>
>
>
>
>
># 1 "/usr/include/inttypes.h" 1 3 4
>
>
>
>
>
># 5 "/usr/include/inttypes.h" 3 4
>extern "C" {
>
>
>
>
>
>
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 13 "/usr/include/inttypes.h" 2 3 4
>
>typedef struct { intmax_t quot, rem; } imaxdiv_t;
>
>intmax_t imaxabs(intmax_t);
>imaxdiv_t imaxdiv(intmax_t, intmax_t);
>
>intmax_t strtoimax(const char *__restrict, char **__restrict, int);
>uintmax_t strtoumax(const char *__restrict, char **__restrict, int);
>
>intmax_t wcstoimax(const wchar_t *__restrict, wchar_t **__restrict, int);
>uintmax_t wcstoumax(const wchar_t *__restrict, wchar_t **__restrict, int);
># 225 "/usr/include/inttypes.h" 3 4
>}
># 527 "../../gcc/system.h" 2
>
>
>
>
># 530 "../../gcc/system.h"
>extern "C" {
># 573 "../../gcc/system.h"
>}
># 596 "../../gcc/system.h"
># 1 "/usr/include/sys/stat.h" 1 3 4
>
>
>
>
># 4 "/usr/include/sys/stat.h" 3 4
>extern "C" {
># 21 "/usr/include/sys/stat.h" 3 4
># 1 "/usr/include/bits/alltypes.h" 1 3 4
># 22 "/usr/include/sys/stat.h" 2 3 4
>
># 1 "/usr/include/bits/stat.h" 1 3 4
>
>
>
>struct stat {
> dev_t st_dev;
> ino_t st_ino;
> nlink_t st_nlink;
>
> mode_t st_mode;
> uid_t st_uid;
> gid_t st_gid;
> unsigned int __pad0;
> dev_t st_rdev;
> off_t st_size;
> blksize_t st_blksize;
> blkcnt_t st_blocks;
>
> struct timespec st_atim;
> struct timespec st_mtim;
> struct timespec st_ctim;
> long __unused[3];
>};
># 24 "/usr/include/sys/stat.h" 2 3 4
># 73 "/usr/include/sys/stat.h" 3 4
>int stat(const char *__restrict, struct stat *__restrict);
>int fstat(int, struct stat *);
>int lstat(const char *__restrict, struct stat *__restrict);
>int fstatat(int, const char *__restrict, struct stat *__restrict, int);
>int chmod(const char *, mode_t);
>int fchmod(int, mode_t);
>int fchmodat(int, const char *, mode_t, int);
>mode_t umask(mode_t);
>int mkdir(const char *, mode_t);
>int mkfifo(const char *, mode_t);
>int mkdirat(int, const char *, mode_t);
>int mkfifoat(int, const char *, mode_t);
>
>
>int mknod(const char *, mode_t, dev_t);
>int mknodat(int, const char *, mode_t, dev_t);
>
>
>int futimens(int, const struct timespec [2]);
>int utimensat(int, const char *, const struct timespec [2], int);
>
>
>int lchmod(const char *, mode_t);
># 114 "/usr/include/sys/stat.h" 3 4
>}
># 597 "../../gcc/system.h" 2
># 668 "../../gcc/system.h"
># 1 "../../gcc/../include/filenames.h" 1
># 29 "../../gcc/../include/filenames.h"
># 1 "../../gcc/../include/hashtab.h" 1
># 36 "../../gcc/../include/hashtab.h"
>
># 36 "../../gcc/../include/hashtab.h"
>extern "C" {
>
>
># 1 "../../gcc/../include/ansidecl.h" 1
># 40 "../../gcc/../include/hashtab.h" 2
>
>
>typedef unsigned int hashval_t;
>
>
>
>
>typedef hashval_t (*htab_hash) (const void *);
>
>
>
>
>
>
>typedef int (*htab_eq) (const void *, const void *);
>
>
>
>typedef void (*htab_del) (void *);
>
>
>
>
>
>typedef int (*htab_trav) (void **, void *);
>
>
>
>
>
>typedef void *(*htab_alloc) (size_t, size_t);
>
>
>typedef void (*htab_free) (void *);
>
>
>
>typedef void *(*htab_alloc_with_arg) (void *, size_t, size_t);
>typedef void (*htab_free_with_arg) (void *, void *);
># 95 "../../gcc/../include/hashtab.h"
>struct htab {
>
> htab_hash hash_f;
>
>
> htab_eq eq_f;
>
>
> htab_del del_f;
>
>
> void **entries;
>
>
> size_t size;
>
>
> size_t n_elements;
>
>
> size_t n_deleted;
>
>
>
> unsigned int searches;
>
>
>
> unsigned int collisions;
>
>
> htab_alloc alloc_f;
> htab_free free_f;
>
>
> void *alloc_arg;
> htab_alloc_with_arg alloc_with_arg_f;
> htab_free_with_arg free_with_arg_f;
>
>
>
> unsigned int size_prime_index;
>};
>
>typedef struct htab *htab_t;
>
>
>enum insert_option {NO_INSERT, INSERT};
>
>
>
>extern htab_t htab_create_alloc (size_t, htab_hash,
> htab_eq, htab_del,
> htab_alloc, htab_free);
>
>extern htab_t htab_create_alloc_ex (size_t, htab_hash,
> htab_eq, htab_del,
> void *, htab_alloc_with_arg,
> htab_free_with_arg);
>
>extern htab_t htab_create_typed_alloc (size_t, htab_hash, htab_eq, htab_del,
> htab_alloc, htab_alloc, htab_free);
>
>
>extern htab_t htab_create (size_t, htab_hash, htab_eq, htab_del);
>extern htab_t htab_try_create (size_t, htab_hash, htab_eq, htab_del);
>
>extern void htab_set_functions_ex (htab_t, htab_hash,
> htab_eq, htab_del,
> void *, htab_alloc_with_arg,
> htab_free_with_arg);
>
>extern void htab_delete (htab_t);
>extern void htab_empty (htab_t);
>
>extern void * htab_find (htab_t, const void *);
>extern void ** htab_find_slot (htab_t, const void *, enum insert_option);
>extern void * htab_find_with_hash (htab_t, const void *, hashval_t);
>extern void ** htab_find_slot_with_hash (htab_t, const void *,
> hashval_t, enum insert_option);
>extern void htab_clear_slot (htab_t, void **);
>extern void htab_remove_elt (htab_t, const void *);
>extern void htab_remove_elt_with_hash (htab_t, const void *, hashval_t);
>
>extern void htab_traverse (htab_t, htab_trav, void *);
>extern void htab_traverse_noresize (htab_t, htab_trav, void *);
>
>extern size_t htab_size (htab_t);
>extern size_t htab_elements (htab_t);
>extern double htab_collisions (htab_t);
>
>
>extern htab_hash htab_hash_pointer;
>
>
>extern htab_eq htab_eq_pointer;
>
>
>extern hashval_t htab_hash_string (const void *);
>
>
>extern hashval_t iterative_hash (const void *, size_t, hashval_t);
>
>
>
>
>}
># 30 "../../gcc/../include/filenames.h" 2
>
>
>extern "C" {
># 84 "../../gcc/../include/filenames.h"
>extern int filename_cmp (const char *s1, const char *s2);
>
>
>extern int filename_ncmp (const char *s1, const char *s2,
> size_t n);
>
>extern hashval_t filename_hash (const void *s);
>
>extern int filename_eq (const void *s1, const void *s2);
>
>extern int canonical_filename_eq (const char *a, const char *b);
>
>
>}
># 669 "../../gcc/system.h" 2
># 680 "../../gcc/system.h"
># 1 "/usr/include/dlfcn.h" 1 3 4
>
>
>
>
>
># 5 "/usr/include/dlfcn.h" 3 4
>extern "C" {
># 22 "/usr/include/dlfcn.h" 3 4
>int dlclose(void *);
>char *dlerror(void);
>void *dlopen(const char *, int);
>void *dlsym(void *__restrict, const char *__restrict);
>
>
>typedef struct {
> const char *dli_fname;
> void *dli_fbase;
> const char *dli_sname;
> void *dli_saddr;
>} Dl_info;
>int dladdr(const void *, Dl_info *);
>int dlinfo(void *, int, void *);
>
>
>
>}
># 681 "../../gcc/system.h" 2
># 689 "../../gcc/system.h"
># 1 "../../gcc/../include/libiberty.h" 1
># 39 "../../gcc/../include/libiberty.h"
>
># 39 "../../gcc/../include/libiberty.h"
>extern "C" {
>
>
>
>
>
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stddef.h" 1 3 4
># 46 "../../gcc/../include/libiberty.h" 2
># 55 "../../gcc/../include/libiberty.h"
>extern void unlock_stream (FILE *);
>
>
>
>
>
>extern void unlock_std_streams (void);
>
>
>
>
>
>extern FILE *fopen_unlocked (const char *, const char *);
>extern FILE *fdopen_unlocked (int, const char *);
>extern FILE *freopen_unlocked (const char *, const char *, FILE *);
>
>
>
>
>extern char **buildargv (const char *) __attribute__ ((__malloc__));
>
>
>
>extern void freeargv (char **);
>
>
>
>
>extern char **dupargv (char * const *) __attribute__ ((__malloc__));
>
>
>
>extern void expandargv (int *, char ***);
>
>
>
>extern int writeargv (char * const *, FILE *);
>
>
>
>extern int countargv (char * const *);
># 112 "../../gcc/../include/libiberty.h"
>extern char *basename (const char *) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1)));
># 123 "../../gcc/../include/libiberty.h"
>extern const char *lbasename (const char *) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern const char *dos_lbasename (const char *) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern const char *unix_lbasename (const char *) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern char *lrealpath (const char *);
>
>
>
>extern int is_valid_fd (int fd);
>
>
>
>
>
>extern char *concat (const char *, ...) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((__sentinel__));
># 157 "../../gcc/../include/libiberty.h"
>extern char *reconcat (char *, const char *, ...) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((__sentinel__));
>
>
>
>
>
>extern unsigned long concat_length (const char *, ...) __attribute__ ((__sentinel__));
>
>
>
>
>
>
>extern char *concat_copy (char *, const char *, ...) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__sentinel__));
>
>
>
>
>
>
>extern char *concat_copy2 (const char *, ...) __attribute__ ((__returns_nonnull__)) __attribute__ ((__sentinel__));
>
>
>
>extern char *libiberty_concat_ptr;
># 193 "../../gcc/../include/libiberty.h"
>extern int fdmatch (int fd1, int fd2);
># 205 "../../gcc/../include/libiberty.h"
>extern char * getpwd (void);
># 218 "../../gcc/../include/libiberty.h"
>extern long get_run_time (void);
>
>
>
>
>extern char *make_relative_prefix (const char *, const char *,
> const char *) __attribute__ ((__malloc__));
>
>
>
>
>
>extern char *make_relative_prefix_ignore_links (const char *, const char *,
> const char *) __attribute__ ((__malloc__));
>
>
>
>
>extern const char *choose_tmpdir (void) __attribute__ ((__returns_nonnull__));
>
>
>
>extern char *choose_temp_base (void) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__));
>
>
>
>extern char *make_temp_file (const char *) __attribute__ ((__malloc__));
>
>
>
>
>extern char *make_temp_file_with_prefix (const char *, const char *) __attribute__ ((__malloc__));
>
>
>
>extern int unlink_if_ordinary (const char *);
>
>
>
>extern const char *spaces (int count);
>
>
>
>
>extern int errno_max (void);
>
>
>
>
>extern const char *strerrno (int);
>
>
>
>extern int strtoerrno (const char *);
>
>
>
>extern char *xstrerror (int) __attribute__ ((__returns_nonnull__));
>
>
>
>
>extern int signo_max (void);
># 292 "../../gcc/../include/libiberty.h"
>extern const char *strsigno (int);
>
>
>
>extern int strtosigno (const char *);
>
>
>
>extern int xatexit (void (*fn) (void));
>
>
>
>extern void xexit (int status) __attribute__ ((__noreturn__));
>
>
>
>extern void xmalloc_set_program_name (const char *);
>
>
>extern void xmalloc_failed (size_t) __attribute__ ((__noreturn__));
>
>
>
>
>
>extern void *xmalloc (size_t) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((alloc_size (1))) __attribute__ ((warn_unused_result));
>
>
>
>
>
>extern void *xrealloc (void *, size_t) __attribute__ ((__returns_nonnull__)) __attribute__ ((alloc_size (2))) __attribute__ ((warn_unused_result));
>
>
>
>
>extern void *xcalloc (size_t, size_t) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((alloc_size (1, 2))) __attribute__ ((warn_unused_result));
>
>
>
>extern char *xstrdup (const char *) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((warn_unused_result));
>
>
>
>extern char *xstrndup (const char *, size_t) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((warn_unused_result));
>
>
>
>extern void *xmemdup (const void *, size_t, size_t) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((warn_unused_result));
>
>
>extern double physmem_total (void);
>extern double physmem_available (void);
>
>
>extern unsigned int xcrc32 (const unsigned char *, int, unsigned int);
># 391 "../../gcc/../include/libiberty.h"
>extern const unsigned char _hex_value[256];
>extern void hex_init (void);
># 428 "../../gcc/../include/libiberty.h"
>extern struct pex_obj *pex_init (int flags, const char *pname,
> const char *tempbase) __attribute__ ((__returns_nonnull__));
># 528 "../../gcc/../include/libiberty.h"
>extern const char *pex_run (struct pex_obj *obj, int flags,
> const char *executable, char * const *argv,
> const char *outname, const char *errname,
> int *err);
># 543 "../../gcc/../include/libiberty.h"
>extern const char *pex_run_in_environment (struct pex_obj *obj, int flags,
> const char *executable,
> char * const *argv,
> char * const *env,
> const char *outname,
> const char *errname, int *err);
>
>
>
>
>
>extern FILE *pex_input_file (struct pex_obj *obj, int flags,
> const char *in_name);
>
>
>
>
>
>
>extern FILE *pex_input_pipe (struct pex_obj *obj, int binary);
>
>
>
>
>
>
>
>extern FILE *pex_read_output (struct pex_obj *, int binary);
>
>
>
>
>
>
>
>extern FILE *pex_read_err (struct pex_obj *, int binary);
>
>
>
>
>
>extern int pex_get_status (struct pex_obj *, int count, int *vector);
>
>
>
>
>
>
>struct pex_time
>{
> unsigned long user_seconds;
> unsigned long user_microseconds;
> unsigned long system_seconds;
> unsigned long system_microseconds;
>};
>
>extern int pex_get_times (struct pex_obj *, int count,
> struct pex_time *vector);
>
>
>
>
>extern void pex_free (struct pex_obj *);
># 618 "../../gcc/../include/libiberty.h"
>extern const char *pex_one (int flags, const char *executable,
> char * const *argv, const char *pname,
> const char *outname, const char *errname,
> int *status, int *err);
># 637 "../../gcc/../include/libiberty.h"
>extern int pexecute (const char *, char * const *, const char *,
> const char *, char **, char **, int);
>
>
>
>extern int pwait (int, int *, int);
># 654 "../../gcc/../include/libiberty.h"
>extern char *xasprintf (const char *, ...) __attribute__ ((__malloc__)) __attribute__ ((__format__ (__printf__, 1, 2))) __attribute__ ((__nonnull__ (1)));
># 666 "../../gcc/../include/libiberty.h"
>extern char *xvasprintf (const char *, va_list) __attribute__ ((__malloc__)) __attribute__ ((__format__ (__printf__, 1, 0))) __attribute__ ((__nonnull__ (1)));
># 715 "../../gcc/../include/libiberty.h"
>extern void setproctitle (const char *name, ...);
>
>
>extern void stack_limit_increase (unsigned long);
># 728 "../../gcc/../include/libiberty.h"
>extern void *C_alloca (size_t) __attribute__ ((__malloc__));
># 755 "../../gcc/../include/libiberty.h"
>}
># 690 "../../gcc/system.h" 2
># 739 "../../gcc/system.h"
>extern void fancy_abort (const char *, int, const char *)
> __attribute__ ((__noreturn__)) __attribute__ ((__cold__));
># 871 "../../gcc/system.h"
> 
>
>
>
>
>
> 
>
>
>
>
>
>
> 
>
>
>
>
> 
>
>
> 
># 941 "../../gcc/system.h"
> 
>
>
>
>
>
>
> 
># 1033 "../../gcc/system.h"
> 
># 1051 "../../gcc/system.h"
> 
>
>
> 
>
>
>
> 
># 1069 "../../gcc/system.h"
> 
># 1085 "../../gcc/system.h"
> 
>
>
>
> 
># 1202 "../../gcc/system.h"
># 1 "../../gcc/hwint.h" 1
># 77 "../../gcc/hwint.h"
>typedef long __gcc_host_wide_int__;
># 141 "../../gcc/hwint.h"
>static inline unsigned long
>least_bit_hwi (unsigned long x)
>{
> return (x & -x);
>}
>
>
>
>static inline bool
>pow2_or_zerop (unsigned long x)
>{
> return least_bit_hwi (x) == x;
>}
>
>
>
>static inline bool
>pow2p_hwi (unsigned long x)
>{
> return x && pow2_or_zerop (x);
>}
># 184 "../../gcc/hwint.h"
>static inline int
>clz_hwi (unsigned long x)
>{
> if (x == 0)
> return 64;
>
> return __builtin_clzl (x);
>
>
>
>
>
>}
>
>static inline int
>ctz_hwi (unsigned long x)
>{
> if (x == 0)
> return 64;
>
> return __builtin_ctzl (x);
>
>
>
>
>
>}
>
>static inline int
>ffs_hwi (unsigned long x)
>{
>
> return __builtin_ffsl (x);
>
>
>
>
>
>}
>
>static inline int
>popcount_hwi (unsigned long x)
>{
>
> return __builtin_popcountl (x);
>
>
>
>
>
>}
>
>static inline int
>floor_log2 (unsigned long x)
>{
> return 64 - 1 - clz_hwi (x);
>}
>
>static inline int
>ceil_log2 (unsigned long x)
>{
> return x == 0 ? 0 : floor_log2 (x - 1) + 1;
>}
>
>static inline int
>exact_log2 (unsigned long x)
>{
> return pow2p_hwi (x) ? ctz_hwi (x) : -1;
>}
>
>
>
>
>
>
>
>extern long abs_hwi (long);
>extern unsigned long absu_hwi (long);
>extern long gcd (long, long);
>extern long pos_mul_hwi (long, long);
>extern long mul_hwi (long, long);
>extern long least_common_multiple (long, long);
>
>
>
>static inline int
>ctz_or_zero (unsigned long x)
>{
> return ffs_hwi (x) - 1;
>}
>
>
>
>static inline long
>sext_hwi (long src, unsigned int prec)
>{
> if (prec == 64)
> return src;
> else
>
> {
>
>
>
>
>
>
> ((void)(!(prec < 64) ? fancy_abort ("../../gcc/hwint.h", 291, __FUNCTION__), 0 : 0));
> int shift = 64 - prec;
> return ((long) ((unsigned long) src << shift)) >> shift;
> }
># 304 "../../gcc/hwint.h"
>}
>
>
>static inline unsigned long
>zext_hwi (unsigned long src, unsigned int prec)
>{
> if (prec == 64)
> return src;
> else
> {
> ((void)(!(prec < 64) ? fancy_abort ("../../gcc/hwint.h", 314, __FUNCTION__), 0 : 0));
> return src & ((1UL << prec) - 1);
> }
>}
>
>
>
>inline long
>abs_hwi (long x)
>{
> ((void)(!(x != (long) (1UL << (64 - 1))) ? fancy_abort ("../../gcc/hwint.h", 324, __FUNCTION__), 0 : 0));
> return x >= 0 ? x : -x;
>}
>
>
>
>inline unsigned long
>absu_hwi (long x)
>{
> return x >= 0 ? (unsigned long)x : -(unsigned long)x;
>}
># 1203 "../../gcc/system.h" 2
>
>typedef int sort_r_cmp_fn (const void *, const void *, void *);
>void qsort_chk (void *, size_t, size_t, sort_r_cmp_fn *, void *);
>void gcc_sort_r (void *, size_t, size_t, sort_r_cmp_fn *, void *);
>void gcc_qsort (void *, size_t, size_t, int (*)(const void *, const void *));
>void gcc_stablesort (void *, size_t, size_t,
> int (*)(const void *, const void *));
># 28 "../../gcc/read-md.c" 2
># 1 "../../gcc/coretypes.h" 1
># 46 "../../gcc/coretypes.h"
>typedef int64_t gcov_type;
>typedef uint64_t gcov_type_unsigned;
>
>struct bitmap_obstack;
>class bitmap_head;
>typedef class bitmap_head *bitmap;
>typedef const class bitmap_head *const_bitmap;
>struct simple_bitmap_def;
>typedef struct simple_bitmap_def *sbitmap;
>typedef const struct simple_bitmap_def *const_sbitmap;
>struct rtx_def;
>typedef struct rtx_def *rtx;
>typedef const struct rtx_def *const_rtx;
>class scalar_mode;
>class scalar_int_mode;
>class scalar_float_mode;
>class complex_mode;
>class fixed_size_mode;
>template<typename> class opt_mode;
>typedef opt_mode<scalar_mode> opt_scalar_mode;
>typedef opt_mode<scalar_int_mode> opt_scalar_int_mode;
>typedef opt_mode<scalar_float_mode> opt_scalar_float_mode;
>template<typename> struct pod_mode;
>typedef pod_mode<scalar_mode> scalar_mode_pod;
>typedef pod_mode<scalar_int_mode> scalar_int_mode_pod;
>typedef pod_mode<fixed_size_mode> fixed_size_mode_pod;
>
>
>
>
>struct rtx_def;
> struct rtx_expr_list;
> struct rtx_insn_list;
> struct rtx_sequence;
> struct rtx_insn;
> struct rtx_debug_insn;
> struct rtx_nonjump_insn;
> struct rtx_jump_insn;
> struct rtx_call_insn;
> struct rtx_jump_table_data;
> struct rtx_barrier;
> struct rtx_code_label;
> struct rtx_note;
>
>struct rtvec_def;
>typedef struct rtvec_def *rtvec;
>typedef const struct rtvec_def *const_rtvec;
>struct hwivec_def;
>typedef struct hwivec_def *hwivec;
>typedef const struct hwivec_def *const_hwivec;
>union tree_node;
>typedef union tree_node *tree;
>typedef const union tree_node *const_tree;
>struct gimple;
>typedef gimple *gimple_seq;
>struct gimple_stmt_iterator;
>
>
>
>
>struct gcond;
>struct gdebug;
>struct ggoto;
>struct glabel;
>struct gswitch;
>struct gassign;
>struct gasm;
>struct gcall;
>struct gtransaction;
>struct greturn;
>struct gbind;
>struct gcatch;
>struct geh_filter;
>struct geh_mnt;
>struct geh_else;
>struct gresx;
>struct geh_dispatch;
>struct gphi;
>struct gtry;
>struct gomp_atomic_load;
>struct gomp_atomic_store;
>struct gomp_continue;
>struct gomp_critical;
>struct gomp_ordered;
>struct gomp_for;
>struct gomp_parallel;
>struct gomp_task;
>struct gomp_sections;
>struct gomp_single;
>struct gomp_target;
>struct gomp_teams;
>
>
>
>
>struct symtab_node;
> struct cgraph_node;
> struct varpool_node;
>struct cgraph_edge;
>
>union section;
>typedef union section section;
>struct gcc_options;
>struct cl_target_option;
>struct cl_optimization;
>struct cl_option;
>struct cl_decoded_option;
>struct cl_option_handlers;
>struct diagnostic_context;
>class pretty_printer;
>class diagnostic_event_id_t;
>
>template<typename T> struct array_traits;
>
>
>
>template<typename T, typename Traits = array_traits<T>,
> bool has_constant_size = Traits::has_constant_size>
>class bitmap_view;
>
>
>typedef unsigned char addr_space_t;
>
>
>
>
>
>
>enum ir_type {
> IR_GIMPLE,
> IR_RTL_CFGRTL,
> IR_RTL_CFGLAYOUT
>};
>
>
>
>
>
>
>struct cpp_reader;
>struct cpp_token;
>
>
>
>
>enum tls_model {
> TLS_MODEL_NONE,
> TLS_MODEL_EMULATED,
> TLS_MODEL_REAL,
> TLS_MODEL_GLOBAL_DYNAMIC = TLS_MODEL_REAL,
> TLS_MODEL_LOCAL_DYNAMIC,
> TLS_MODEL_INITIAL_EXEC,
> TLS_MODEL_LOCAL_EXEC
>};
>
>
>enum offload_abi {
> OFFLOAD_ABI_UNSET,
> OFFLOAD_ABI_LP64,
> OFFLOAD_ABI_ILP32
>};
>
>
>enum profile_update {
> PROFILE_UPDATE_SINGLE,
> PROFILE_UPDATE_ATOMIC,
> PROFILE_UPDATE_PREFER_ATOMIC
>};
>
>
>enum profile_reproducibility {
> PROFILE_REPRODUCIBILITY_SERIAL,
> PROFILE_REPRODUCIBILITY_PARALLEL_RUNS,
> PROFILE_REPRODUCIBILITY_MULTITHREADED
>};
>
>
>
>enum unwind_info_type
>{
> UI_NONE,
> UI_SJLJ,
> UI_DWARF2,
> UI_TARGET,
> UI_SEH
>};
>
>
>enum node_frequency {
>
>
> NODE_FREQUENCY_UNLIKELY_EXECUTED,
>
>
> NODE_FREQUENCY_EXECUTED_ONCE,
>
> NODE_FREQUENCY_NORMAL,
>
>
> NODE_FREQUENCY_HOT
>};
>
>
>enum optimization_type {
>
> OPTIMIZE_FOR_SPEED,
>
>
> OPTIMIZE_FOR_BOTH,
>
>
> OPTIMIZE_FOR_SIZE
>};
>
>
>enum pad_direction {
>
> PAD_NONE,
>
>
>
>
> PAD_UPWARD,
>
>
>
>
> PAD_DOWNWARD
>};
>
>
>
>
>enum var_init_status
>{
> VAR_INIT_STATUS_UNKNOWN,
> VAR_INIT_STATUS_UNINITIALIZED,
> VAR_INIT_STATUS_INITIALIZED
>};
>
>
>
>enum warn_strict_overflow_code
>{
>
>
>
> WARN_STRICT_OVERFLOW_ALL = 1,
>
>
>
>
> WARN_STRICT_OVERFLOW_CONDITIONAL = 2,
>
>
> WARN_STRICT_OVERFLOW_COMPARISON = 3,
>
>
> WARN_STRICT_OVERFLOW_MISC = 4,
>
>
> WARN_STRICT_OVERFLOW_MAGNITUDE = 5
>};
>
>
>
>
>
>
>
>typedef int alias_set_type;
>
>class edge_def;
>typedef class edge_def *edge;
>typedef const class edge_def *const_edge;
>struct basic_block_def;
>typedef struct basic_block_def *basic_block;
>typedef const struct basic_block_def *const_basic_block;
># 343 "../../gcc/coretypes.h"
>typedef int reg_class_t;
>
>class rtl_opt_pass;
>
>namespace gcc {
> class context;
>}
>
>typedef std::pair <tree, tree> tree_pair;
>typedef std::pair <const char *, int> string_int_pair;
>
>
>template <typename ValueType>
>struct kv_pair
>{
> const char *const name;
> const ValueType value;
>};
># 385 "../../gcc/coretypes.h"
>enum function_class {
> function_c94,
> function_c99_misc,
> function_c99_math_complex,
> function_sincos,
> function_c11_misc,
> function_c2x_misc
>};
>
>
>
>enum symbol_visibility
>{
> VISIBILITY_DEFAULT,
> VISIBILITY_PROTECTED,
> VISIBILITY_HIDDEN,
> VISIBILITY_INTERNAL
>};
>
>
>
>enum flt_eval_method
>{
> FLT_EVAL_METHOD_UNPREDICTABLE = -1,
> FLT_EVAL_METHOD_PROMOTE_TO_FLOAT = 0,
> FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE = 1,
> FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE = 2,
> FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16 = 16
>};
>
>enum excess_precision_type
>{
> EXCESS_PRECISION_TYPE_IMPLICIT,
> EXCESS_PRECISION_TYPE_STANDARD,
> EXCESS_PRECISION_TYPE_FAST
>};
>
>
>
>typedef void (*gt_pointer_operator) (void *, void *);
>
>
>typedef unsigned char uchar;
>
>
>
>
># 1 "./insn-modes.h" 1
>
>
>
>
>
>
>enum machine_mode
>{
> E_VOIDmode,
>
>
>
>
>
>
> E_BLKmode,
>
>
>
>
>
>
> E_CCmode,
>
>
>
>
>
>
> E_CCGCmode,
>
>
>
>
>
>
> E_CCGOCmode,
>
>
>
>
>
>
> E_CCNOmode,
>
>
>
>
>
>
> E_CCGZmode,
>
>
>
>
>
>
> E_CCAmode,
>
>
>
>
>
>
> E_CCCmode,
>
>
>
>
>
>
> E_CCOmode,
>
>
>
>
>
>
> E_CCPmode,
>
>
>
>
>
>
> E_CCSmode,
>
>
>
>
>
>
> E_CCZmode,
>
>
>
>
>
>
> E_CCFPmode,
>
>
>
>
>
>
> E_BImode,
>
>
>
>
>
>
> E_QImode,
>
>
>
>
>
>
> E_HImode,
>
>
>
>
>
>
> E_SImode,
>
>
>
>
>
>
> E_DImode,
>
>
>
>
>
>
> E_TImode,
>
>
>
>
>
>
> E_OImode,
>
>
>
>
>
>
> E_XImode,
>
>
>
>
>
>
> E_P2QImode,
>
>
>
>
>
>
> E_P2HImode,
>
>
>
>
>
>
> E_POImode,
>
>
>
>
>
>
> E_QQmode,
>
>
>
>
>
>
> E_HQmode,
>
>
>
>
>
>
> E_SQmode,
>
>
>
>
>
>
> E_DQmode,
>
>
>
>
>
>
> E_TQmode,
>
>
>
>
>
>
> E_UQQmode,
>
>
>
>
>
>
> E_UHQmode,
>
>
>
>
>
>
> E_USQmode,
>
>
>
>
>
>
> E_UDQmode,
>
>
>
>
>
>
> E_UTQmode,
>
>
>
>
>
>
> E_HAmode,
>
>
>
>
>
>
> E_SAmode,
>
>
>
>
>
>
> E_DAmode,
>
>
>
>
>
>
> E_TAmode,
>
>
>
>
>
>
> E_UHAmode,
>
>
>
>
>
>
> E_USAmode,
>
>
>
>
>
>
> E_UDAmode,
>
>
>
>
>
>
> E_UTAmode,
>
>
>
>
>
>
> E_SFmode,
>
>
>
>
>
>
> E_DFmode,
>
>
>
>
>
>
> E_XFmode,
>
>
>
>
>
>
> E_TFmode,
>
>
>
>
>
>
> E_SDmode,
>
>
>
>
>
>
> E_DDmode,
>
>
>
>
>
>
> E_TDmode,
>
>
>
>
>
>
> E_CQImode,
>
>
>
>
>
>
> E_CP2QImode,
>
>
>
>
>
>
> E_CHImode,
>
>
>
>
>
>
> E_CP2HImode,
>
>
>
>
>
>
> E_CSImode,
>
>
>
>
>
>
> E_CDImode,
>
>
>
>
>
>
> E_CTImode,
>
>
>
>
>
>
> E_CPOImode,
>
>
>
>
>
>
> E_COImode,
>
>
>
>
>
>
> E_CXImode,
>
>
>
>
>
>
> E_SCmode,
>
>
>
>
>
>
> E_DCmode,
>
>
>
>
>
>
> E_XCmode,
>
>
>
>
>
>
> E_TCmode,
>
>
>
>
>
>
> E_V2QImode,
>
>
>
>
>
>
> E_V4QImode,
>
>
>
>
>
>
> E_V2HImode,
>
>
>
>
>
>
> E_V1SImode,
>
>
>
>
>
>
> E_V8QImode,
>
>
>
>
>
>
> E_V4HImode,
>
>
>
>
>
>
> E_V2SImode,
>
>
>
>
>
>
> E_V1DImode,
>
>
>
>
>
>
> E_V12QImode,
>
>
>
>
>
>
> E_V6HImode,
>
>
>
>
>
>
> E_V14QImode,
>
>
>
>
>
>
> E_V16QImode,
>
>
>
>
>
>
> E_V8HImode,
>
>
>
>
>
>
> E_V4SImode,
>
>
>
>
>
>
> E_V2DImode,
>
>
>
>
>
>
> E_V1TImode,
>
>
>
>
>
>
> E_V32QImode,
>
>
>
>
>
>
> E_V16HImode,
>
>
>
>
>
>
> E_V8SImode,
>
>
>
>
>
>
> E_V4DImode,
>
>
>
>
>
>
> E_V2TImode,
>
>
>
>
>
>
> E_V64QImode,
>
>
>
>
>
>
> E_V32HImode,
>
>
>
>
>
>
> E_V16SImode,
>
>
>
>
>
>
> E_V8DImode,
>
>
>
>
>
>
> E_V4TImode,
>
>
>
>
>
>
> E_V128QImode,
>
>
>
>
>
>
> E_V64HImode,
>
>
>
>
>
>
> E_V32SImode,
>
>
>
>
>
>
> E_V16DImode,
>
>
>
>
>
>
> E_V8TImode,
>
>
>
>
>
>
> E_V64SImode,
>
>
>
>
>
>
> E_V2SFmode,
>
>
>
>
>
>
> E_V4SFmode,
>
>
>
>
>
>
> E_V2DFmode,
>
>
>
>
>
>
> E_V8SFmode,
>
>
>
>
>
>
> E_V4DFmode,
>
>
>
>
>
>
> E_V2TFmode,
>
>
>
>
>
>
> E_V16SFmode,
>
>
>
>
>
>
> E_V8DFmode,
>
>
>
>
>
>
> E_V4TFmode,
>
>
>
>
>
>
> E_V32SFmode,
>
>
>
>
>
>
> E_V16DFmode,
>
>
>
>
>
>
> E_V8TFmode,
>
>
>
>
>
>
> E_V64SFmode,
>
>
>
>
>
>
> E_V32DFmode,
>
>
>
>
>
>
> E_V16TFmode,
>
>
>
>
>
>
> MAX_MACHINE_MODE,
>
> MIN_MODE_RANDOM = E_VOIDmode,
> MAX_MODE_RANDOM = E_BLKmode,
>
> MIN_MODE_CC = E_CCmode,
> MAX_MODE_CC = E_CCFPmode,
>
> MIN_MODE_INT = E_QImode,
> MAX_MODE_INT = E_XImode,
>
> MIN_MODE_PARTIAL_INT = E_P2QImode,
> MAX_MODE_PARTIAL_INT = E_POImode,
>
> MIN_MODE_FRACT = E_QQmode,
> MAX_MODE_FRACT = E_TQmode,
>
> MIN_MODE_UFRACT = E_UQQmode,
> MAX_MODE_UFRACT = E_UTQmode,
>
> MIN_MODE_ACCUM = E_HAmode,
> MAX_MODE_ACCUM = E_TAmode,
>
> MIN_MODE_UACCUM = E_UHAmode,
> MAX_MODE_UACCUM = E_UTAmode,
>
> MIN_MODE_FLOAT = E_SFmode,
> MAX_MODE_FLOAT = E_TFmode,
>
> MIN_MODE_DECIMAL_FLOAT = E_SDmode,
> MAX_MODE_DECIMAL_FLOAT = E_TDmode,
>
> MIN_MODE_COMPLEX_INT = E_CQImode,
> MAX_MODE_COMPLEX_INT = E_CXImode,
>
> MIN_MODE_COMPLEX_FLOAT = E_SCmode,
> MAX_MODE_COMPLEX_FLOAT = E_TCmode,
>
> MIN_MODE_VECTOR_BOOL = E_VOIDmode,
> MAX_MODE_VECTOR_BOOL = E_VOIDmode,
>
> MIN_MODE_VECTOR_INT = E_V2QImode,
> MAX_MODE_VECTOR_INT = E_V64SImode,
>
> MIN_MODE_VECTOR_FRACT = E_VOIDmode,
> MAX_MODE_VECTOR_FRACT = E_VOIDmode,
>
> MIN_MODE_VECTOR_UFRACT = E_VOIDmode,
> MAX_MODE_VECTOR_UFRACT = E_VOIDmode,
>
> MIN_MODE_VECTOR_ACCUM = E_VOIDmode,
> MAX_MODE_VECTOR_ACCUM = E_VOIDmode,
>
> MIN_MODE_VECTOR_UACCUM = E_VOIDmode,
> MAX_MODE_VECTOR_UACCUM = E_VOIDmode,
>
> MIN_MODE_VECTOR_FLOAT = E_V2SFmode,
> MAX_MODE_VECTOR_FLOAT = E_V16TFmode,
>
> NUM_MACHINE_MODES = MAX_MACHINE_MODE
>};
># 433 "../../gcc/coretypes.h" 2
># 1 "../../gcc/signop.h" 1
># 28 "../../gcc/signop.h"
>enum signop {
> SIGNED,
> UNSIGNED
>};
># 434 "../../gcc/coretypes.h" 2
># 1 "../../gcc/wide-int.h" 1
># 314 "../../gcc/wide-int.h"
>template <typename T> class generic_wide_int;
>template <int N> class fixed_wide_int_storage;
>class wide_int_storage;
>
>
>
>
>
>typedef generic_wide_int <wide_int_storage> wide_int;
>typedef generic_wide_int < fixed_wide_int_storage <((64 + 4 + 64 - 1) & ~(64 - 1))> > offset_int;
>typedef generic_wide_int < fixed_wide_int_storage <(((160 + 64) / 64) * 64)> > widest_int;
>
>
>typedef generic_wide_int < fixed_wide_int_storage <(((160 + 64) / 64) * 64) * 2> > widest2_int;
>
>
>
>template <bool SE, bool HDP = true>
>class wide_int_ref_storage;
>
>typedef generic_wide_int <wide_int_ref_storage <false> > wide_int_ref;
># 348 "../../gcc/wide-int.h"
>namespace wi
>{
># 358 "../../gcc/wide-int.h"
> enum overflow_type {
> OVF_NONE = 0,
> OVF_UNDERFLOW = -1,
> OVF_OVERFLOW = 1,
>
>
> OVF_UNKNOWN = 2
> };
>
>
> enum precision_type {
>
>
>
> FLEXIBLE_PRECISION,
>
>
> VAR_PRECISION,
>
>
>
> CONST_PRECISION
> };
># 403 "../../gcc/wide-int.h"
> template <typename T> struct int_traits;
>
>
>
>
> template <typename T1, typename T2,
> enum precision_type P1 = int_traits <T1>::precision_type,
> enum precision_type P2 = int_traits <T2>::precision_type>
> struct binary_traits;
>
>
>
>
>
> template <typename T1, typename T2>
> struct binary_traits <T1, T2, FLEXIBLE_PRECISION, FLEXIBLE_PRECISION>
> {
> typedef widest_int result_type;
>
> };
>
> template <typename T1, typename T2>
> struct binary_traits <T1, T2, FLEXIBLE_PRECISION, VAR_PRECISION>
> {
> typedef wide_int result_type;
> typedef result_type operator_result;
> typedef bool predicate_result;
> };
>
> template <typename T1, typename T2>
> struct binary_traits <T1, T2, FLEXIBLE_PRECISION, CONST_PRECISION>
> {
>
>
> typedef generic_wide_int < fixed_wide_int_storage
> <int_traits <T2>::precision> > result_type;
> typedef result_type operator_result;
> typedef bool predicate_result;
> typedef result_type signed_shift_result_type;
> typedef bool signed_predicate_result;
> };
>
> template <typename T1, typename T2>
> struct binary_traits <T1, T2, VAR_PRECISION, FLEXIBLE_PRECISION>
> {
> typedef wide_int result_type;
> typedef result_type operator_result;
> typedef bool predicate_result;
> };
>
> template <typename T1, typename T2>
> struct binary_traits <T1, T2, CONST_PRECISION, FLEXIBLE_PRECISION>
> {
>
>
> typedef generic_wide_int < fixed_wide_int_storage
> <int_traits <T1>::precision> > result_type;
> typedef result_type operator_result;
> typedef bool predicate_result;
> typedef result_type signed_shift_result_type;
> typedef bool signed_predicate_result;
> };
>
> template <typename T1, typename T2>
> struct binary_traits <T1, T2, CONST_PRECISION, CONST_PRECISION>
> {
> static_assert ((int_traits <T1>::precision == int_traits <T2>::precision), "int_traits <T1>::precision == int_traits <T2>::precision");
>
>
> typedef generic_wide_int < fixed_wide_int_storage
> <int_traits <T1>::precision> > result_type;
> typedef result_type operator_result;
> typedef bool predicate_result;
> typedef result_type signed_shift_result_type;
> typedef bool signed_predicate_result;
> };
>
> template <typename T1, typename T2>
> struct binary_traits <T1, T2, VAR_PRECISION, VAR_PRECISION>
> {
> typedef wide_int result_type;
> typedef result_type operator_result;
> typedef bool predicate_result;
> };
>}
>
>
>namespace wi
>{
> template <typename T>
> unsigned int get_precision (const T &);
>
> template <typename T1, typename T2>
> unsigned int get_binary_precision (const T1 &, const T2 &);
>
> template <typename T1, typename T2>
> void copy (T1 &, const T2 &);
># 512 "../../gcc/wide-int.h"
> template <typename T> bool fits_shwi_p (const T &);
> template <typename T> bool fits_uhwi_p (const T &);
> template <typename T> bool neg_p (const T &, signop = SIGNED);
>
> template <typename T>
> long sign_mask (const T &);
>
> template <typename T1, typename T2> bool eq_p (const T1 &, const T2 &);
> template <typename T1, typename T2> bool ne_p (const T1 &, const T2 &);
> template <typename T1, typename T2> bool lt_p (const T1 &, const T2 &, signop);
> template <typename T1, typename T2> bool lts_p (const T1 &, const T2 &);
> template <typename T1, typename T2> bool ltu_p (const T1 &, const T2 &);
> template <typename T1, typename T2> bool le_p (const T1 &, const T2 &, signop);
> template <typename T1, typename T2> bool les_p (const T1 &, const T2 &);
> template <typename T1, typename T2> bool leu_p (const T1 &, const T2 &);
> template <typename T1, typename T2> bool gt_p (const T1 &, const T2 &, signop);
> template <typename T1, typename T2> bool gts_p (const T1 &, const T2 &);
> template <typename T1, typename T2> bool gtu_p (const T1 &, const T2 &);
> template <typename T1, typename T2> bool ge_p (const T1 &, const T2 &, signop);
> template <typename T1, typename T2> bool ges_p (const T1 &, const T2 &);
> template <typename T1, typename T2> bool geu_p (const T1 &, const T2 &);
>
> template <typename T1, typename T2>
> int cmp (const T1 &, const T2 &, signop);
>
> template <typename T1, typename T2>
> int cmps (const T1 &, const T2 &);
>
> template <typename T1, typename T2>
> int cmpu (const T1 &, const T2 &);
>
> template <typename T> typename wi::binary_traits <T, T>::result_type bit_not (const T &);
> template <typename T> typename wi::binary_traits <T, T>::result_type neg (const T &);
> template <typename T> typename wi::binary_traits <T, T>::result_type neg (const T &, overflow_type *);
> template <typename T> typename wi::binary_traits <T, T>::result_type abs (const T &);
> template <typename T> typename wi::binary_traits <T, T>::result_type ext (const T &, unsigned int, signop);
> template <typename T> typename wi::binary_traits <T, T>::result_type sext (const T &, unsigned int);
> template <typename T> typename wi::binary_traits <T, T>::result_type zext (const T &, unsigned int);
> template <typename T> typename wi::binary_traits <T, T>::result_type set_bit (const T &, unsigned int);
>
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type min (const T1 &, const T2 &, signop);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type smin (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umin (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type max (const T1 &, const T2 &, signop);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type smax (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umax (const T1 &, const T2 &);
>
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_and (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_and_not (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_or (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_or_not (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_xor (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type add (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type add (const T1 &, const T2 &, signop, overflow_type *);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type sub (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type sub (const T1 &, const T2 &, signop, overflow_type *);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mul (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mul (const T1 &, const T2 &, signop, overflow_type *);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type smul (const T1 &, const T2 &, overflow_type *);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umul (const T1 &, const T2 &, overflow_type *);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mul_high (const T1 &, const T2 &, signop);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type div_trunc (const T1 &, const T2 &, signop,
> overflow_type * = 0);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type sdiv_trunc (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type udiv_trunc (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type div_floor (const T1 &, const T2 &, signop,
> overflow_type * = 0);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type udiv_floor (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type sdiv_floor (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type div_ceil (const T1 &, const T2 &, signop,
> overflow_type * = 0);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type udiv_ceil (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type div_round (const T1 &, const T2 &, signop,
> overflow_type * = 0);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type divmod_trunc (const T1 &, const T2 &, signop,
> typename wi::binary_traits <T1, T2>::result_type *);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type gcd (const T1 &, const T2 &, signop = UNSIGNED);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mod_trunc (const T1 &, const T2 &, signop,
> overflow_type * = 0);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type smod_trunc (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umod_trunc (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mod_floor (const T1 &, const T2 &, signop,
> overflow_type * = 0);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umod_floor (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mod_ceil (const T1 &, const T2 &, signop,
> overflow_type * = 0);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mod_round (const T1 &, const T2 &, signop,
> overflow_type * = 0);
>
> template <typename T1, typename T2>
> bool multiple_of_p (const T1 &, const T2 &, signop);
>
> template <typename T1, typename T2>
> bool multiple_of_p (const T1 &, const T2 &, signop,
> typename wi::binary_traits <T1, T2>::result_type *);
>
> template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type lshift (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type lrshift (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type arshift (const T1 &, const T2 &);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type rshift (const T1 &, const T2 &, signop sgn);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type lrotate (const T1 &, const T2 &, unsigned int = 0);
> template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type rrotate (const T1 &, const T2 &, unsigned int = 0);
>
>
>
>
>
>
>
> bool only_sign_bit_p (const wide_int_ref &, unsigned int);
> bool only_sign_bit_p (const wide_int_ref &);
> int clz (const wide_int_ref &);
> int clrsb (const wide_int_ref &);
> int ctz (const wide_int_ref &);
> int exact_log2 (const wide_int_ref &);
> int floor_log2 (const wide_int_ref &);
> int ffs (const wide_int_ref &);
> int popcount (const wide_int_ref &);
> int parity (const wide_int_ref &);
>
> template <typename T>
> unsigned long extract_uhwi (const T &, unsigned int, unsigned int);
>
> template <typename T>
> unsigned int min_precision (const T &, signop);
>
> static inline void accumulate_overflow (overflow_type &, overflow_type);
>}
>
>namespace wi
>{
>
>
> class storage_ref
> {
> public:
> storage_ref () {}
> storage_ref (const long *, unsigned int, unsigned int);
>
> const long *val;
> unsigned int len;
> unsigned int precision;
>
>
>
> unsigned int get_len () const;
> unsigned int get_precision () const;
> const long *get_val () const;
> };
>}
>
>inline::wi::storage_ref::storage_ref (const long *val_in,
> unsigned int len_in,
> unsigned int precision_in)
> : val (val_in), len (len_in), precision (precision_in)
>{
>}
>
>inline unsigned int
>wi::storage_ref::get_len () const
>{
> return len;
>}
>
>inline unsigned int
>wi::storage_ref::get_precision () const
>{
> return precision;
>}
>
>inline const long *
>wi::storage_ref::get_val () const
>{
> return val;
>}
># 711 "../../gcc/wide-int.h"
>template <typename storage>
>class generic_wide_int : public storage
>{
>public:
> generic_wide_int ();
>
> template <typename T>
> generic_wide_int (const T &);
>
> template <typename T>
> generic_wide_int (const T &, unsigned int);
>
>
> long to_shwi (unsigned int) const;
> long to_shwi () const;
> unsigned long to_uhwi (unsigned int) const;
> unsigned long to_uhwi () const;
> long to_short_addr () const;
>
>
> long sign_mask () const;
> long elt (unsigned int) const;
> long sext_elt (unsigned int) const;
> unsigned long ulow () const;
> unsigned long uhigh () const;
> long slow () const;
> long shigh () const;
>
> template <typename T>
> generic_wide_int &operator = (const T &);
># 754 "../../gcc/wide-int.h"
> template <typename T> generic_wide_int &operator &= (const T &c) { return (*this = wi::bit_and (*this, c)); }
> template <typename T> generic_wide_int &operator |= (const T &c) { return (*this = wi::bit_or (*this, c)); }
> template <typename T> generic_wide_int &operator ^= (const T &c) { return (*this = wi::bit_xor (*this, c)); }
> template <typename T> generic_wide_int &operator += (const T &c) { return (*this = wi::add (*this, c)); }
> template <typename T> generic_wide_int &operator -= (const T &c) { return (*this = wi::sub (*this, c)); }
> template <typename T> generic_wide_int &operator *= (const T &c) { return (*this = wi::mul (*this, c)); }
> template <typename T> generic_wide_int &operator <<= (const T &c) { return (*this = wi::lshift (*this, c)); }
> template <typename T> generic_wide_int &operator >>= (const T &c) { return (*this = *this >> c); }
> generic_wide_int &operator ++ () { *this += 1; return *this; }
> generic_wide_int &operator -- () { *this += -1; return *this; }
>
>
>
>
>
>
> void dump () const;
>
> static const bool is_sign_extended
> = wi::int_traits <generic_wide_int <storage> >::is_sign_extended;
>};
>
>template <typename storage>
>inline generic_wide_int <storage>::generic_wide_int () {}
>
>template <typename storage>
>template <typename T>
>inline generic_wide_int <storage>::generic_wide_int (const T &x)
> : storage (x)
>{
>}
>
>template <typename storage>
>template <typename T>
>inline generic_wide_int <storage>::generic_wide_int (const T &x,
> unsigned int precision)
> : storage (x, precision)
>{
>}
>
>
>
>template <typename storage>
>inline long
>generic_wide_int <storage>::to_shwi (unsigned int precision) const
>{
> if (precision < 64)
> return sext_hwi (this->get_val ()[0], precision);
> else
> return this->get_val ()[0];
>}
>
>
>template <typename storage>
>inline long
>generic_wide_int <storage>::to_shwi () const
>{
> if (is_sign_extended)
> return this->get_val ()[0];
> else
> return to_shwi (this->get_precision ());
>}
>
>
>
>
>template <typename storage>
>inline unsigned long
>generic_wide_int <storage>::to_uhwi (unsigned int precision) const
>{
> if (precision < 64)
> return zext_hwi (this->get_val ()[0], precision);
> else
> return this->get_val ()[0];
>}
>
>
>template <typename storage>
>inline unsigned long
>generic_wide_int <storage>::to_uhwi () const
>{
> return to_uhwi (this->get_precision ());
>}
>
>
>
>
>
>template <typename storage>
>inline long
>generic_wide_int <storage>::to_short_addr () const
>{
> return this->get_val ()[0];
>}
>
>
>template <typename storage>
>inline long
>generic_wide_int <storage>::sign_mask () const
>{
> unsigned int len = this->get_len ();
> ((void)(!(len > 0) ? fancy_abort ("../../gcc/wide-int.h", 855, __FUNCTION__), 0 : 0));
>
> unsigned long high = this->get_val ()[len - 1];
> if (!is_sign_extended)
> {
> unsigned int precision = this->get_precision ();
> int excess = len * 64 - precision;
> if (excess > 0)
> high <<= excess;
> }
> return (long) (high) < 0 ? -1 : 0;
>}
>
>
>
>template <typename storage>
>inline long
>generic_wide_int <storage>::slow () const
>{
> return this->get_val ()[0];
>}
>
>
>
>template <typename storage>
>inline long
>generic_wide_int <storage>::shigh () const
>{
> return this->get_val ()[this->get_len () - 1];
>}
>
>
>
>template <typename storage>
>inline unsigned long
>generic_wide_int <storage>::ulow () const
>{
> return this->get_val ()[0];
>}
>
>
>
>template <typename storage>
>inline unsigned long
>generic_wide_int <storage>::uhigh () const
>{
> return this->get_val ()[this->get_len () - 1];
>}
>
>
>template <typename storage>
>inline long
>generic_wide_int <storage>::elt (unsigned int i) const
>{
> if (i >= this->get_len ())
> return sign_mask ();
> else
> return this->get_val ()[i];
>}
>
>
>
>template <typename storage>
>inline long
>generic_wide_int <storage>::sext_elt (unsigned int i) const
>{
> long elt_i = elt (i);
> if (!is_sign_extended)
> {
> unsigned int precision = this->get_precision ();
> unsigned int lsb = i * 64;
> if (precision - lsb < 64)
> elt_i = sext_hwi (elt_i, precision - lsb);
> }
> return elt_i;
>}
>
>template <typename storage>
>template <typename T>
>inline generic_wide_int <storage> &
>generic_wide_int <storage>::operator = (const T &x)
>{
> storage::operator = (x);
> return *this;
>}
>
>
>template <typename storage>
>void
>generic_wide_int <storage>::dump () const
>{
> unsigned int len = this->get_len ();
> const long *val = this->get_val ();
> unsigned int precision = this->get_precision ();
> fprintf (
># 949 "../../gcc/wide-int.h" 3 4
> (stderr)
># 949 "../../gcc/wide-int.h"
> , "[");
> if (len * 64 < precision)
> fprintf (
># 951 "../../gcc/wide-int.h" 3 4
> (stderr)
># 951 "../../gcc/wide-int.h"
> , "...,");
> for (unsigned int i = 0; i < len - 1; ++i)
> fprintf (
># 953 "../../gcc/wide-int.h" 3 4
> (stderr)
># 953 "../../gcc/wide-int.h"
> , "%#" 
># 953 "../../gcc/wide-int.h" 3 4
> "l" "x" 
># 953 "../../gcc/wide-int.h"
> ",", val[len - 1 - i]);
> fprintf (
># 954 "../../gcc/wide-int.h" 3 4
> (stderr)
># 954 "../../gcc/wide-int.h"
> , "%#" 
># 954 "../../gcc/wide-int.h" 3 4
> "l" "x" 
># 954 "../../gcc/wide-int.h"
> "], precision = %d\n",
> val[0], precision);
>}
>
>namespace wi
>{
> template <typename storage>
> struct int_traits < generic_wide_int <storage> >
> : public wi::int_traits <storage>
> {
> static unsigned int get_precision (const generic_wide_int <storage> &);
> static wi::storage_ref decompose (long *, unsigned int,
> const generic_wide_int <storage> &);
> };
>}
>
>template <typename storage>
>inline unsigned int
>wi::int_traits < generic_wide_int <storage> >::
>get_precision (const generic_wide_int <storage> &x)
>{
> return x.get_precision ();
>}
>
>template <typename storage>
>inline wi::storage_ref
>wi::int_traits < generic_wide_int <storage> >::
>decompose (long *, unsigned int precision,
> const generic_wide_int <storage> &x)
>{
> ((void)(!(precision == x.get_precision ()) ? fancy_abort ("../../gcc/wide-int.h", 984, __FUNCTION__), 0 : 0));
> return wi::storage_ref (x.get_val (), x.get_len (), precision);
>}
>
>
>
>
>template <bool SE, bool HDP>
>class wide_int_ref_storage : public wi::storage_ref
>{
>private:
>
>
> long scratch[2];
>
>public:
> wide_int_ref_storage () {}
>
> wide_int_ref_storage (const wi::storage_ref &);
>
> template <typename T>
> wide_int_ref_storage (const T &);
>
> template <typename T>
> wide_int_ref_storage (const T &, unsigned int);
>};
>
>
>template <bool SE, bool HDP>
>inline wide_int_ref_storage <SE, HDP>::
>wide_int_ref_storage (const wi::storage_ref &x)
> : storage_ref (x)
>{}
>
>
>
>
>template <bool SE, bool HDP>
>template <typename T>
>inline wide_int_ref_storage <SE, HDP>::wide_int_ref_storage (const T &x)
> : storage_ref (wi::int_traits <T>::decompose (scratch,
> wi::get_precision (x), x))
>{
>}
>
>
>template <bool SE, bool HDP>
>template <typename T>
>inline wide_int_ref_storage <SE, HDP>::
>wide_int_ref_storage (const T &x, unsigned int precision)
> : storage_ref (wi::int_traits <T>::decompose (scratch, precision, x))
>{
>}
>
>namespace wi
>{
> template <bool SE, bool HDP>
> struct int_traits <wide_int_ref_storage <SE, HDP> >
> {
> static const enum precision_type precision_type = VAR_PRECISION;
> static const bool host_dependent_precision = HDP;
> static const bool is_sign_extended = SE;
> };
>}
>
>namespace wi
>{
> unsigned int force_to_size (long *, const long *,
> unsigned int, unsigned int, unsigned int,
> signop sgn);
> unsigned int from_array (long *, const long *,
> unsigned int, unsigned int, bool = true);
>}
>
>
>class wide_int_storage
>{
>private:
> long val[((160 + 64) / 64)];
> unsigned int len;
> unsigned int precision;
>
>public:
> wide_int_storage ();
> template <typename T>
> wide_int_storage (const T &);
>
>
> unsigned int get_precision () const;
> const long *get_val () const;
> unsigned int get_len () const;
> long *write_val ();
> void set_len (unsigned int, bool = false);
>
> template <typename T>
> wide_int_storage &operator = (const T &);
>
> static wide_int from (const wide_int_ref &, unsigned int, signop);
> static wide_int from_array (const long *, unsigned int,
> unsigned int, bool = true);
> static wide_int create (unsigned int);
>
>
> wide_int bswap () const;
>};
>
>namespace wi
>{
> template <>
> struct int_traits <wide_int_storage>
> {
> static const enum precision_type precision_type = VAR_PRECISION;
>
> static const bool host_dependent_precision = false;
> static const bool is_sign_extended = true;
> template <typename T1, typename T2>
> static wide_int get_binary_result (const T1 &, const T2 &);
> };
>}
>
>inline wide_int_storage::wide_int_storage () {}
>
>
>
>
>
>template <typename T>
>inline wide_int_storage::wide_int_storage (const T &x)
>{
> { static_assert ((!wi::int_traits<T>::host_dependent_precision), "!wi::int_traits<T>::host_dependent_precision"); }
> { static_assert ((wi::int_traits<T>::precision_type != wi::CONST_PRECISION), "wi::int_traits<T>::precision_type != wi::CONST_PRECISION"); }
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
> precision = xi.precision;
> wi::copy (*this, xi);
>}
>
>template <typename T>
>inline wide_int_storage&
>wide_int_storage::operator = (const T &x)
>{
> { static_assert ((!wi::int_traits<T>::host_dependent_precision), "!wi::int_traits<T>::host_dependent_precision"); }
> { static_assert ((wi::int_traits<T>::precision_type != wi::CONST_PRECISION), "wi::int_traits<T>::precision_type != wi::CONST_PRECISION"); }
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
> precision = xi.precision;
> wi::copy (*this, xi);
> return *this;
>}
>
>inline unsigned int
>wide_int_storage::get_precision () const
>{
> return precision;
>}
>
>inline const long *
>wide_int_storage::get_val () const
>{
> return val;
>}
>
>inline unsigned int
>wide_int_storage::get_len () const
>{
> return len;
>}
>
>inline long *
>wide_int_storage::write_val ()
>{
> return val;
>}
>
>inline void
>wide_int_storage::set_len (unsigned int l, bool is_sign_extended)
>{
> len = l;
> if (!is_sign_extended && len * 64 > precision)
> val[len - 1] = sext_hwi (val[len - 1],
> precision % 64);
>}
>
>
>
>inline wide_int
>wide_int_storage::from (const wide_int_ref &x, unsigned int precision,
> signop sgn)
>{
> wide_int result = wide_int::create (precision);
> result.set_len (wi::force_to_size (result.write_val (), x.val, x.len,
> x.precision, precision, sgn));
> return result;
>}
>
>
>
>
>inline wide_int
>wide_int_storage::from_array (const long *val, unsigned int len,
> unsigned int precision, bool need_canon_p)
>{
> wide_int result = wide_int::create (precision);
> result.set_len (wi::from_array (result.write_val (), val, len, precision,
> need_canon_p));
> return result;
>}
>
>
>inline wide_int
>wide_int_storage::create (unsigned int precision)
>{
> wide_int x;
> x.precision = precision;
> return x;
>}
>
>template <typename T1, typename T2>
>inline wide_int
>wi::int_traits <wide_int_storage>::get_binary_result (const T1 &x, const T2 &y)
>{
>
> static_assert ((wi::int_traits <T1>::precision_type != FLEXIBLE_PRECISION || wi::int_traits <T2>::precision_type != FLEXIBLE_PRECISION), "wi::int_traits <T1>::precision_type != FLEXIBLE_PRECISION || wi::int_traits <T2>::precision_type != FLEXIBLE_PRECISION")
> ;
> if (wi::int_traits <T1>::precision_type == FLEXIBLE_PRECISION)
> return wide_int::create (wi::get_precision (y));
> else
> return wide_int::create (wi::get_precision (x));
>}
>
>
>template <int N>
>class fixed_wide_int_storage
>{
>private:
> long val[(N + 64 + 1) / 64];
> unsigned int len;
>
>public:
> fixed_wide_int_storage ();
> template <typename T>
> fixed_wide_int_storage (const T &);
>
>
> unsigned int get_precision () const;
> const long *get_val () const;
> unsigned int get_len () const;
> long *write_val ();
> void set_len (unsigned int, bool = false);
>
> static generic_wide_int < fixed_wide_int_storage <N> > from (const wide_int_ref &, signop);
> static generic_wide_int < fixed_wide_int_storage <N> > from_array (const long *, unsigned int,
> bool = true);
>};
>
>namespace wi
>{
> template <int N>
> struct int_traits < fixed_wide_int_storage <N> >
> {
> static const enum precision_type precision_type = CONST_PRECISION;
> static const bool host_dependent_precision = false;
> static const bool is_sign_extended = true;
> static const unsigned int precision = N;
> template <typename T1, typename T2>
> static generic_wide_int < fixed_wide_int_storage <N> > get_binary_result (const T1 &, const T2 &);
> };
>}
>
>template <int N>
>inline fixed_wide_int_storage <N>::fixed_wide_int_storage () {}
>
>
>template <int N>
>template <typename T>
>inline fixed_wide_int_storage <N>::fixed_wide_int_storage (const T &x)
>{
>
>
> typename wi::binary_traits <T, generic_wide_int < fixed_wide_int_storage <N> > >::result_type *assertion __attribute__ ((__unused__));
> wi::copy (*this, generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > (x, N));
>}
>
>template <int N>
>inline unsigned int
>fixed_wide_int_storage <N>::get_precision () const
>{
> return N;
>}
>
>template <int N>
>inline const long *
>fixed_wide_int_storage <N>::get_val () const
>{
> return val;
>}
>
>template <int N>
>inline unsigned int
>fixed_wide_int_storage <N>::get_len () const
>{
> return len;
>}
>
>template <int N>
>inline long *
>fixed_wide_int_storage <N>::write_val ()
>{
> return val;
>}
>
>template <int N>
>inline void
>fixed_wide_int_storage <N>::set_len (unsigned int l, bool)
>{
> len = l;
>
> static_assert ((N % 64 == 0), "N % HOST_BITS_PER_WIDE_INT == 0");
>}
>
>
>template <int N>
>inline generic_wide_int < fixed_wide_int_storage <N> >
>fixed_wide_int_storage <N>::from (const wide_int_ref &x, signop sgn)
>{
> generic_wide_int < fixed_wide_int_storage <N> > result;
> result.set_len (wi::force_to_size (result.write_val (), x.val, x.len,
> x.precision, N, sgn));
> return result;
>}
>
>
>
>
>template <int N>
>inline generic_wide_int < fixed_wide_int_storage <N> >
>fixed_wide_int_storage <N>::from_array (const long *val,
> unsigned int len,
> bool need_canon_p)
>{
> generic_wide_int < fixed_wide_int_storage <N> > result;
> result.set_len (wi::from_array (result.write_val (), val, len,
> N, need_canon_p));
> return result;
>}
>
>template <int N>
>template <typename T1, typename T2>
>inline generic_wide_int < fixed_wide_int_storage <N> >
>wi::int_traits < fixed_wide_int_storage <N> >::
>get_binary_result (const T1 &, const T2 &)
>{
> return generic_wide_int < fixed_wide_int_storage <N> > ();
>}
>
>
>class trailing_wide_int_storage
>{
>private:
>
>
> unsigned int m_precision;
>
>
> unsigned char *m_len;
>
>
>
> long *m_val;
>
>public:
> trailing_wide_int_storage (unsigned int, unsigned char *, long *);
>
>
> unsigned int get_len () const;
> unsigned int get_precision () const;
> const long *get_val () const;
> long *write_val ();
> void set_len (unsigned int, bool = false);
>
> template <typename T>
> trailing_wide_int_storage &operator = (const T &);
>};
>
>typedef generic_wide_int <trailing_wide_int_storage> trailing_wide_int;
>
>
>namespace wi
>{
> template <>
> struct int_traits <trailing_wide_int_storage>
> : public int_traits <wide_int_storage> {};
>}
>
>
>
>
>
>template <int N>
>struct trailing_wide_ints
>{
>private:
>
> unsigned short m_precision;
>
>
> unsigned char m_max_len;
>
>
> unsigned char m_len[N];
>
>
>
> long m_val[1];
>
>public:
> typedef generic_wide_int <wide_int_ref_storage <wi::int_traits <trailing_wide_int_storage>::is_sign_extended, wi::int_traits <trailing_wide_int_storage>::host_dependent_precision> > const_reference;
>
> void set_precision (unsigned int);
> unsigned int get_precision () const { return m_precision; }
> trailing_wide_int operator [] (unsigned int);
> const_reference operator [] (unsigned int) const;
> static size_t extra_size (unsigned int);
> size_t extra_size () const { return extra_size (m_precision); }
>};
>
>inline trailing_wide_int_storage::
>trailing_wide_int_storage (unsigned int precision, unsigned char *len,
> long *val)
> : m_precision (precision), m_len (len), m_val (val)
>{
>}
>
>inline unsigned int
>trailing_wide_int_storage::get_len () const
>{
> return *m_len;
>}
>
>inline unsigned int
>trailing_wide_int_storage::get_precision () const
>{
> return m_precision;
>}
>
>inline const long *
>trailing_wide_int_storage::get_val () const
>{
> return m_val;
>}
>
>inline long *
>trailing_wide_int_storage::write_val ()
>{
> return m_val;
>}
>
>inline void
>trailing_wide_int_storage::set_len (unsigned int len, bool is_sign_extended)
>{
> *m_len = len;
> if (!is_sign_extended && len * 64 > m_precision)
> m_val[len - 1] = sext_hwi (m_val[len - 1],
> m_precision % 64);
>}
>
>template <typename T>
>inline trailing_wide_int_storage &
>trailing_wide_int_storage::operator = (const T &x)
>{
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, m_precision);
> wi::copy (*this, xi);
> return *this;
>}
>
>
>
>template <int N>
>inline void
>trailing_wide_ints <N>::set_precision (unsigned int precision)
>{
> m_precision = precision;
> m_max_len = ((precision + 64 - 1)
> / 64);
>}
>
>
>template <int N>
>inline trailing_wide_int
>trailing_wide_ints <N>::operator [] (unsigned int index)
>{
> return trailing_wide_int_storage (m_precision, &m_len[index],
> &m_val[index * m_max_len]);
>}
>
>template <int N>
>inline typename trailing_wide_ints <N>::const_reference
>trailing_wide_ints <N>::operator [] (unsigned int index) const
>{
> return wi::storage_ref (&m_val[index * m_max_len],
> m_len[index], m_precision);
>}
>
>
>
>template <int N>
>inline size_t
>trailing_wide_ints <N>::extra_size (unsigned int precision)
>{
> unsigned int max_len = ((precision + 64 - 1)
> / 64);
> return (N * max_len - 1) * sizeof (long);
>}
># 1503 "../../gcc/wide-int.h"
>namespace wi
>{
>
> template <typename T, bool signed_p>
> struct primitive_int_traits
> {
> static const enum precision_type precision_type = FLEXIBLE_PRECISION;
> static const bool host_dependent_precision = true;
> static const bool is_sign_extended = true;
> static unsigned int get_precision (T);
> static wi::storage_ref decompose (long *, unsigned int, T);
> };
>}
>
>template <typename T, bool signed_p>
>inline unsigned int
>wi::primitive_int_traits <T, signed_p>::get_precision (T)
>{
> return sizeof (T) * 8;
>}
>
>template <typename T, bool signed_p>
>inline wi::storage_ref
>wi::primitive_int_traits <T, signed_p>::decompose (long *scratch,
> unsigned int precision, T x)
>{
> scratch[0] = x;
> if (signed_p || scratch[0] >= 0 || precision <= 64)
> return wi::storage_ref (scratch, 1, precision);
> scratch[1] = 0;
> return wi::storage_ref (scratch, 2, precision);
>}
>
>
>namespace wi
>{
> template <>
> struct int_traits <unsigned char>
> : public primitive_int_traits <unsigned char, false> {};
>
> template <>
> struct int_traits <unsigned short>
> : public primitive_int_traits <unsigned short, false> {};
>
> template <>
> struct int_traits <int>
> : public primitive_int_traits <int, true> {};
>
> template <>
> struct int_traits <unsigned int>
> : public primitive_int_traits <unsigned int, false> {};
>
> template <>
> struct int_traits <long>
> : public primitive_int_traits <long, true> {};
>
> template <>
> struct int_traits <unsigned long>
> : public primitive_int_traits <unsigned long, false> {};
>
>
> template <>
> struct int_traits <long long>
> : public primitive_int_traits <long long, true> {};
>
> template <>
> struct int_traits <unsigned long long>
> : public primitive_int_traits <unsigned long long, false> {};
>
>}
>
>namespace wi
>{
>
>
> class hwi_with_prec
> {
> public:
> hwi_with_prec () {}
> hwi_with_prec (long, unsigned int, signop);
> long val;
> unsigned int precision;
> signop sgn;
> };
>
> hwi_with_prec shwi (long, unsigned int);
> hwi_with_prec uhwi (unsigned long, unsigned int);
>
> hwi_with_prec minus_one (unsigned int);
> hwi_with_prec zero (unsigned int);
> hwi_with_prec one (unsigned int);
> hwi_with_prec two (unsigned int);
>}
>
>inline wi::hwi_with_prec::hwi_with_prec (long v, unsigned int p,
> signop s)
> : precision (p), sgn (s)
>{
> if (precision < 64)
> val = sext_hwi (v, precision);
> else
> val = v;
>}
>
>
>inline wi::hwi_with_prec
>wi::shwi (long val, unsigned int precision)
>{
> return hwi_with_prec (val, precision, SIGNED);
>}
>
>
>inline wi::hwi_with_prec
>wi::uhwi (unsigned long val, unsigned int precision)
>{
> return hwi_with_prec (val, precision, UNSIGNED);
>}
>
>
>inline wi::hwi_with_prec
>wi::minus_one (unsigned int precision)
>{
> return wi::shwi (-1, precision);
>}
>
>
>inline wi::hwi_with_prec
>wi::zero (unsigned int precision)
>{
> return wi::shwi (0, precision);
>}
>
>
>inline wi::hwi_with_prec
>wi::one (unsigned int precision)
>{
> return wi::shwi (1, precision);
>}
>
>
>inline wi::hwi_with_prec
>wi::two (unsigned int precision)
>{
> return wi::shwi (2, precision);
>}
>
>namespace wi
>{
>
>
> template<typename T, precision_type = int_traits<T>::precision_type>
> struct ints_for
> {
> static int zero (const T &) { return 0; }
> };
>
> template<typename T>
> struct ints_for<T, VAR_PRECISION>
> {
> static hwi_with_prec zero (const T &);
> };
>}
>
>template<typename T>
>inline wi::hwi_with_prec
>wi::ints_for<T, wi::VAR_PRECISION>::zero (const T &x)
>{
> return wi::zero (wi::get_precision (x));
>}
>
>namespace wi
>{
> template <>
> struct int_traits <wi::hwi_with_prec>
> {
> static const enum precision_type precision_type = VAR_PRECISION;
>
>
> static const bool host_dependent_precision = false;
> static const bool is_sign_extended = true;
> static unsigned int get_precision (const wi::hwi_with_prec &);
> static wi::storage_ref decompose (long *, unsigned int,
> const wi::hwi_with_prec &);
> };
>}
>
>inline unsigned int
>wi::int_traits <wi::hwi_with_prec>::get_precision (const wi::hwi_with_prec &x)
>{
> return x.precision;
>}
>
>inline wi::storage_ref
>wi::int_traits <wi::hwi_with_prec>::
>decompose (long *scratch, unsigned int precision,
> const wi::hwi_with_prec &x)
>{
> ((void)(!(precision == x.precision) ? fancy_abort ("../../gcc/wide-int.h", 1700, __FUNCTION__), 0 : 0));
> scratch[0] = x.val;
> if (x.sgn == SIGNED || x.val >= 0 || precision <= 64)
> return wi::storage_ref (scratch, 1, precision);
> scratch[1] = 0;
> return wi::storage_ref (scratch, 2, precision);
>}
>
>
>
>
>
>
>namespace wi
>{
> bool eq_p_large (const long *, unsigned int,
> const long *, unsigned int, unsigned int);
> bool lts_p_large (const long *, unsigned int, unsigned int,
> const long *, unsigned int);
> bool ltu_p_large (const long *, unsigned int, unsigned int,
> const long *, unsigned int);
> int cmps_large (const long *, unsigned int, unsigned int,
> const long *, unsigned int);
> int cmpu_large (const long *, unsigned int, unsigned int,
> const long *, unsigned int);
> unsigned int sext_large (long *, const long *,
> unsigned int,
> unsigned int, unsigned int);
> unsigned int zext_large (long *, const long *,
> unsigned int,
> unsigned int, unsigned int);
> unsigned int set_bit_large (long *, const long *,
> unsigned int, unsigned int, unsigned int);
> unsigned int lshift_large (long *, const long *,
> unsigned int, unsigned int, unsigned int);
> unsigned int lrshift_large (long *, const long *,
> unsigned int, unsigned int, unsigned int,
> unsigned int);
> unsigned int arshift_large (long *, const long *,
> unsigned int, unsigned int, unsigned int,
> unsigned int);
> unsigned int and_large (long *, const long *, unsigned int,
> const long *, unsigned int, unsigned int);
> unsigned int and_not_large (long *, const long *,
> unsigned int, const long *,
> unsigned int, unsigned int);
> unsigned int or_large (long *, const long *, unsigned int,
> const long *, unsigned int, unsigned int);
> unsigned int or_not_large (long *, const long *,
> unsigned int, const long *,
> unsigned int, unsigned int);
> unsigned int xor_large (long *, const long *, unsigned int,
> const long *, unsigned int, unsigned int);
> unsigned int add_large (long *, const long *, unsigned int,
> const long *, unsigned int, unsigned int,
> signop, overflow_type *);
> unsigned int sub_large (long *, const long *, unsigned int,
> const long *, unsigned int, unsigned int,
> signop, overflow_type *);
> unsigned int mul_internal (long *, const long *,
> unsigned int, const long *,
> unsigned int, unsigned int, signop,
> overflow_type *, bool);
> unsigned int divmod_internal (long *, unsigned int *,
> long *, const long *,
> unsigned int, unsigned int,
> const long *,
> unsigned int, unsigned int,
> signop, overflow_type *);
>}
>
>
>template <typename T>
>inline unsigned int
>wi::get_precision (const T &x)
>{
> return wi::int_traits <T>::get_precision (x);
>}
>
>
>
>template <typename T1, typename T2>
>inline unsigned int
>wi::get_binary_precision (const T1 &x, const T2 &y)
>{
> return get_precision (wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::
> get_binary_result (x, y));
>}
>
>
>template <typename T1, typename T2>
>inline void
>wi::copy (T1 &x, const T2 &y)
>{
> long *xval = x.write_val ();
> const long *yval = y.get_val ();
> unsigned int len = y.get_len ();
> unsigned int i = 0;
> do
> xval[i] = yval[i];
> while (++i < len);
> x.set_len (len, y.is_sign_extended);
>}
>
>
>template <typename T>
>inline bool
>wi::fits_shwi_p (const T &x)
>{
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
> return xi.len == 1;
>}
>
>
>
>template <typename T>
>inline bool
>wi::fits_uhwi_p (const T &x)
>{
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
> if (xi.precision <= 64)
> return true;
> if (xi.len == 1)
> return xi.slow () >= 0;
> return xi.len == 2 && xi.uhigh () == 0;
>}
>
>
>
>template <typename T>
>inline bool
>wi::neg_p (const T &x, signop sgn)
>{
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
> if (sgn == UNSIGNED)
> return false;
> return xi.sign_mask () < 0;
>}
>
>
>template <typename T>
>inline long
>wi::sign_mask (const T &x)
>{
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
> return xi.sign_mask ();
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::eq_p (const T1 &x, const T2 &y)
>{
> unsigned int precision = get_binary_precision (x, y);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> if (xi.is_sign_extended && yi.is_sign_extended)
> {
>
> if (xi.len != yi.len)
> return false;
> unsigned int i = 0;
> do
> if (xi.val[i] != yi.val[i])
> return false;
> while (++i != xi.len);
> return true;
> }
> if (__builtin_expect (yi.len == 1, true))
> {
>
> if (xi.len != 1)
> return false;
>
>
> if ((__builtin_constant_p (yi.val[0] == 0) && (yi.val[0] == 0)))
> return xi.val[0] == 0;
>
> unsigned long diff = xi.val[0] ^ yi.val[0];
> int excess = 64 - precision;
> if (excess > 0)
> diff <<= excess;
> return diff == 0;
> }
> return eq_p_large (xi.val, xi.len, yi.val, yi.len, precision);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::ne_p (const T1 &x, const T2 &y)
>{
> return !eq_p (x, y);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::lts_p (const T1 &x, const T2 &y)
>{
> unsigned int precision = get_binary_precision (x, y);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
>
> if (wi::fits_shwi_p (yi))
> {
>
> if ((__builtin_constant_p (yi.val[0] == 0) && (yi.val[0] == 0)))
> return neg_p (xi);
>
> if (wi::fits_shwi_p (xi))
> return xi.to_shwi () < yi.to_shwi ();
>
>
> if (neg_p (xi))
> return true;
>
>
> return false;
> }
>
> if ((__builtin_constant_p (xi.len == 1) && (xi.len == 1)))
>
>
> return !neg_p (yi);
> return lts_p_large (xi.val, xi.len, precision, yi.val, yi.len);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::ltu_p (const T1 &x, const T2 &y)
>{
> unsigned int precision = get_binary_precision (x, y);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
>
> if ((__builtin_constant_p (yi.len == 1 && yi.val[0] >= 0) && (yi.len == 1 && yi.val[0] >= 0)))
> return xi.len == 1 && xi.to_uhwi () < (unsigned long) yi.val[0];
> if ((__builtin_constant_p (xi.len == 1 && xi.val[0] >= 0) && (xi.len == 1 && xi.val[0] >= 0)))
> return yi.len != 1 || yi.to_uhwi () > (unsigned long) xi.val[0];
>
>
>
> if (__builtin_expect (xi.len + yi.len == 2, true))
> {
> unsigned long xl = xi.to_uhwi ();
> unsigned long yl = yi.to_uhwi ();
> return xl < yl;
> }
> return ltu_p_large (xi.val, xi.len, precision, yi.val, yi.len);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::lt_p (const T1 &x, const T2 &y, signop sgn)
>{
> if (sgn == SIGNED)
> return lts_p (x, y);
> else
> return ltu_p (x, y);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::les_p (const T1 &x, const T2 &y)
>{
> return !lts_p (y, x);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::leu_p (const T1 &x, const T2 &y)
>{
> return !ltu_p (y, x);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::le_p (const T1 &x, const T2 &y, signop sgn)
>{
> if (sgn == SIGNED)
> return les_p (x, y);
> else
> return leu_p (x, y);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::gts_p (const T1 &x, const T2 &y)
>{
> return lts_p (y, x);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::gtu_p (const T1 &x, const T2 &y)
>{
> return ltu_p (y, x);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::gt_p (const T1 &x, const T2 &y, signop sgn)
>{
> if (sgn == SIGNED)
> return gts_p (x, y);
> else
> return gtu_p (x, y);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::ges_p (const T1 &x, const T2 &y)
>{
> return !lts_p (x, y);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::geu_p (const T1 &x, const T2 &y)
>{
> return !ltu_p (x, y);
>}
>
>
>template <typename T1, typename T2>
>inline bool
>wi::ge_p (const T1 &x, const T2 &y, signop sgn)
>{
> if (sgn == SIGNED)
> return ges_p (x, y);
> else
> return geu_p (x, y);
>}
>
>
>
>template <typename T1, typename T2>
>inline int
>wi::cmps (const T1 &x, const T2 &y)
>{
> unsigned int precision = get_binary_precision (x, y);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> if (wi::fits_shwi_p (yi))
> {
>
> if ((__builtin_constant_p (yi.val[0] == 0) && (yi.val[0] == 0)))
> return neg_p (xi) ? -1 : !(xi.len == 1 && xi.val[0] == 0);
>
> if (wi::fits_shwi_p (xi))
> {
> long xl = xi.to_shwi ();
> long yl = yi.to_shwi ();
> return xl < yl ? -1 : xl > yl;
> }
>
>
> if (neg_p (xi))
> return -1;
>
>
> return 1;
> }
>
> if ((__builtin_constant_p (xi.len == 1) && (xi.len == 1)))
>
>
> return neg_p (yi) ? 1 : -1;
> return cmps_large (xi.val, xi.len, precision, yi.val, yi.len);
>}
>
>
>
>template <typename T1, typename T2>
>inline int
>wi::cmpu (const T1 &x, const T2 &y)
>{
> unsigned int precision = get_binary_precision (x, y);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
>
> if ((__builtin_constant_p (yi.len == 1 && yi.val[0] >= 0) && (yi.len == 1 && yi.val[0] >= 0)))
> {
>
> if (xi.len != 1)
> return 1;
>
> unsigned long xl = xi.to_uhwi ();
> unsigned long yl = yi.val[0];
> return xl < yl ? -1 : xl > yl;
> }
> if ((__builtin_constant_p (xi.len == 1 && xi.val[0] >= 0) && (xi.len == 1 && xi.val[0] >= 0)))
> {
>
> if (yi.len != 1)
> return -1;
>
> unsigned long xl = xi.val[0];
> unsigned long yl = yi.to_uhwi ();
> return xl < yl ? -1 : xl > yl;
> }
>
>
>
> if (__builtin_expect (xi.len + yi.len == 2, true))
> {
> unsigned long xl = xi.to_uhwi ();
> unsigned long yl = yi.to_uhwi ();
> return xl < yl ? -1 : xl > yl;
> }
> return cmpu_large (xi.val, xi.len, precision, yi.val, yi.len);
>}
>
>
>
>template <typename T1, typename T2>
>inline int
>wi::cmp (const T1 &x, const T2 &y, signop sgn)
>{
> if (sgn == SIGNED)
> return cmps (x, y);
> else
> return cmpu (x, y);
>}
>
>
>template <typename T>
>inline typename wi::binary_traits <T, T>::result_type
>wi::bit_not (const T &x)
>{
> typename wi::binary_traits <T, T>::result_type result = wi::int_traits <typename wi::binary_traits <T, T>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, get_precision (result));
> for (unsigned int i = 0; i < xi.len; ++i)
> val[i] = ~xi.val[i];
> result.set_len (xi.len);
> return result;
>}
>
>
>template <typename T>
>inline typename wi::binary_traits <T, T>::result_type
>wi::neg (const T &x)
>{
> return sub (0, x);
>}
>
>
>
>template <typename T>
>inline typename wi::binary_traits <T, T>::result_type
>wi::neg (const T &x, overflow_type *overflow)
>{
> *overflow = only_sign_bit_p (x) ? OVF_OVERFLOW : OVF_NONE;
> return sub (0, x);
>}
>
>
>template <typename T>
>inline typename wi::binary_traits <T, T>::result_type
>wi::abs (const T &x)
>{
> return neg_p (x) ? neg (x) : typename wi::binary_traits <T, T>::result_type (x);
>}
>
>
>template <typename T>
>inline typename wi::binary_traits <T, T>::result_type
>wi::sext (const T &x, unsigned int offset)
>{
> typename wi::binary_traits <T, T>::result_type result = wi::int_traits <typename wi::binary_traits <T, T>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, precision);
>
> if (offset <= 64)
> {
> val[0] = sext_hwi (xi.ulow (), offset);
> result.set_len (1, true);
> }
> else
> result.set_len (sext_large (val, xi.val, xi.len, precision, offset));
> return result;
>}
>
>
>template <typename T>
>inline typename wi::binary_traits <T, T>::result_type
>wi::zext (const T &x, unsigned int offset)
>{
> typename wi::binary_traits <T, T>::result_type result = wi::int_traits <typename wi::binary_traits <T, T>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, precision);
>
>
>
> if (offset >= precision)
> {
> wi::copy (result, xi);
> return result;
> }
>
>
>
> if (offset < 64)
> {
> val[0] = zext_hwi (xi.ulow (), offset);
> result.set_len (1, true);
> }
> else
> result.set_len (zext_large (val, xi.val, xi.len, precision, offset), true);
> return result;
>}
>
>
>
>template <typename T>
>inline typename wi::binary_traits <T, T>::result_type
>wi::ext (const T &x, unsigned int offset, signop sgn)
>{
> return sgn == SIGNED ? sext (x, offset) : zext (x, offset);
>}
>
>
>template <typename T>
>inline typename wi::binary_traits <T, T>::result_type
>wi::set_bit (const T &x, unsigned int bit)
>{
> typename wi::binary_traits <T, T>::result_type result = wi::int_traits <typename wi::binary_traits <T, T>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, precision);
> if (precision <= 64)
> {
> val[0] = xi.ulow () | (1UL << bit);
> result.set_len (1);
> }
> else
> result.set_len (set_bit_large (val, xi.val, xi.len, precision, bit));
> return result;
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::min (const T1 &x, const T2 &y, signop sgn)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val __attribute__ ((__unused__)) = result.write_val ();
> unsigned int precision = get_precision (result);
> if (wi::le_p (x, y, sgn))
> wi::copy (result, generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > (x, precision));
> else
> wi::copy (result, generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > (y, precision));
> return result;
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::smin (const T1 &x, const T2 &y)
>{
> return wi::min (x, y, SIGNED);
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::umin (const T1 &x, const T2 &y)
>{
> return wi::min (x, y, UNSIGNED);
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::max (const T1 &x, const T2 &y, signop sgn)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val __attribute__ ((__unused__)) = result.write_val ();
> unsigned int precision = get_precision (result);
> if (wi::ge_p (x, y, sgn))
> wi::copy (result, generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > (x, precision));
> else
> wi::copy (result, generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > (y, precision));
> return result;
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::smax (const T1 &x, const T2 &y)
>{
> return wi::max (x, y, SIGNED);
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::umax (const T1 &x, const T2 &y)
>{
> return wi::max (x, y, UNSIGNED);
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::bit_and (const T1 &x, const T2 &y)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
> if (__builtin_expect (xi.len + yi.len == 2, true))
> {
> val[0] = xi.ulow () & yi.ulow ();
> result.set_len (1, is_sign_extended);
> }
> else
> result.set_len (and_large (val, xi.val, xi.len, yi.val, yi.len,
> precision), is_sign_extended);
> return result;
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::bit_and_not (const T1 &x, const T2 &y)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
> if (__builtin_expect (xi.len + yi.len == 2, true))
> {
> val[0] = xi.ulow () & ~yi.ulow ();
> result.set_len (1, is_sign_extended);
> }
> else
> result.set_len (and_not_large (val, xi.val, xi.len, yi.val, yi.len,
> precision), is_sign_extended);
> return result;
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::bit_or (const T1 &x, const T2 &y)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
> if (__builtin_expect (xi.len + yi.len == 2, true))
> {
> val[0] = xi.ulow () | yi.ulow ();
> result.set_len (1, is_sign_extended);
> }
> else
> result.set_len (or_large (val, xi.val, xi.len,
> yi.val, yi.len, precision), is_sign_extended);
> return result;
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::bit_or_not (const T1 &x, const T2 &y)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
> if (__builtin_expect (xi.len + yi.len == 2, true))
> {
> val[0] = xi.ulow () | ~yi.ulow ();
> result.set_len (1, is_sign_extended);
> }
> else
> result.set_len (or_not_large (val, xi.val, xi.len, yi.val, yi.len,
> precision), is_sign_extended);
> return result;
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::bit_xor (const T1 &x, const T2 &y)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
> if (__builtin_expect (xi.len + yi.len == 2, true))
> {
> val[0] = xi.ulow () ^ yi.ulow ();
> result.set_len (1, is_sign_extended);
> }
> else
> result.set_len (xor_large (val, xi.val, xi.len,
> yi.val, yi.len, precision), is_sign_extended);
> return result;
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::add (const T1 &x, const T2 &y)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> if (precision <= 64)
> {
> val[0] = xi.ulow () + yi.ulow ();
> result.set_len (1);
> }
># 2441 "../../gcc/wide-int.h"
> else if ((__builtin_constant_p (precision > 64) && (precision > 64))
> && __builtin_expect (xi.len + yi.len == 2, true))
> {
> unsigned long xl = xi.ulow ();
> unsigned long yl = yi.ulow ();
> unsigned long resultl = xl + yl;
> val[0] = resultl;
> val[1] = (long) resultl < 0 ? 0 : -1;
> result.set_len (1 + (((resultl ^ xl) & (resultl ^ yl))
> >> (64 - 1)));
> }
> else
> result.set_len (add_large (val, xi.val, xi.len,
> yi.val, yi.len, precision,
> UNSIGNED, 0));
> return result;
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::add (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> if (precision <= 64)
> {
> unsigned long xl = xi.ulow ();
> unsigned long yl = yi.ulow ();
> unsigned long resultl = xl + yl;
> if (sgn == SIGNED)
> {
> if ((((resultl ^ xl) & (resultl ^ yl))
> >> (precision - 1)) & 1)
> {
> if (xl > resultl)
> *overflow = OVF_UNDERFLOW;
> else if (xl < resultl)
> *overflow = OVF_OVERFLOW;
> else
> *overflow = OVF_NONE;
> }
> else
> *overflow = OVF_NONE;
> }
> else
> *overflow = ((resultl << (64 - precision))
> < (xl << (64 - precision)))
> ? OVF_OVERFLOW : OVF_NONE;
> val[0] = resultl;
> result.set_len (1);
> }
> else
> result.set_len (add_large (val, xi.val, xi.len,
> yi.val, yi.len, precision,
> sgn, overflow));
> return result;
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::sub (const T1 &x, const T2 &y)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> if (precision <= 64)
> {
> val[0] = xi.ulow () - yi.ulow ();
> result.set_len (1);
> }
># 2527 "../../gcc/wide-int.h"
> else if ((__builtin_constant_p (precision > 64) && (precision > 64))
> && __builtin_expect (xi.len + yi.len == 2, true))
> {
> unsigned long xl = xi.ulow ();
> unsigned long yl = yi.ulow ();
> unsigned long resultl = xl - yl;
> val[0] = resultl;
> val[1] = (long) resultl < 0 ? 0 : -1;
> result.set_len (1 + (((resultl ^ xl) & (xl ^ yl))
> >> (64 - 1)));
> }
> else
> result.set_len (sub_large (val, xi.val, xi.len,
> yi.val, yi.len, precision,
> UNSIGNED, 0));
> return result;
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::sub (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> if (precision <= 64)
> {
> unsigned long xl = xi.ulow ();
> unsigned long yl = yi.ulow ();
> unsigned long resultl = xl - yl;
> if (sgn == SIGNED)
> {
> if ((((xl ^ yl) & (resultl ^ xl)) >> (precision - 1)) & 1)
> {
> if (xl > yl)
> *overflow = OVF_UNDERFLOW;
> else if (xl < yl)
> *overflow = OVF_OVERFLOW;
> else
> *overflow = OVF_NONE;
> }
> else
> *overflow = OVF_NONE;
> }
> else
> *overflow = ((resultl << (64 - precision))
> > (xl << (64 - precision)))
> ? OVF_UNDERFLOW : OVF_NONE;
> val[0] = resultl;
> result.set_len (1);
> }
> else
> result.set_len (sub_large (val, xi.val, xi.len,
> yi.val, yi.len, precision,
> sgn, overflow));
> return result;
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::mul (const T1 &x, const T2 &y)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> if (precision <= 64)
> {
> val[0] = xi.ulow () * yi.ulow ();
> result.set_len (1);
> }
> else
> result.set_len (mul_internal (val, xi.val, xi.len, yi.val, yi.len,
> precision, UNSIGNED, 0, false));
> return result;
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::mul (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> result.set_len (mul_internal (val, xi.val, xi.len,
> yi.val, yi.len, precision,
> sgn, overflow, false));
> return result;
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::smul (const T1 &x, const T2 &y, overflow_type *overflow)
>{
> return mul (x, y, SIGNED, overflow);
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::umul (const T1 &x, const T2 &y, overflow_type *overflow)
>{
> return mul (x, y, UNSIGNED, overflow);
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::mul_high (const T1 &x, const T2 &y, signop sgn)
>{
> typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
> result.set_len (mul_internal (val, xi.val, xi.len,
> yi.val, yi.len, precision,
> sgn, 0, true));
> return result;
>}
>
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::div_trunc (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
>{
> typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
> unsigned int precision = get_precision (quotient);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
>
> quotient.set_len (divmod_internal (quotient_val, 0, 0, xi.val, xi.len,
> precision,
> yi.val, yi.len, yi.precision,
> sgn, overflow));
> return quotient;
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::sdiv_trunc (const T1 &x, const T2 &y)
>{
> return div_trunc (x, y, SIGNED);
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::udiv_trunc (const T1 &x, const T2 &y)
>{
> return div_trunc (x, y, UNSIGNED);
>}
>
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::div_floor (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
>{
> typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
> typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
> unsigned int precision = get_precision (quotient);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
>
> unsigned int remainder_len;
> quotient.set_len (divmod_internal (quotient_val,
> &remainder_len, remainder_val,
> xi.val, xi.len, precision,
> yi.val, yi.len, yi.precision, sgn,
> overflow));
> remainder.set_len (remainder_len);
> if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn) && remainder != 0)
> return quotient - 1;
> return quotient;
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::sdiv_floor (const T1 &x, const T2 &y)
>{
> return div_floor (x, y, SIGNED);
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::udiv_floor (const T1 &x, const T2 &y)
>{
> return div_floor (x, y, UNSIGNED);
>}
>
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::div_ceil (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
>{
> typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
> typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
> unsigned int precision = get_precision (quotient);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
>
> unsigned int remainder_len;
> quotient.set_len (divmod_internal (quotient_val,
> &remainder_len, remainder_val,
> xi.val, xi.len, precision,
> yi.val, yi.len, yi.precision, sgn,
> overflow));
> remainder.set_len (remainder_len);
> if (wi::neg_p (x, sgn) == wi::neg_p (y, sgn) && remainder != 0)
> return quotient + 1;
> return quotient;
>}
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::udiv_ceil (const T1 &x, const T2 &y)
>{
> return div_ceil (x, y, UNSIGNED);
>}
>
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::div_round (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
>{
> typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
> typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
> unsigned int precision = get_precision (quotient);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
>
> unsigned int remainder_len;
> quotient.set_len (divmod_internal (quotient_val,
> &remainder_len, remainder_val,
> xi.val, xi.len, precision,
> yi.val, yi.len, yi.precision, sgn,
> overflow));
> remainder.set_len (remainder_len);
>
> if (remainder != 0)
> {
> if (sgn == SIGNED)
> {
> typename wi::binary_traits <T1, T2>::result_type abs_remainder = wi::abs (remainder);
> if (wi::geu_p (abs_remainder, wi::sub (wi::abs (y), abs_remainder)))
> {
> if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn))
> return quotient - 1;
> else
> return quotient + 1;
> }
> }
> else
> {
> if (wi::geu_p (remainder, wi::sub (y, remainder)))
> return quotient + 1;
> }
> }
> return quotient;
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::divmod_trunc (const T1 &x, const T2 &y, signop sgn,
> typename wi::binary_traits <T1, T2>::result_type *remainder_ptr)
>{
> typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
> typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
> unsigned int precision = get_precision (quotient);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
>
> unsigned int remainder_len;
> quotient.set_len (divmod_internal (quotient_val,
> &remainder_len, remainder_val,
> xi.val, xi.len, precision,
> yi.val, yi.len, yi.precision, sgn, 0));
> remainder.set_len (remainder_len);
>
> *remainder_ptr = remainder;
> return quotient;
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::gcd (const T1 &a, const T2 &b, signop sgn)
>{
> T1 x, y, z;
>
> x = wi::abs (a);
> y = wi::abs (b);
>
> while (gt_p (x, 0, sgn))
> {
> z = mod_trunc (y, x, sgn);
> y = x;
> x = z;
> }
>
> return y;
>}
>
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::mod_trunc (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
>{
> typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
> unsigned int precision = get_precision (remainder);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
>
> unsigned int remainder_len;
> divmod_internal (0, &remainder_len, remainder_val,
> xi.val, xi.len, precision,
> yi.val, yi.len, yi.precision, sgn, overflow);
> remainder.set_len (remainder_len);
>
> return remainder;
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::smod_trunc (const T1 &x, const T2 &y)
>{
> return mod_trunc (x, y, SIGNED);
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::umod_trunc (const T1 &x, const T2 &y)
>{
> return mod_trunc (x, y, UNSIGNED);
>}
>
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::mod_floor (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
>{
> typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
> typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
> unsigned int precision = get_precision (quotient);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
>
> unsigned int remainder_len;
> quotient.set_len (divmod_internal (quotient_val,
> &remainder_len, remainder_val,
> xi.val, xi.len, precision,
> yi.val, yi.len, yi.precision, sgn,
> overflow));
> remainder.set_len (remainder_len);
>
> if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn) && remainder != 0)
> return remainder + y;
> return remainder;
>}
>
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::umod_floor (const T1 &x, const T2 &y)
>{
> return mod_floor (x, y, UNSIGNED);
>}
>
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::mod_ceil (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
>{
> typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
> typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
> unsigned int precision = get_precision (quotient);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
>
> unsigned int remainder_len;
> quotient.set_len (divmod_internal (quotient_val,
> &remainder_len, remainder_val,
> xi.val, xi.len, precision,
> yi.val, yi.len, yi.precision, sgn,
> overflow));
> remainder.set_len (remainder_len);
>
> if (wi::neg_p (x, sgn) == wi::neg_p (y, sgn) && remainder != 0)
> return remainder - y;
> return remainder;
>}
>
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::result_type
>wi::mod_round (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
>{
> typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
> typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
> unsigned int precision = get_precision (quotient);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
>
> unsigned int remainder_len;
> quotient.set_len (divmod_internal (quotient_val,
> &remainder_len, remainder_val,
> xi.val, xi.len, precision,
> yi.val, yi.len, yi.precision, sgn,
> overflow));
> remainder.set_len (remainder_len);
>
> if (remainder != 0)
> {
> if (sgn == SIGNED)
> {
> typename wi::binary_traits <T1, T2>::result_type abs_remainder = wi::abs (remainder);
> if (wi::geu_p (abs_remainder, wi::sub (wi::abs (y), abs_remainder)))
> {
> if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn))
> return remainder + y;
> else
> return remainder - y;
> }
> }
> else
> {
> if (wi::geu_p (remainder, wi::sub (y, remainder)))
> return remainder - y;
> }
> }
> return remainder;
>}
>
>
>
>template <typename T1, typename T2>
>inline bool
>wi::multiple_of_p (const T1 &x, const T2 &y, signop sgn)
>{
> return wi::mod_trunc (x, y, sgn) == 0;
>}
>
>
>
>template <typename T1, typename T2>
>inline bool
>wi::multiple_of_p (const T1 &x, const T2 &y, signop sgn,
> typename wi::binary_traits <T1, T2>::result_type *res)
>{
> typename wi::binary_traits <T1, T2>::result_type remainder;
> typename wi::binary_traits <T1, T2>::result_type quotient
> = divmod_trunc (x, y, sgn, &remainder);
> if (remainder == 0)
> {
> *res = quotient;
> return true;
> }
> return false;
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T1>::result_type
>wi::lshift (const T1 &x, const T2 &y)
>{
> typename wi::binary_traits <T1, T1>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T1>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
> unsigned int precision = get_precision (result);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
>
> if (geu_p (yi, precision))
> {
> val[0] = 0;
> result.set_len (1);
> }
> else
> {
> unsigned int shift = yi.to_uhwi ();
># 3054 "../../gcc/wide-int.h"
> if ((__builtin_constant_p (xi.precision > 64) && (xi.precision > 64))
> ? ((__builtin_constant_p (shift < 64 - 1) && (shift < 64 - 1))
> && xi.len == 1
> && ((unsigned long) (xi.val[0]) - (unsigned long) (0) <= (unsigned long) ((~((long) (1UL << (64 - 1)))) >> shift) - (unsigned long) (0)))
> : precision <= 64)
> {
> val[0] = xi.ulow () << shift;
> result.set_len (1);
> }
> else
> result.set_len (lshift_large (val, xi.val, xi.len,
> precision, shift));
> }
> return result;
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T1>::result_type
>wi::lrshift (const T1 &x, const T2 &y)
>{
> typename wi::binary_traits <T1, T1>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T1>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
>
>
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
>
> if (geu_p (yi, xi.precision))
> {
> val[0] = 0;
> result.set_len (1);
> }
> else
> {
> unsigned int shift = yi.to_uhwi ();
># 3098 "../../gcc/wide-int.h"
> if ((__builtin_constant_p (xi.precision > 64) && (xi.precision > 64))
> ? (shift < 64
> && xi.len == 1
> && xi.val[0] >= 0)
> : xi.precision <= 64)
> {
> val[0] = xi.to_uhwi () >> shift;
> result.set_len (1);
> }
> else
> result.set_len (lrshift_large (val, xi.val, xi.len, xi.precision,
> get_precision (result), shift));
> }
> return result;
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T1>::result_type
>wi::arshift (const T1 &x, const T2 &y)
>{
> typename wi::binary_traits <T1, T1>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T1>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
>
>
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x);
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
>
> if (geu_p (yi, xi.precision))
> {
> val[0] = sign_mask (x);
> result.set_len (1);
> }
> else
> {
> unsigned int shift = yi.to_uhwi ();
> if (xi.precision <= 64)
> {
> val[0] = sext_hwi (xi.ulow () >> shift, xi.precision - shift);
> result.set_len (1, true);
> }
> else
> result.set_len (arshift_large (val, xi.val, xi.len, xi.precision,
> get_precision (result), shift));
> }
> return result;
>}
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T1>::result_type
>wi::rshift (const T1 &x, const T2 &y, signop sgn)
>{
> if (sgn == UNSIGNED)
> return lrshift (x, y);
> else
> return arshift (x, y);
>}
>
>
>
>
>template <typename T1, typename T2>
>typename wi::binary_traits <T1, T1>::result_type
>wi::lrotate (const T1 &x, const T2 &y, unsigned int width)
>{
> unsigned int precision = get_binary_precision (x, x);
> if (width == 0)
> width = precision;
> typename wi::binary_traits <T2, T2>::result_type ymod = umod_trunc (y, width);
> typename wi::binary_traits <T1, T1>::result_type left = wi::lshift (x, ymod);
> typename wi::binary_traits <T1, T1>::result_type right = wi::lrshift (x, wi::sub (width, ymod));
> if (width != precision)
> return wi::zext (left, width) | wi::zext (right, width);
> return left | right;
>}
>
>
>
>
>template <typename T1, typename T2>
>typename wi::binary_traits <T1, T1>::result_type
>wi::rrotate (const T1 &x, const T2 &y, unsigned int width)
>{
> unsigned int precision = get_binary_precision (x, x);
> if (width == 0)
> width = precision;
> typename wi::binary_traits <T2, T2>::result_type ymod = umod_trunc (y, width);
> typename wi::binary_traits <T1, T1>::result_type right = wi::lrshift (x, ymod);
> typename wi::binary_traits <T1, T1>::result_type left = wi::lshift (x, wi::sub (width, ymod));
> if (width != precision)
> return wi::zext (left, width) | wi::zext (right, width);
> return left | right;
>}
>
>
>
>inline int
>wi::parity (const wide_int_ref &x)
>{
> return popcount (x) & 1;
>}
>
>
>template <typename T>
>inline unsigned long
>wi::extract_uhwi (const T &x, unsigned int bitpos, unsigned int width)
>{
> unsigned precision = get_precision (x);
> if (precision < bitpos + width)
> precision = bitpos + width;
> generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, precision);
>
>
>
> if (width == 0)
> return 0;
>
> unsigned int start = bitpos / 64;
> unsigned int shift = bitpos % 64;
> unsigned long res = xi.elt (start);
> res >>= shift;
> if (shift + width > 64)
> {
> unsigned long upper = xi.elt (start + 1);
> res |= upper << (-shift % 64);
> }
> return zext_hwi (res, width);
>}
>
>
>template <typename T>
>inline unsigned int
>wi::min_precision (const T &x, signop sgn)
>{
> if (sgn == SIGNED)
> return get_precision (x) - clrsb (x);
> else
> return get_precision (x) - clz (x);
>}
># 3248 "../../gcc/wide-int.h"
>template <typename T1, typename T2> inline typename wi::binary_traits <T1, T2>::signed_predicate_result operator < (const T1 &x, const T2 &y) { return wi::lts_p (x, y); }
>template <typename T1, typename T2> inline typename wi::binary_traits <T1, T2>::signed_predicate_result operator <= (const T1 &x, const T2 &y) { return wi::les_p (x, y); }
>template <typename T1, typename T2> inline typename wi::binary_traits <T1, T2>::signed_predicate_result operator > (const T1 &x, const T2 &y) { return wi::gts_p (x, y); }
>template <typename T1, typename T2> inline typename wi::binary_traits <T1, T2>::signed_predicate_result operator >= (const T1 &x, const T2 &y) { return wi::ges_p (x, y); }
># 3287 "../../gcc/wide-int.h"
>template<typename T> typename wi::binary_traits <generic_wide_int<T>, generic_wide_int<T> >::result_type operator ~ (const generic_wide_int<T> &x) { return wi::bit_not (x); }
>template<typename T> typename wi::binary_traits <generic_wide_int<T>, generic_wide_int<T> >::result_type operator - (const generic_wide_int<T> &x) { return wi::neg (x); }
>template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::predicate_result operator == (const T1 &x, const T2 &y) { return wi::eq_p (x, y); }
>template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::predicate_result operator != (const T1 &x, const T2 &y) { return wi::ne_p (x, y); }
>template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator & (const T1 &x, const T2 &y) { return wi::bit_and (x, y); }
>template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator | (const T1 &x, const T2 &y) { return wi::bit_or (x, y); }
>template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator ^ (const T1 &x, const T2 &y) { return wi::bit_xor (x, y); }
>template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator + (const T1 &x, const T2 &y) { return wi::add (x, y); }
>template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator - (const T1 &x, const T2 &y) { return wi::sub (x, y); }
>template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator * (const T1 &x, const T2 &y) { return wi::mul (x, y); }
>template<typename T1, typename T2> typename wi::binary_traits <T1, T1>::operator_result operator << (const T1 &x, const T2 &y) { return wi::lshift (x, y); }
>
>
>
>
>
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::signed_shift_result_type
>operator >> (const T1 &x, const T2 &y)
>{
> return wi::arshift (x, y);
>}
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::signed_shift_result_type
>operator / (const T1 &x, const T2 &y)
>{
> return wi::sdiv_trunc (x, y);
>}
>
>template <typename T1, typename T2>
>inline typename wi::binary_traits <T1, T2>::signed_shift_result_type
>operator % (const T1 &x, const T2 &y)
>{
> return wi::smod_trunc (x, y);
>}
>
>template<typename T>
>void
>gt_ggc_mx (generic_wide_int <T> *)
>{
>}
>
>template<typename T>
>void
>gt_pch_nx (generic_wide_int <T> *)
>{
>}
>
>template<typename T>
>void
>gt_pch_nx (generic_wide_int <T> *, void (*) (void *, void *), void *)
>{
>}
>
>template<int N>
>void
>gt_ggc_mx (trailing_wide_ints <N> *)
>{
>}
>
>template<int N>
>void
>gt_pch_nx (trailing_wide_ints <N> *)
>{
>}
>
>template<int N>
>void
>gt_pch_nx (trailing_wide_ints <N> *, void (*) (void *, void *), void *)
>{
>}
>
>namespace wi
>{
>
>
>
> struct never_used1 {};
> struct never_used2 {};
>
> wide_int min_value (unsigned int, signop);
> wide_int min_value (never_used1 *);
> wide_int min_value (never_used2 *);
> wide_int max_value (unsigned int, signop);
> wide_int max_value (never_used1 *);
> wide_int max_value (never_used2 *);
>
>
>
> wide_int from_buffer (const unsigned char *, unsigned int);
>
>
>
>
>
> wide_int mask (unsigned int, bool, unsigned int);
> wide_int shifted_mask (unsigned int, unsigned int, bool, unsigned int);
> wide_int set_bit_in_zero (unsigned int, unsigned int);
> wide_int insert (const wide_int &x, const wide_int &y, unsigned int,
> unsigned int);
> wide_int round_down_for_mask (const wide_int &, const wide_int &);
> wide_int round_up_for_mask (const wide_int &, const wide_int &);
>
> template <typename T>
> T mask (unsigned int, bool);
>
> template <typename T>
> T shifted_mask (unsigned int, unsigned int, bool);
>
> template <typename T>
> T set_bit_in_zero (unsigned int);
>
> unsigned int mask (long *, unsigned int, bool, unsigned int);
> unsigned int shifted_mask (long *, unsigned int, unsigned int,
> bool, unsigned int);
> unsigned int from_array (long *, const long *,
> unsigned int, unsigned int, bool);
>}
>
>
>
>inline wide_int
>wi::mask (unsigned int width, bool negate_p, unsigned int precision)
>{
> wide_int result = wide_int::create (precision);
> result.set_len (mask (result.write_val (), width, negate_p, precision));
> return result;
>}
>
>
>
>
>inline wide_int
>wi::shifted_mask (unsigned int start, unsigned int width, bool negate_p,
> unsigned int precision)
>{
> wide_int result = wide_int::create (precision);
> result.set_len (shifted_mask (result.write_val (), start, width, negate_p,
> precision));
> return result;
>}
>
>
>
>inline wide_int
>wi::set_bit_in_zero (unsigned int bit, unsigned int precision)
>{
> return shifted_mask (bit, 1, false, precision);
>}
>
>
>
>template <typename T>
>inline T
>wi::mask (unsigned int width, bool negate_p)
>{
> static_assert ((wi::int_traits<T>::precision), "wi::int_traits<T>::precision");
> T result;
> result.set_len (mask (result.write_val (), width, negate_p,
> wi::int_traits <T>::precision));
> return result;
>}
>
>
>
>
>template <typename T>
>inline T
>wi::shifted_mask (unsigned int start, unsigned int width, bool negate_p)
>{
> static_assert ((wi::int_traits<T>::precision), "wi::int_traits<T>::precision");
> T result;
> result.set_len (shifted_mask (result.write_val (), start, width,
> negate_p,
> wi::int_traits <T>::precision));
> return result;
>}
>
>
>
>template <typename T>
>inline T
>wi::set_bit_in_zero (unsigned int bit)
>{
> return shifted_mask <T> (bit, 1, false);
>}
>
>
>
>static inline void
>wi::accumulate_overflow (wi::overflow_type &overflow,
> wi::overflow_type suboverflow)
>{
> if (!suboverflow)
> return;
> if (!overflow)
> overflow = suboverflow;
> else if (overflow != suboverflow)
> overflow = wi::OVF_UNKNOWN;
>}
># 435 "../../gcc/coretypes.h" 2
># 1 "../../gcc/wide-int-print.h" 1
># 29 "../../gcc/wide-int-print.h"
>extern void print_dec (const wide_int_ref &wi, char *buf, signop sgn);
>extern void print_dec (const wide_int_ref &wi, FILE *file, signop sgn);
>extern void print_decs (const wide_int_ref &wi, char *buf);
>extern void print_decs (const wide_int_ref &wi, FILE *file);
>extern void print_decu (const wide_int_ref &wi, char *buf);
>extern void print_decu (const wide_int_ref &wi, FILE *file);
>extern void print_hex (const wide_int_ref &wi, char *buf);
>extern void print_hex (const wide_int_ref &wi, FILE *file);
># 436 "../../gcc/coretypes.h" 2
># 449 "../../gcc/coretypes.h"
># 1 "../../gcc/poly-int.h" 1
># 32 "../../gcc/poly-int.h"
>template<unsigned int N, typename T> struct poly_int_pod;
>template<unsigned int N, typename T> class poly_int;
># 62 "../../gcc/poly-int.h"
>template<typename T, wi::precision_type = wi::int_traits<T>::precision_type>
>struct poly_coeff_traits;
>
>template<typename T>
>struct poly_coeff_traits<T, wi::FLEXIBLE_PRECISION>
>{
> typedef T result;
> typedef T int_type;
> static const int signedness = (T (0) >= T (-1));
> static const int precision = sizeof (T) * 8;
> static const T max_value = (signedness
> ? ((T (1) << (precision - 2))
> + ((T (1) << (precision - 2)) - 1))
> : T (-1));
> static const int rank = sizeof (T) * 2 + !signedness;
>};
>
>template<typename T>
>struct poly_coeff_traits<T, wi::VAR_PRECISION>
>{
> typedef T result;
> typedef int int_type;
> static const int signedness = -1;
> static const int precision = (((160 + 64) / 64) * 64);
> static const int rank = 0x7fffffff;
>};
>
>template<typename T>
>struct poly_coeff_traits<T, wi::CONST_PRECISION>
>{
> typedef typename wi::binary_traits <T, T>::result_type result;
> typedef int int_type;
>
> static const int signedness = 1;
> static const int precision = wi::int_traits<T>::precision;
> static const int rank = precision * 2 / 8;
>};
>
>
>template<typename T1, typename T2>
>struct poly_coeff_pair_traits
>{
># 118 "../../gcc/poly-int.h"
> static const bool lossless_p = (poly_coeff_traits<T1>::signedness
> == poly_coeff_traits<T2>::signedness
> ? (poly_coeff_traits<T1>::precision
> >= poly_coeff_traits<T2>::precision)
> : (poly_coeff_traits<T1>::signedness == 1
> && poly_coeff_traits<T2>::signedness == 0
> && (poly_coeff_traits<T1>::precision
> > poly_coeff_traits<T2>::precision)));
>
>
>
>
>
> static const int result_kind
> = ((poly_coeff_traits<T1>::rank <= poly_coeff_traits<long>::rank
> && poly_coeff_traits<T2>::rank <= poly_coeff_traits<long>::rank)
> ? 0
> : (poly_coeff_traits<T1>::rank <= poly_coeff_traits<unsigned long>::rank
> && poly_coeff_traits<T2>::rank <= poly_coeff_traits<unsigned long>::rank)
> ? 1 : 2);
>
>};
>
>
>
>template<typename T1, typename T2, typename T3,
> bool lossless_p = poly_coeff_pair_traits<T1, T2>::lossless_p>
>struct if_lossless;
>template<typename T1, typename T2, typename T3>
>struct if_lossless<T1, T2, T3, true>
>{
> typedef T3 type;
>};
># 166 "../../gcc/poly-int.h"
>template<typename T>
>struct poly_int_traits
>{
> static const bool is_poly = false;
> static const unsigned int num_coeffs = 1;
> typedef T coeff_type;
> typedef typename poly_coeff_traits<T>::int_type int_type;
>};
>template<unsigned int N, typename C>
>struct poly_int_traits<poly_int_pod<N, C> >
>{
> static const bool is_poly = true;
> static const unsigned int num_coeffs = N;
> typedef C coeff_type;
> typedef typename poly_coeff_traits<C>::int_type int_type;
>};
>template<unsigned int N, typename C>
>struct poly_int_traits<poly_int<N, C> > : poly_int_traits<poly_int_pod<N, C> >
>{
>};
>
>
>
>template<typename T1, typename T2 = T1,
> bool is_poly = poly_int_traits<T1>::is_poly>
>struct if_nonpoly {};
>template<typename T1, typename T2>
>struct if_nonpoly<T1, T2, false>
>{
> typedef T2 type;
>};
>
>
>
>template<typename T1, typename T2, typename T3,
> bool is_poly1 = poly_int_traits<T1>::is_poly,
> bool is_poly2 = poly_int_traits<T2>::is_poly>
>struct if_nonpoly2 {};
>template<typename T1, typename T2, typename T3>
>struct if_nonpoly2<T1, T2, T3, false, false>
>{
> typedef T3 type;
>};
>
>
>
>template<typename T1, typename T2 = T1,
> bool is_poly = poly_int_traits<T1>::is_poly>
>struct if_poly {};
>template<typename T1, typename T2>
>struct if_poly<T1, T2, true>
>{
> typedef T2 type;
>};
># 234 "../../gcc/poly-int.h"
>template<typename T1, typename T2 = T1,
> int result_kind = poly_coeff_pair_traits<T1, T2>::result_kind>
>struct poly_result;
>
>
>template<typename T1, typename T2>
>struct poly_result<T1, T2, 0>
>{
> typedef long type;
>
>
> typedef type cast;
>};
>
>
>template<typename T1, typename T2>
>struct poly_result<T1, T2, 1>
>{
> typedef unsigned long type;
>
>
> typedef type cast;
>};
>
>
>template<typename T1, typename T2>
>struct poly_result<T1, T2, 2>
>{
> typedef typename wi::binary_traits <T1, T2>::result_type type;
>
>
> typedef const T1 &cast;
>};
># 337 "../../gcc/poly-int.h"
>template<unsigned int N, typename C>
>struct poly_int_pod
>{
>public:
> template<typename Ca>
> poly_int_pod &operator = (const poly_int_pod<N, Ca> &);
> template<typename Ca>
> typename if_nonpoly<Ca, poly_int_pod>::type &operator = (const Ca &);
>
> template<typename Ca>
> poly_int_pod &operator += (const poly_int_pod<N, Ca> &);
> template<typename Ca>
> typename if_nonpoly<Ca, poly_int_pod>::type &operator += (const Ca &);
>
> template<typename Ca>
> poly_int_pod &operator -= (const poly_int_pod<N, Ca> &);
> template<typename Ca>
> typename if_nonpoly<Ca, poly_int_pod>::type &operator -= (const Ca &);
>
> template<typename Ca>
> typename if_nonpoly<Ca, poly_int_pod>::type &operator *= (const Ca &);
>
> poly_int_pod &operator <<= (unsigned int);
>
> bool is_constant () const;
>
> template<typename T>
> typename if_lossless<T, C, bool>::type is_constant (T *) const;
>
> C to_constant () const;
>
> template<typename Ca>
> static poly_int<N, C> from (const poly_int_pod<N, Ca> &, unsigned int,
> signop);
> template<typename Ca>
> static poly_int<N, C> from (const poly_int_pod<N, Ca> &, signop);
>
> bool to_shwi (poly_int_pod<N, long> *) const;
> bool to_uhwi (poly_int_pod<N, unsigned long> *) const;
> poly_int<N, long> force_shwi () const;
> poly_int<N, unsigned long> force_uhwi () const;
>
>
>
>
>
> C coeffs[N];
>};
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline poly_int_pod<N, C>&
>poly_int_pod<N, C>::operator = (const poly_int_pod<N, Ca> &a)
>{
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = a.coeffs[i]) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (a.coeffs[i])));
> return *this;
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline typename if_nonpoly<Ca, poly_int_pod<N, C> >::type &
>poly_int_pod<N, C>::operator = (const Ca &a)
>{
> ((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[0] = a) : (void) ((*this).coeffs[0].~C (), new (&(*this).coeffs[0]) C (a)));
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = wi::ints_for<C>::zero (this->coeffs[0])) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (wi::ints_for<C>::zero (this->coeffs[0]))));
> return *this;
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline poly_int_pod<N, C>&
>poly_int_pod<N, C>::operator += (const poly_int_pod<N, Ca> &a)
>{
> for (unsigned int i = 0; i < N; i++)
> this->coeffs[i] += a.coeffs[i];
> return *this;
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline typename if_nonpoly<Ca, poly_int_pod<N, C> >::type &
>poly_int_pod<N, C>::operator += (const Ca &a)
>{
> this->coeffs[0] += a;
> return *this;
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline poly_int_pod<N, C>&
>poly_int_pod<N, C>::operator -= (const poly_int_pod<N, Ca> &a)
>{
> for (unsigned int i = 0; i < N; i++)
> this->coeffs[i] -= a.coeffs[i];
> return *this;
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline typename if_nonpoly<Ca, poly_int_pod<N, C> >::type &
>poly_int_pod<N, C>::operator -= (const Ca &a)
>{
> this->coeffs[0] -= a;
> return *this;
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline typename if_nonpoly<Ca, poly_int_pod<N, C> >::type &
>poly_int_pod<N, C>::operator *= (const Ca &a)
>{
> for (unsigned int i = 0; i < N; i++)
> this->coeffs[i] *= a;
> return *this;
>}
>
>template<unsigned int N, typename C>
>inline poly_int_pod<N, C>&
>poly_int_pod<N, C>::operator <<= (unsigned int a)
>{
> for (unsigned int i = 0; i < N; i++)
> this->coeffs[i] <<= a;
> return *this;
>}
>
>
>
>template<unsigned int N, typename C>
>inline bool
>poly_int_pod<N, C>::is_constant () const
>{
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (this->coeffs[i] != 0)
> return false;
> return true;
>}
>
>
>
>
>template<unsigned int N, typename C>
>template<typename T>
>inline typename if_lossless<T, C, bool>::type
>poly_int_pod<N, C>::is_constant (T *const_value) const
>{
> if (is_constant ())
> {
> *const_value = this->coeffs[0];
> return true;
> }
> return false;
>}
>
>
>
>
>
>
>
>template<unsigned int N, typename C>
>inline C
>poly_int_pod<N, C>::to_constant () const
>{
> ((void)(!(is_constant ()) ? fancy_abort ("../../gcc/poly-int.h", 504, __FUNCTION__), 0 : 0));
> return this->coeffs[0];
>}
>
>
>
>
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline poly_int<N, C>
>poly_int_pod<N, C>::from (const poly_int_pod<N, Ca> &a,
> unsigned int bitsize, signop sgn)
>{
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = C::from (a.coeffs[i], bitsize, sgn)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (C::from (a.coeffs[i], bitsize, sgn))));
> return r;
>}
>
>
>
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline poly_int<N, C>
>poly_int_pod<N, C>::from (const poly_int_pod<N, Ca> &a, signop sgn)
>{
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = C::from (a.coeffs[i], sgn)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (C::from (a.coeffs[i], sgn))));
> return r;
>}
>
>
>
>
>
>template<unsigned int N, typename C>
>inline bool
>poly_int_pod<N, C>::to_shwi (poly_int_pod<N, long> *r) const
>{
> for (unsigned int i = 0; i < N; i++)
> if (!wi::fits_shwi_p (this->coeffs[i]))
> return false;
> for (unsigned int i = 0; i < N; i++)
> r->coeffs[i] = this->coeffs[i].to_shwi ();
> return true;
>}
>
>
>
>
>
>
>template<unsigned int N, typename C>
>inline bool
>poly_int_pod<N, C>::to_uhwi (poly_int_pod<N, unsigned long> *r) const
>{
> for (unsigned int i = 0; i < N; i++)
> if (!wi::fits_uhwi_p (this->coeffs[i]))
> return false;
> for (unsigned int i = 0; i < N; i++)
> r->coeffs[i] = this->coeffs[i].to_uhwi ();
> return true;
>}
>
>
>
>
>template<unsigned int N, typename C>
>inline poly_int<N, long>
>poly_int_pod<N, C>::force_shwi () const
>{
> poly_int_pod<N, long> r;
> for (unsigned int i = 0; i < N; i++)
> r.coeffs[i] = this->coeffs[i].to_shwi ();
> return r;
>}
>
>
>
>
>template<unsigned int N, typename C>
>inline poly_int<N, unsigned long>
>poly_int_pod<N, C>::force_uhwi () const
>{
> poly_int_pod<N, unsigned long> r;
> for (unsigned int i = 0; i < N; i++)
> r.coeffs[i] = this->coeffs[i].to_uhwi ();
> return r;
>}
># 611 "../../gcc/poly-int.h"
>template<unsigned int N, typename C>
>class poly_int : public poly_int_pod<N, C>
>{
>public:
> poly_int () {}
>
> template<typename Ca>
> poly_int (const poly_int<N, Ca> &);
> template<typename Ca>
> poly_int (const poly_int_pod<N, Ca> &);
> template<typename C0>
> poly_int (const C0 &);
> template<typename C0, typename C1>
> poly_int (const C0 &, const C1 &);
>
> template<typename Ca>
> poly_int &operator = (const poly_int_pod<N, Ca> &);
> template<typename Ca>
> typename if_nonpoly<Ca, poly_int>::type &operator = (const Ca &);
>
> template<typename Ca>
> poly_int &operator += (const poly_int_pod<N, Ca> &);
> template<typename Ca>
> typename if_nonpoly<Ca, poly_int>::type &operator += (const Ca &);
>
> template<typename Ca>
> poly_int &operator -= (const poly_int_pod<N, Ca> &);
> template<typename Ca>
> typename if_nonpoly<Ca, poly_int>::type &operator -= (const Ca &);
>
> template<typename Ca>
> typename if_nonpoly<Ca, poly_int>::type &operator *= (const Ca &);
>
> poly_int &operator <<= (unsigned int);
>};
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline
>poly_int<N, C>::poly_int (const poly_int<N, Ca> &a)
>{
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = a.coeffs[i]) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (a.coeffs[i])));
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline
>poly_int<N, C>::poly_int (const poly_int_pod<N, Ca> &a)
>{
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = a.coeffs[i]) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (a.coeffs[i])));
>}
>
>template<unsigned int N, typename C>
>template<typename C0>
>inline
>poly_int<N, C>::poly_int (const C0 &c0)
>{
> ((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[0] = c0) : (void) ((*this).coeffs[0].~C (), new (&(*this).coeffs[0]) C (c0)));
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = wi::ints_for<C>::zero (this->coeffs[0])) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (wi::ints_for<C>::zero (this->coeffs[0]))));
>}
>
>template<unsigned int N, typename C>
>template<typename C0, typename C1>
>inline
>poly_int<N, C>::poly_int (const C0 &c0, const C1 &c1)
>{
> static_assert ((N >= 2), "N >= 2");
> ((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[0] = c0) : (void) ((*this).coeffs[0].~C (), new (&(*this).coeffs[0]) C (c0)));
> ((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[1] = c1) : (void) ((*this).coeffs[1].~C (), new (&(*this).coeffs[1]) C (c1)));
> for (unsigned int i = 2; i < N; i++)
> ((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = wi::ints_for<C>::zero (this->coeffs[0])) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (wi::ints_for<C>::zero (this->coeffs[0]))));
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline poly_int<N, C>&
>poly_int<N, C>::operator = (const poly_int_pod<N, Ca> &a)
>{
> for (unsigned int i = 0; i < N; i++)
> this->coeffs[i] = a.coeffs[i];
> return *this;
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline typename if_nonpoly<Ca, poly_int<N, C> >::type &
>poly_int<N, C>::operator = (const Ca &a)
>{
> this->coeffs[0] = a;
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> this->coeffs[i] = wi::ints_for<C>::zero (this->coeffs[0]);
> return *this;
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline poly_int<N, C>&
>poly_int<N, C>::operator += (const poly_int_pod<N, Ca> &a)
>{
> for (unsigned int i = 0; i < N; i++)
> this->coeffs[i] += a.coeffs[i];
> return *this;
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline typename if_nonpoly<Ca, poly_int<N, C> >::type &
>poly_int<N, C>::operator += (const Ca &a)
>{
> this->coeffs[0] += a;
> return *this;
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline poly_int<N, C>&
>poly_int<N, C>::operator -= (const poly_int_pod<N, Ca> &a)
>{
> for (unsigned int i = 0; i < N; i++)
> this->coeffs[i] -= a.coeffs[i];
> return *this;
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline typename if_nonpoly<Ca, poly_int<N, C> >::type &
>poly_int<N, C>::operator -= (const Ca &a)
>{
> this->coeffs[0] -= a;
> return *this;
>}
>
>template<unsigned int N, typename C>
>template<typename Ca>
>inline typename if_nonpoly<Ca, poly_int<N, C> >::type &
>poly_int<N, C>::operator *= (const Ca &a)
>{
> for (unsigned int i = 0; i < N; i++)
> this->coeffs[i] *= a;
> return *this;
>}
>
>template<unsigned int N, typename C>
>inline poly_int<N, C>&
>poly_int<N, C>::operator <<= (unsigned int a)
>{
> for (unsigned int i = 0; i < N; i++)
> this->coeffs[i] <<= a;
> return *this;
>}
>
>
>
>template<typename Ca, typename Cb, typename Cc>
>inline typename if_nonpoly<Ca, bool>::type
>coeffs_in_range_p (const Ca &a, const Cb &b, const Cc &c)
>{
> return a >= b && a <= c;
>}
>
>template<unsigned int N, typename Ca, typename Cb, typename Cc>
>inline typename if_nonpoly<Ca, bool>::type
>coeffs_in_range_p (const poly_int_pod<N, Ca> &a, const Cb &b, const Cc &c)
>{
> for (unsigned int i = 0; i < N; i++)
> if (a.coeffs[i] c)
> return false;
> return true;
>}
>
>namespace wi {
>
>
>template<unsigned int N>
>inline poly_int<N, hwi_with_prec>
>shwi (const poly_int_pod<N, long> &a, unsigned int precision)
>{
> poly_int<N, hwi_with_prec> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (hwi_with_prec *) 0), wi::int_traits<hwi_with_prec>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::shwi (a.coeffs[i], precision)) : (void) ((r).coeffs[i].~hwi_with_prec (), new (&(r).coeffs[i]) hwi_with_prec (wi::shwi (a.coeffs[i], precision))));
> return r;
>}
>
>
>
>template<unsigned int N>
>inline poly_int<N, hwi_with_prec>
>uhwi (const poly_int_pod<N, unsigned long> &a, unsigned int precision)
>{
> poly_int<N, hwi_with_prec> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (hwi_with_prec *) 0), wi::int_traits<hwi_with_prec>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::uhwi (a.coeffs[i], precision)) : (void) ((r).coeffs[i].~hwi_with_prec (), new (&(r).coeffs[i]) hwi_with_prec (wi::uhwi (a.coeffs[i], precision))));
> return r;
>}
>
>
>
>template<unsigned int N, typename Ca>
>inline poly_int<N, typename poly_result<Ca, Ca>::type>
>sext (const poly_int_pod<N, Ca> &a, unsigned int precision)
>{
> typedef typename poly_result<Ca, Ca>::type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sext (a.coeffs[i], precision)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sext (a.coeffs[i], precision))));
> return r;
>}
>
>
>
>template<unsigned int N, typename Ca>
>inline poly_int<N, typename poly_result<Ca, Ca>::type>
>zext (const poly_int_pod<N, Ca> &a, unsigned int precision)
>{
> typedef typename poly_result<Ca, Ca>::type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::zext (a.coeffs[i], precision)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::zext (a.coeffs[i], precision))));
> return r;
>}
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, Cb>::type>
>operator + (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Ca, Cb>::type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i]) + b.coeffs[i]) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]) + b.coeffs[i])));
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
>operator + (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = NCa (a.coeffs[0]) + b) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (NCa (a.coeffs[0]) + b)));
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]))));
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
>operator + (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename poly_result<Cb, Ca>::cast NCb;
> typedef typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type C;
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = a + NCb (b.coeffs[0])) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (a + NCb (b.coeffs[0]))));
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCb (b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCb (b.coeffs[i]))));
> return r;
>}
>
>namespace wi {
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
>add (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename wi::binary_traits <Ca, Cb>::result_type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::add (a.coeffs[i], b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::add (a.coeffs[i], b.coeffs[i]))));
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
>add (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> typedef typename wi::binary_traits <Ca, Cb>::result_type C;
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::add (a.coeffs[0], b)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::add (a.coeffs[0], b))));
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::add (a.coeffs[i], wi::ints_for<Cb>::zero (b))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::add (a.coeffs[i], wi::ints_for<Cb>::zero (b)))))
> ;
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
>add (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename wi::binary_traits <Ca, Cb>::result_type C;
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::add (a, b.coeffs[0])) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::add (a, b.coeffs[0]))));
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::add (wi::ints_for<Ca>::zero (a), b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::add (wi::ints_for<Ca>::zero (a), b.coeffs[i]))))
> ;
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
>add (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b,
> signop sgn, wi::overflow_type *overflow)
>{
> typedef typename wi::binary_traits <Ca, Cb>::result_type C;
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::add (a.coeffs[0], b.coeffs[0], sgn, overflow)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::add (a.coeffs[0], b.coeffs[0], sgn, overflow))));
> for (unsigned int i = 1; i < N; i++)
> {
> wi::overflow_type suboverflow;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::add (a.coeffs[i], b.coeffs[i], sgn, &suboverflow)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::add (a.coeffs[i], b.coeffs[i], sgn, &suboverflow))))
> ;
> wi::accumulate_overflow (*overflow, suboverflow);
> }
> return r;
>}
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, Cb>::type>
>operator - (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Ca, Cb>::type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i]) - b.coeffs[i]) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]) - b.coeffs[i])));
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
>operator - (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = NCa (a.coeffs[0]) - b) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (NCa (a.coeffs[0]) - b)));
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]))));
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
>operator - (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename poly_result<Cb, Ca>::cast NCb;
> typedef typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type C;
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = a - NCb (b.coeffs[0])) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (a - NCb (b.coeffs[0]))));
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = -NCb (b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (-NCb (b.coeffs[i]))));
> return r;
>}
>
>namespace wi {
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
>sub (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename wi::binary_traits <Ca, Cb>::result_type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sub (a.coeffs[i], b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sub (a.coeffs[i], b.coeffs[i]))));
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
>sub (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> typedef typename wi::binary_traits <Ca, Cb>::result_type C;
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::sub (a.coeffs[0], b)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::sub (a.coeffs[0], b))));
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sub (a.coeffs[i], wi::ints_for<Cb>::zero (b))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sub (a.coeffs[i], wi::ints_for<Cb>::zero (b)))))
> ;
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
>sub (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename wi::binary_traits <Ca, Cb>::result_type C;
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::sub (a, b.coeffs[0])) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::sub (a, b.coeffs[0]))));
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sub (wi::ints_for<Ca>::zero (a), b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sub (wi::ints_for<Ca>::zero (a), b.coeffs[i]))))
> ;
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
>sub (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b,
> signop sgn, wi::overflow_type *overflow)
>{
> typedef typename wi::binary_traits <Ca, Cb>::result_type C;
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::sub (a.coeffs[0], b.coeffs[0], sgn, overflow)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::sub (a.coeffs[0], b.coeffs[0], sgn, overflow))));
> for (unsigned int i = 1; i < N; i++)
> {
> wi::overflow_type suboverflow;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sub (a.coeffs[i], b.coeffs[i], sgn, &suboverflow)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sub (a.coeffs[i], b.coeffs[i], sgn, &suboverflow))))
> ;
> wi::accumulate_overflow (*overflow, suboverflow);
> }
> return r;
>}
>}
>
>template<unsigned int N, typename Ca>
>inline poly_int<N, typename poly_result<Ca, Ca>::type>
>operator - (const poly_int_pod<N, Ca> &a)
>{
> typedef typename poly_result<Ca, Ca>::cast NCa;
> typedef typename poly_result<Ca, Ca>::type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = -NCa (a.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (-NCa (a.coeffs[i]))));
> return r;
>}
>
>namespace wi {
>
>
>template<unsigned int N, typename Ca>
>inline poly_int<N, typename wi::binary_traits <Ca, Ca>::result_type>
>neg (const poly_int_pod<N, Ca> &a)
>{
> typedef typename wi::binary_traits <Ca, Ca>::result_type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::neg (a.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::neg (a.coeffs[i]))));
> return r;
>}
>
>template<unsigned int N, typename Ca>
>inline poly_int<N, typename wi::binary_traits <Ca, Ca>::result_type>
>neg (const poly_int_pod<N, Ca> &a, wi::overflow_type *overflow)
>{
> typedef typename wi::binary_traits <Ca, Ca>::result_type C;
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::neg (a.coeffs[0], overflow)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::neg (a.coeffs[0], overflow))));
> for (unsigned int i = 1; i < N; i++)
> {
> wi::overflow_type suboverflow;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::neg (a.coeffs[i], &suboverflow)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::neg (a.coeffs[i], &suboverflow))));
> wi::accumulate_overflow (*overflow, suboverflow);
> }
> return r;
>}
>}
>
>template<unsigned int N, typename Ca>
>inline poly_int<N, typename poly_result<Ca, Ca>::type>
>operator ~ (const poly_int_pod<N, Ca> &a)
>{
> if (N >= 2)
> return -1 - a;
> return ~a.coeffs[0];
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
>operator * (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i]) * b) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]) * b)));
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
>operator * (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a) * b.coeffs[i]) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a) * b.coeffs[i])));
> return r;
>}
>
>namespace wi {
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
>mul (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> typedef typename wi::binary_traits <Ca, Cb>::result_type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::mul (a.coeffs[i], b)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::mul (a.coeffs[i], b))));
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
>mul (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename wi::binary_traits <Ca, Cb>::result_type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::mul (a, b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::mul (a, b.coeffs[i]))));
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
>mul (const poly_int_pod<N, Ca> &a, const Cb &b,
> signop sgn, wi::overflow_type *overflow)
>{
> typedef typename wi::binary_traits <Ca, Cb>::result_type C;
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::mul (a.coeffs[0], b, sgn, overflow)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::mul (a.coeffs[0], b, sgn, overflow))));
> for (unsigned int i = 1; i < N; i++)
> {
> wi::overflow_type suboverflow;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::mul (a.coeffs[i], b, sgn, &suboverflow)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::mul (a.coeffs[i], b, sgn, &suboverflow))));
> wi::accumulate_overflow (*overflow, suboverflow);
> }
> return r;
>}
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, Ca>::type>
>operator << (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> typedef typename poly_result<Ca, Ca>::cast NCa;
> typedef typename poly_result<Ca, Ca>::type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i]) << b) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]) << b)));
> return r;
>}
>
>namespace wi {
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename wi::binary_traits <Ca, Ca>::result_type>
>lshift (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> typedef typename wi::binary_traits <Ca, Ca>::result_type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::lshift (a.coeffs[i], b)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::lshift (a.coeffs[i], b))));
> return r;
>}
>}
>
>
>
>
>template<typename Ca, typename Cb>
>inline bool
>maybe_eq_2 (const Ca &a0, const Ca &a1, const Cb &b0, const Cb &b1)
>{
> if (a1 != b1)
>
>
>
>
>
>
>
> return (a1 < b1
> ? b0 <= a0 && (a0 - b0) % (b1 - a1) == 0
> : b0 >= a0 && (b0 - a0) % (a1 - b1) == 0);
> return a0 == b0;
>}
>
>
>
>
>template<typename Ca, typename Cb>
>inline bool
>maybe_eq_2 (const Ca &a0, const Ca &a1, const Cb &b)
>{
> if (a1 != 0)
>
>
>
>
>
>
> return (a1 < 0
> ? b <= a0 && (a0 - b) % a1 == 0
> : b >= a0 && (b - a0) % a1 == 0);
> return a0 == b;
>}
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline bool
>maybe_eq (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> static_assert ((N <= 2), "N <= 2");
> if (N == 2)
> return maybe_eq_2 (a.coeffs[0], a.coeffs[1], b.coeffs[0], b.coeffs[1]);
> return a.coeffs[0] == b.coeffs[0];
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename if_nonpoly<Cb, bool>::type
>maybe_eq (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> static_assert ((N <= 2), "N <= 2");
> if (N == 2)
> return maybe_eq_2 (a.coeffs[0], a.coeffs[1], b);
> return a.coeffs[0] == b;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename if_nonpoly<Ca, bool>::type
>maybe_eq (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> static_assert ((N <= 2), "N <= 2");
> if (N == 2)
> return maybe_eq_2 (b.coeffs[0], b.coeffs[1], a);
> return a == b.coeffs[0];
>}
>
>template<typename Ca, typename Cb>
>inline typename if_nonpoly2<Ca, Cb, bool>::type
>maybe_eq (const Ca &a, const Cb &b)
>{
> return a == b;
>}
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline bool
>maybe_ne (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (a.coeffs[i] != b.coeffs[i])
> return true;
> return a.coeffs[0] != b.coeffs[0];
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename if_nonpoly<Cb, bool>::type
>maybe_ne (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (a.coeffs[i] != 0)
> return true;
> return a.coeffs[0] != b;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename if_nonpoly<Ca, bool>::type
>maybe_ne (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (b.coeffs[i] != 0)
> return true;
> return a != b.coeffs[0];
>}
>
>template<typename Ca, typename Cb>
>inline typename if_nonpoly2<Ca, Cb, bool>::type
>maybe_ne (const Ca &a, const Cb &b)
>{
> return a != b;
>}
># 1312 "../../gcc/poly-int.h"
>template<unsigned int N, typename Ca, typename Cb>
>inline bool
>maybe_le (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (a.coeffs[i] < b.coeffs[i])
> return true;
> return a.coeffs[0] <= b.coeffs[0];
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename if_nonpoly<Cb, bool>::type
>maybe_le (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (a.coeffs[i] < 0)
> return true;
> return a.coeffs[0] <= b;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename if_nonpoly<Ca, bool>::type
>maybe_le (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (b.coeffs[i] > 0)
> return true;
> return a <= b.coeffs[0];
>}
>
>template<typename Ca, typename Cb>
>inline typename if_nonpoly2<Ca, Cb, bool>::type
>maybe_le (const Ca &a, const Cb &b)
>{
> return a <= b;
>}
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline bool
>maybe_lt (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (a.coeffs[i] < b.coeffs[i])
> return true;
> return a.coeffs[0] < b.coeffs[0];
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename if_nonpoly<Cb, bool>::type
>maybe_lt (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (a.coeffs[i] < 0)
> return true;
> return a.coeffs[0] < b;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename if_nonpoly<Ca, bool>::type
>maybe_lt (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (b.coeffs[i] > 0)
> return true;
> return a < b.coeffs[0];
>}
>
>template<typename Ca, typename Cb>
>inline typename if_nonpoly2<Ca, Cb, bool>::type
>maybe_lt (const Ca &a, const Cb &b)
>{
> return a < b;
>}
># 1414 "../../gcc/poly-int.h"
>template<typename T1, typename T2>
>inline bool
>ordered_p (const T1 &a, const T2 &b)
>{
> return ((poly_int_traits<T1>::num_coeffs == 1
> && poly_int_traits<T2>::num_coeffs == 1)
> || (!maybe_lt (b, a))
> || (!maybe_lt (a, b)));
>}
>
>
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, Cb>::type>
>ordered_min (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> if ((!maybe_lt (b, a)))
> return a;
> else
> {
> if (N > 1)
> ((void)(!((!maybe_lt (a, b))) ? fancy_abort ("../../gcc/poly-int.h", 1439, __FUNCTION__), 0 : 0));
> return b;
> }
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
>ordered_min (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> if ((!maybe_lt (b, a)))
> return a;
> else
> {
> if (N > 1)
> ((void)(!((!maybe_lt (a, b))) ? fancy_abort ("../../gcc/poly-int.h", 1453, __FUNCTION__), 0 : 0));
> return b;
> }
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
>ordered_min (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> if ((!maybe_lt (b, a)))
> return a;
> else
> {
> if (N > 1)
> ((void)(!((!maybe_lt (a, b))) ? fancy_abort ("../../gcc/poly-int.h", 1467, __FUNCTION__), 0 : 0));
> return b;
> }
>}
>
>
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, Cb>::type>
>ordered_max (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> if ((!maybe_lt (b, a)))
> return b;
> else
> {
> if (N > 1)
> ((void)(!((!maybe_lt (a, b))) ? fancy_abort ("../../gcc/poly-int.h", 1487, __FUNCTION__), 0 : 0));
> return a;
> }
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
>ordered_max (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> if ((!maybe_lt (b, a)))
> return b;
> else
> {
> if (N > 1)
> ((void)(!((!maybe_lt (a, b))) ? fancy_abort ("../../gcc/poly-int.h", 1501, __FUNCTION__), 0 : 0));
> return a;
> }
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
>ordered_max (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> if ((!maybe_lt (b, a)))
> return b;
> else
> {
> if (N > 1)
> ((void)(!((!maybe_lt (a, b))) ? fancy_abort ("../../gcc/poly-int.h", 1515, __FUNCTION__), 0 : 0));
> return a;
> }
>}
>
>
>
>
>template<unsigned int N, typename Ca>
>inline Ca
>constant_lower_bound (const poly_int_pod<N, Ca> &a)
>{
> ((void)(!((!maybe_lt (a, typename poly_int_traits<Ca>::int_type (0)))) ? fancy_abort ("../../gcc/poly-int.h", 1527, __FUNCTION__), 0 : 0));
> return a.coeffs[0];
>}
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type
>constant_lower_bound_with_limit (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> if ((!maybe_lt (a, b)))
> return a.coeffs[0];
> return b;
>}
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type
>constant_upper_bound_with_limit (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> if ((!maybe_lt (b, a)))
> return a.coeffs[0];
> return b;
>}
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
>lower_bound (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Cb, Ca>::cast NCb;
> typedef typename poly_int_traits<Cb>::int_type ICb;
> typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
>
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = ((NCa (a.coeffs[0])) < (NCb (b)) ? (NCa (a.coeffs[0])) : (NCb (b)))) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (((NCa (a.coeffs[0])) < (NCb (b)) ? (NCa (a.coeffs[0])) : (NCb (b))))));
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = ((NCa (a.coeffs[i])) < (ICb (0)) ? (NCa (a.coeffs[i])) : (ICb (0)))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (((NCa (a.coeffs[i])) < (ICb (0)) ? (NCa (a.coeffs[i])) : (ICb (0))))));
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
>lower_bound (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> return lower_bound (b, a);
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, Cb>::type>
>lower_bound (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Cb, Ca>::cast NCb;
> typedef typename poly_result<Ca, Cb>::type C;
>
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = ((NCa (a.coeffs[i])) < (NCb (b.coeffs[i])) ? (NCa (a.coeffs[i])) : (NCb (b.coeffs[i])))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (((NCa (a.coeffs[i])) < (NCb (b.coeffs[i])) ? (NCa (a.coeffs[i])) : (NCb (b.coeffs[i]))))));
> return r;
>}
>
>template<typename Ca, typename Cb>
>inline typename poly_result<typename if_nonpoly<Ca>::type, typename if_nonpoly<Cb>::type>::type
>lower_bound (const Ca &a, const Cb &b)
>{
> return a }
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
>upper_bound (const poly_int_pod<N, Ca> &a, const Cb &b)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Cb, Ca>::cast NCb;
> typedef typename poly_int_traits<Cb>::int_type ICb;
> typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
>
> poly_int<N, C> r;
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = ((NCa (a.coeffs[0])) > (NCb (b)) ? (NCa (a.coeffs[0])) : (NCb (b)))) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (((NCa (a.coeffs[0])) > (NCb (b)) ? (NCa (a.coeffs[0])) : (NCb (b))))));
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = ((NCa (a.coeffs[i])) > (ICb (0)) ? (NCa (a.coeffs[i])) : (ICb (0)))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (((NCa (a.coeffs[i])) > (ICb (0)) ? (NCa (a.coeffs[i])) : (ICb (0))))));
> return r;
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
>upper_bound (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> return upper_bound (b, a);
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, Cb>::type>
>upper_bound (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Cb, Ca>::cast NCb;
> typedef typename poly_result<Ca, Cb>::type C;
>
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = ((NCa (a.coeffs[i])) > (NCb (b.coeffs[i])) ? (NCa (a.coeffs[i])) : (NCb (b.coeffs[i])))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (((NCa (a.coeffs[i])) > (NCb (b.coeffs[i])) ? (NCa (a.coeffs[i])) : (NCb (b.coeffs[i]))))));
> return r;
>}
>
>
>
>
>template<unsigned int N, typename Ca>
>inline typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type
>coeff_gcd (const poly_int_pod<N, Ca> &a)
>{
>
> unsigned int i;
> for (i = N - 1; i > 0; --i)
> if (a.coeffs[i] != 0)
> break;
> typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type C;
> C r = a.coeffs[i];
> for (unsigned int j = 0; j < i; ++j)
> if (a.coeffs[j] != 0)
> r = gcd (r, C (a.coeffs[j]));
> return r;
>}
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
>common_multiple (const poly_int_pod<N, Ca> &a, Cb b)
>{
> typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type xgcd = coeff_gcd (a);
> return a * (least_common_multiple (xgcd, b) / xgcd);
>}
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
>common_multiple (const Ca &a, const poly_int_pod<N, Cb> &b)
>{
> return common_multiple (b, a);
>}
># 1692 "../../gcc/poly-int.h"
>template<unsigned int N, typename Ca, typename Cb>
>poly_int<N, typename poly_result<Ca, Cb>::type>
>force_common_multiple (const poly_int_pod<N, Ca> &a,
> const poly_int_pod<N, Cb> &b)
>{
> if (b.is_constant ())
> return common_multiple (a, b.coeffs[0]);
> if (a.is_constant ())
> return common_multiple (a.coeffs[0], b);
>
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Cb, Ca>::cast NCb;
> typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Cb>::coeff_type>::type C;
> typedef typename poly_int_traits<Ca>::int_type ICa;
>
> for (unsigned int i = 1; i < N; ++i)
> if (a.coeffs[i] != ICa (0))
> {
> C lcm = least_common_multiple (NCa (a.coeffs[i]), NCb (b.coeffs[i]));
> C amul = lcm / a.coeffs[i];
> C bmul = lcm / b.coeffs[i];
> for (unsigned int j = 0; j < N; ++j)
> ((void)(!(a.coeffs[j] * amul == b.coeffs[j] * bmul) ? fancy_abort ("../../gcc/poly-int.h", 1714, __FUNCTION__), 0 : 0));
> return a * amul;
> }
> (fancy_abort ("../../gcc/poly-int.h", 1717, __FUNCTION__));
>}
># 1731 "../../gcc/poly-int.h"
>template<unsigned int N, typename Ca, typename Cb>
>inline int
>compare_sizes_for_sort (const poly_int_pod<N, Ca> &a,
> const poly_int_pod<N, Cb> &b)
>{
> for (unsigned int i = N; i-- > 0; )
> if (a.coeffs[i] != b.coeffs[i])
> return a.coeffs[i] < b.coeffs[i] ? -1 : 1;
> return 0;
>}
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline bool
>can_align_p (const poly_int_pod<N, Ca> &value, Cb align)
>{
> for (unsigned int i = 1; i < N; i++)
> if ((value.coeffs[i] & (align - 1)) != 0)
> return false;
> return true;
>}
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline bool
>can_align_up (const poly_int_pod<N, Ca> &value, Cb align,
> poly_int_pod<N, Ca> *aligned)
>{
> if (!can_align_p (value, align))
> return false;
> *aligned = value + (-value.coeffs[0] & (align - 1));
> return true;
>}
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline bool
>can_align_down (const poly_int_pod<N, Ca> &value, Cb align,
> poly_int_pod<N, Ca> *aligned)
>{
> if (!can_align_p (value, align))
> return false;
> *aligned = value - (value.coeffs[0] & (align - 1));
> return true;
>}
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb, typename Cc>
>inline bool
>known_equal_after_align_up (const poly_int_pod<N, Ca> &a,
> const poly_int_pod<N, Cb> &b,
> Cc align)
>{
> poly_int<N, Ca> aligned_a;
> poly_int<N, Cb> aligned_b;
> return (can_align_up (a, align, &aligned_a)
> && can_align_up (b, align, &aligned_b)
> && (!maybe_ne (aligned_a, aligned_b)));
>}
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb, typename Cc>
>inline bool
>known_equal_after_align_down (const poly_int_pod<N, Ca> &a,
> const poly_int_pod<N, Cb> &b,
> Cc align)
>{
> poly_int<N, Ca> aligned_a;
> poly_int<N, Cb> aligned_b;
> return (can_align_down (a, align, &aligned_a)
> && can_align_down (b, align, &aligned_b)
> && (!maybe_ne (aligned_a, aligned_b)));
>}
># 1823 "../../gcc/poly-int.h"
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, Ca>
>force_align_up (const poly_int_pod<N, Ca> &value, Cb align)
>{
> ((void)(!(can_align_p (value, align)) ? fancy_abort ("../../gcc/poly-int.h", 1827, __FUNCTION__), 0 : 0));
> return value + (-value.coeffs[0] & (align - 1));
>}
># 1838 "../../gcc/poly-int.h"
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, Ca>
>force_align_down (const poly_int_pod<N, Ca> &value, Cb align)
>{
> ((void)(!(can_align_p (value, align)) ? fancy_abort ("../../gcc/poly-int.h", 1842, __FUNCTION__), 0 : 0));
> return value - (value.coeffs[0] & (align - 1));
>}
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, Ca>
>aligned_lower_bound (const poly_int_pod<N, Ca> &value, Cb align)
>{
> poly_int<N, Ca> r;
> for (unsigned int i = 0; i < N; i++)
>
>
> ((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = (value.coeffs[i] - (value.coeffs[i] & (align - 1)))) : (void) ((r).coeffs[i].~Ca (), new (&(r).coeffs[i]) Ca ((value.coeffs[i] - (value.coeffs[i] & (align - 1))))))
> ;
> return r;
>}
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, Ca>
>aligned_upper_bound (const poly_int_pod<N, Ca> &value, Cb align)
>{
> poly_int<N, Ca> r;
> for (unsigned int i = 0; i < N; i++)
> ((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = (value.coeffs[i] + (-value.coeffs[i] & (align - 1)))) : (void) ((r).coeffs[i].~Ca (), new (&(r).coeffs[i]) Ca ((value.coeffs[i] + (-value.coeffs[i] & (align - 1))))))
> ;
> return r;
>}
># 1886 "../../gcc/poly-int.h"
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, Ca>
>force_align_down_and_div (const poly_int_pod<N, Ca> &value, Cb align)
>{
> ((void)(!(can_align_p (value, align)) ? fancy_abort ("../../gcc/poly-int.h", 1890, __FUNCTION__), 0 : 0));
>
> poly_int<N, Ca> r;
> ((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = ((value.coeffs[0] - (value.coeffs[0] & (align - 1))) / align)) : (void) ((r).coeffs[0].~Ca (), new (&(r).coeffs[0]) Ca (((value.coeffs[0] - (value.coeffs[0] & (align - 1))) / align))))
>
> ;
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = value.coeffs[i] / align) : (void) ((r).coeffs[i].~Ca (), new (&(r).coeffs[i]) Ca (value.coeffs[i] / align)));
> return r;
>}
># 1910 "../../gcc/poly-int.h"
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, Ca>
>force_align_up_and_div (const poly_int_pod<N, Ca> &value, Cb align)
>{
> ((void)(!(can_align_p (value, align)) ? fancy_abort ("../../gcc/poly-int.h", 1914, __FUNCTION__), 0 : 0));
>
> poly_int<N, Ca> r;
> ((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = ((value.coeffs[0] + (-value.coeffs[0] & (align - 1))) / align)) : (void) ((r).coeffs[0].~Ca (), new (&(r).coeffs[0]) Ca (((value.coeffs[0] + (-value.coeffs[0] & (align - 1))) / align))))
>
> ;
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> ((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = value.coeffs[i] / align) : (void) ((r).coeffs[i].~Ca (), new (&(r).coeffs[i]) Ca (value.coeffs[i] / align)));
> return r;
>}
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb, typename Cm>
>inline bool
>known_misalignment (const poly_int_pod<N, Ca> &value, Cb align, Cm *misalign)
>{
> ((void)(!(align != 0) ? fancy_abort ("../../gcc/poly-int.h", 1934, __FUNCTION__), 0 : 0));
> if (!can_align_p (value, align))
> return false;
> *misalign = value.coeffs[0] & (align - 1);
> return true;
>}
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type
>force_get_misalignment (const poly_int_pod<N, Ca> &a, Cb align)
>{
> ((void)(!(can_align_p (a, align)) ? fancy_abort ("../../gcc/poly-int.h", 1949, __FUNCTION__), 0 : 0));
> return a.coeffs[0] & (align - 1);
>}
>
>
>
>
>template<unsigned int N, typename Ca>
>inline typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type
>known_alignment (const poly_int_pod<N, Ca> &a)
>{
> typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type C;
> C r = a.coeffs[0];
> for (unsigned int i = 1; i < N; ++i)
> r |= a.coeffs[i];
> return r & -r;
>}
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb, typename Cr>
>inline typename if_nonpoly<Cb, bool>::type
>can_ior_p (const poly_int_pod<N, Ca> &a, Cb b, Cr *result)
>{
>
>
> typedef typename poly_int_traits<Ca>::int_type int_type;
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if ((-(a.coeffs[i] & -a.coeffs[i]) & b) != int_type (0))
> return false;
> *result = a;
> result->coeffs[0] |= b;
> return true;
>}
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb, typename Cm>
>inline typename if_nonpoly<Cb, bool>::type
>constant_multiple_p (const poly_int_pod<N, Ca> &a, Cb b, Cm *multiple)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Cb, Ca>::cast NCb;
>
>
>
> if (NCa (a.coeffs[0]) % NCb (b) != 0 || !a.is_constant ())
> return false;
> *multiple = NCa (a.coeffs[0]) / NCb (b);
> return true;
>}
>
>template<unsigned int N, typename Ca, typename Cb, typename Cm>
>inline typename if_nonpoly<Ca, bool>::type
>constant_multiple_p (Ca a, const poly_int_pod<N, Cb> &b, Cm *multiple)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Cb, Ca>::cast NCb;
> typedef typename poly_int_traits<Ca>::int_type int_type;
>
>
>
> if (NCa (a) % NCb (b.coeffs[0]) != 0
> || (a != int_type (0) && !b.is_constant ()))
> return false;
> *multiple = NCa (a) / NCb (b.coeffs[0]);
> return true;
>}
>
>template<unsigned int N, typename Ca, typename Cb, typename Cm>
>inline bool
>constant_multiple_p (const poly_int_pod<N, Ca> &a,
> const poly_int_pod<N, Cb> &b, Cm *multiple)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Cb, Ca>::cast NCb;
> typedef typename poly_int_traits<Ca>::int_type ICa;
> typedef typename poly_int_traits<Cb>::int_type ICb;
> typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Cb>::coeff_type>::type C;
>
> if (NCa (a.coeffs[0]) % NCb (b.coeffs[0]) != 0)
> return false;
>
> C r = NCa (a.coeffs[0]) / NCb (b.coeffs[0]);
> for (unsigned int i = 1; i < N; ++i)
> if (b.coeffs[i] == ICb (0)
> ? a.coeffs[i] != ICa (0)
> : (NCa (a.coeffs[i]) % NCb (b.coeffs[i]) != 0
> || NCa (a.coeffs[i]) / NCb (b.coeffs[i]) != r))
> return false;
>
> *multiple = r;
> return true;
>}
>
>
>
>template<typename Ca, typename Cb>
>inline typename if_nonpoly2<Ca, Cb, bool>::type
>multiple_p (Ca a, Cb b)
>{
> return a % b == 0;
>}
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename if_nonpoly<Cb, bool>::type
>multiple_p (const poly_int_pod<N, Ca> &a, Cb b)
>{
> for (unsigned int i = 0; i < N; ++i)
> if (a.coeffs[i] % b != 0)
> return false;
> return true;
>}
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline typename if_nonpoly<Ca, bool>::type
>multiple_p (Ca a, const poly_int_pod<N, Cb> &b)
>{
> typedef typename poly_int_traits<Ca>::int_type int_type;
>
>
>
> return a % b.coeffs[0] == 0 && (a == int_type (0) || b.is_constant ());
>}
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline bool
>multiple_p (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> if (b.is_constant ())
> return multiple_p (a, b.coeffs[0]);
> typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type tmp;
> return constant_multiple_p (a, b, &tmp);
>}
>
>
>
>
>template<typename Ca, typename Cb, typename Cm>
>inline typename if_nonpoly2<Ca, Cb, bool>::type
>multiple_p (Ca a, Cb b, Cm *multiple)
>{
> if (a % b != 0)
> return false;
> *multiple = a / b;
> return true;
>}
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb, typename Cm>
>inline typename if_nonpoly<Cb, bool>::type
>multiple_p (const poly_int_pod<N, Ca> &a, Cb b, poly_int_pod<N, Cm> *multiple)
>{
> if (!multiple_p (a, b))
> return false;
> for (unsigned int i = 0; i < N; ++i)
> multiple->coeffs[i] = a.coeffs[i] / b;
> return true;
>}
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb, typename Cm>
>inline typename if_nonpoly<Ca, bool>::type
>multiple_p (Ca a, const poly_int_pod<N, Cb> &b, Cm *multiple)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
>
>
>
> if (a % b.coeffs[0] != 0 || (NCa (a) != 0 && !b.is_constant ()))
> return false;
> *multiple = a / b.coeffs[0];
> return true;
>}
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb, typename Cm>
>inline bool
>multiple_p (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b,
> poly_int_pod<N, Cm> *multiple)
>{
> if (b.is_constant ())
> return multiple_p (a, b.coeffs[0], multiple);
> return constant_multiple_p (a, b, multiple);
>}
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
>exact_div (const poly_int_pod<N, Ca> &a, Cb b)
>{
> typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
> poly_int<N, C> r;
> for (unsigned int i = 0; i < N; i++)
> {
> ((void)(!(a.coeffs[i] % b == 0) ? fancy_abort ("../../gcc/poly-int.h", 2162, __FUNCTION__), 0 : 0));
> ((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = a.coeffs[i] / b) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (a.coeffs[i] / b)));
> }
> return r;
>}
>
>
>
>template<unsigned int N, typename Ca, typename Cb>
>inline poly_int<N, typename poly_result<Ca, Cb>::type>
>exact_div (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
>{
> if (b.is_constant ())
> return exact_div (a, b.coeffs[0]);
>
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Cb, Ca>::cast NCb;
> typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Cb>::coeff_type>::type C;
> typedef typename poly_int_traits<Cb>::int_type int_type;
>
> ((void)(!(a.coeffs[0] % b.coeffs[0] == 0) ? fancy_abort ("../../gcc/poly-int.h", 2182, __FUNCTION__), 0 : 0));
> C r = NCa (a.coeffs[0]) / NCb (b.coeffs[0]);
> for (unsigned int i = 1; i < N; ++i)
> ((void)(!(b.coeffs[i] == int_type (0) ? a.coeffs[i] == int_type (0) : (a.coeffs[i] % b.coeffs[i] == 0 && NCa (a.coeffs[i]) / NCb (b.coeffs[i]) == r)) ? fancy_abort ("../../gcc/poly-int.h", 2185, __FUNCTION__), 0 : 0))
>
>
> ;
>
> return r;
>}
># 2201 "../../gcc/poly-int.h"
>template<unsigned int N, typename Ca, typename Cb, typename Cq>
>inline typename if_nonpoly2<Cb, Cq, bool>::type
>can_div_trunc_p (const poly_int_pod<N, Ca> &a, Cb b, Cq *quotient)
>{
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Cb, Ca>::cast NCb;
>
>
>
> Cq q = NCa (a.coeffs[0]) / NCb (b);
> if (!a.is_constant ())
> return false;
> *quotient = q;
> return true;
>}
>
>template<unsigned int N, typename Ca, typename Cb, typename Cq>
>inline typename if_nonpoly<Cq, bool>::type
>can_div_trunc_p (const poly_int_pod<N, Ca> &a,
> const poly_int_pod<N, Cb> &b,
> Cq *quotient)
>{
>
>
> typedef typename poly_result<Ca, Cb>::cast NCa;
> typedef typename poly_result<Cb, Ca>::cast NCb;
> typedef typename poly_int_traits<Ca>::int_type ICa;
> typedef typename poly_int_traits<Cb>::int_type ICb;
> typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Cb>::coeff_type>::type C;
> C q = NCa (a.coeffs[0]) / NCb (b.coeffs[0]);
># 2277 "../../gcc/poly-int.h"
> bool rem_p = NCa (a.coeffs[0]) % NCb (b.coeffs[0]) != 0;
> for (unsigned int i = 1; i < N; ++i)
> {
> if (b.coeffs[i] == ICb (0))
> {
>
> if (a.coeffs[i] != ICa (0))
> return false;
> }
> else
> {
> if (q == 0)
> {
>
> if (a.coeffs[i] != ICa (0))
> {
>
>
> C neg_abs_a = (a.coeffs[i] < 0 ? a.coeffs[i] : -a.coeffs[i]);
> C neg_abs_b = (b.coeffs[i] < 0 ? b.coeffs[i] : -b.coeffs[i]);
> if (neg_abs_a < neg_abs_b)
> return false;
> rem_p = true;
> }
> }
> else
> {
>
> if (NCa (a.coeffs[i]) / NCb (b.coeffs[i]) != q)
> return false;
> if (NCa (a.coeffs[i]) % NCb (b.coeffs[i]) != 0)
> rem_p = true;
> }
> }
> }
>
>
>
>
> if (rem_p && (!ordered_p (a, ICa (0)) || !ordered_p (b, ICb (0))))
> return false;
>
> *quotient = q;
> return true;
>}
>
>
>
>template<unsigned int N, typename Ca, typename Cb, typename Cq, typename Cr>
>inline typename if_nonpoly<Cq, bool>::type
>can_div_trunc_p (const poly_int_pod<N, Ca> &a,
> const poly_int_pod<N, Cb> &b,
> Cq *quotient, Cr *remainder)
>{
> if (!can_div_trunc_p (a, b, quotient))
> return false;
> *remainder = a - *quotient * b;
> return true;
>}
># 2345 "../../gcc/poly-int.h"
>template<unsigned int N, typename Ca, typename Cb, typename Cq>
>inline typename if_nonpoly<Cb, bool>::type
>can_div_trunc_p (const poly_int_pod<N, Ca> &a, Cb b,
> poly_int_pod<N, Cq> *quotient)
>{
>
> for (unsigned int i = 1; i < N; ++i)
> if (a.coeffs[i] % b != 0)
> return false;
> for (unsigned int i = 0; i < N; ++i)
> quotient->coeffs[i] = a.coeffs[i] / b;
> return true;
>}
>
>
>
>template<unsigned int N, typename Ca, typename Cb, typename Cq, typename Cr>
>inline typename if_nonpoly<Cb, bool>::type
>can_div_trunc_p (const poly_int_pod<N, Ca> &a, Cb b,
> poly_int_pod<N, Cq> *quotient, Cr *remainder)
>{
> if (!can_div_trunc_p (a, b, quotient))
> return false;
> *remainder = a.coeffs[0] % b;
> return true;
>}
>
>
>
>
>
>
>
>template<unsigned int N, typename Ca, typename Cb, typename Cq>
>inline bool
>can_div_trunc_p (const poly_int_pod<N, Ca> &a,
> const poly_int_pod<N, Cb> &b,
> poly_int_pod<N, Cq> *quotient)
>{
> if (b.is_constant ())
> return can_div_trunc_p (a, b.coeffs[0], quotient);
> if (!can_div_trunc_p (a, b, &quotient->coeffs[0]))
> return false;
> for (unsigned int i = 1; i < N; ++i)
> quotient->coeffs[i] = 0;
> return true;
>}
># 2401 "../../gcc/poly-int.h"
>template<unsigned int N, typename Ca, typename Cb, typename Cq>
>inline typename if_nonpoly<Cq, bool>::type
>can_div_away_from_zero_p (const poly_int_pod<N, Ca> &a,
> const poly_int_pod<N, Cb> &b,
> Cq *quotient)
>{
> if (!can_div_trunc_p (a, b, quotient))
> return false;
> if (maybe_ne (*quotient * b, a))
> *quotient += (*quotient < 0 ? -1 : 1);
> return true;
>}
>
>
>
>
>template<unsigned int N, typename C>
>void
>print_dec (const poly_int_pod<N, C> &value, FILE *file, signop sgn)
>{
> if (value.is_constant ())
> print_dec (value.coeffs[0], file, sgn);
> else
> {
> fprintf (file, "[");
> for (unsigned int i = 0; i < N; ++i)
> {
> print_dec (value.coeffs[i], file, sgn);
> fputc_unlocked (i == N - 1 ? ']' : ',', file);
> }
> }
>}
>
>
>
>
>template<unsigned int N, typename C>
>void
>print_dec (const poly_int_pod<N, C> &value, FILE *file)
>{
> static_assert ((poly_coeff_traits<C>::signedness >= 0), "poly_coeff_traits<C>::signedness >= 0");
> print_dec (value, file,
> poly_coeff_traits<C>::signedness ? SIGNED : UNSIGNED);
>}
>
>
>
>template<unsigned int N, typename C>
>void
>print_hex (const poly_int_pod<N, C> &value, FILE *file)
>{
> if (value.is_constant ())
> print_hex (value.coeffs[0], file);
> else
> {
> fprintf (file, "[");
> for (unsigned int i = 0; i < N; ++i)
> {
> print_hex (value.coeffs[i], file);
> fputc_unlocked (i == N - 1 ? ']' : ',', file);
> }
> }
>}
># 2482 "../../gcc/poly-int.h"
>template<typename T1, typename T2,
> typename Res = typename poly_result<typename poly_int_traits<typename poly_result<typename poly_int_traits<T1>::coeff_type, typename poly_int_traits<T2>::coeff_type>::type>::coeff_type, typename poly_int_traits<unsigned long>::coeff_type>::type
> >
>struct poly_span_traits
>{
> template<typename T>
> static const T &cast (const T &x) { return x; }
>};
>
>template<typename T1, typename T2>
>struct poly_span_traits<T1, T2, unsigned long>
>{
> template<typename T>
> static typename if_nonpoly<T, unsigned long>::type
> cast (const T &x) { return x; }
>
> template<unsigned int N, typename T>
> static poly_int<N, unsigned long>
> cast (const poly_int_pod<N, T> &x) { return x; }
>};
>
>
>
>
>template<typename T>
>inline bool
>known_size_p (const T &a)
>{
> return maybe_ne (a, typename poly_int_traits<T>::int_type (-1));
>}
>
>
>
>
>
>template<typename T1, typename T2, typename T3>
>inline bool
>maybe_in_range_p (const T1 &val, const T2 &pos, const T3 &size)
>{
> typedef poly_span_traits<T1, T2> start_span;
> typedef poly_span_traits<T3, T3> size_span;
> if ((!maybe_le (pos, val)))
> return false;
> if (!known_size_p (size))
> return true;
> if ((poly_int_traits<T1>::num_coeffs > 1
> || poly_int_traits<T2>::num_coeffs > 1)
> && maybe_lt (val, pos))
>
>
> return true;
> return maybe_lt (start_span::cast (val) - start_span::cast (pos),
> size_span::cast (size));
>}
>
>
>
>
>
>template<typename T1, typename T2, typename T3>
>inline bool
>known_in_range_p (const T1 &val, const T2 &pos, const T3 &size)
>{
> typedef poly_span_traits<T1, T2> start_span;
> typedef poly_span_traits<T3, T3> size_span;
> return (known_size_p (size)
> && (!maybe_lt (val, pos))
> && (!maybe_le (size_span::cast (size), start_span::cast (val) - start_span::cast (pos)))
> );
>}
>
>
>
>
>
>template<typename T1, typename T2, typename T3, typename T4>
>inline bool
>ranges_maybe_overlap_p (const T1 &pos1, const T2 &size1,
> const T3 &pos2, const T4 &size2)
>{
> if (maybe_in_range_p (pos2, pos1, size1))
> return maybe_ne (size2, typename poly_int_traits<T4>::int_type (0));
> if (maybe_in_range_p (pos1, pos2, size2))
> return maybe_ne (size1, typename poly_int_traits<T2>::int_type (0));
> return false;
>}
>
>
>
>
>
>template<typename T1, typename T2, typename T3, typename T4>
>inline bool
>ranges_known_overlap_p (const T1 &pos1, const T2 &size1,
> const T3 &pos2, const T4 &size2)
>{
> typedef poly_span_traits<T1, T3> start_span;
> typedef poly_span_traits<T2, T2> size1_span;
> typedef poly_span_traits<T4, T4> size2_span;
># 2593 "../../gcc/poly-int.h"
> return (known_size_p (size1)
> && known_size_p (size2)
> && (!maybe_le (size1_span::cast (size1), start_span::cast (pos2) - start_span::cast (lower_bound (pos1, pos2))))
>
>
> && (!maybe_le (size2_span::cast (size2), start_span::cast (pos1) - start_span::cast (lower_bound (pos1, pos2))))
>
> );
>}
>
>
>
>
>
>template<typename T1, typename T2, typename T3, typename T4>
>inline bool
>known_subrange_p (const T1 &pos1, const T2 &size1,
> const T3 &pos2, const T4 &size2)
>{
> typedef typename poly_int_traits<T2>::coeff_type C2;
> typedef poly_span_traits<T1, T3> start_span;
> typedef poly_span_traits<T2, T4> size_span;
> return ((!maybe_le (size1, typename poly_int_traits<T2>::int_type (0)))
> && (poly_coeff_traits<C2>::signedness > 0
> || known_size_p (size1))
> && known_size_p (size2)
> && (!maybe_lt (pos1, pos2))
> && (!maybe_lt (size2, size1))
> && (!maybe_lt (size_span::cast (size2) - size_span::cast (size1), start_span::cast (pos1) - start_span::cast (pos2)))
> );
>}
>
>
>
>
>
>template<typename T>
>inline typename if_nonpoly<T, bool>::type
>endpoint_representable_p (const T &pos, const T &size)
>{
> return (!known_size_p (size)
> || pos <= poly_coeff_traits<T>::max_value - size);
>}
>
>template<unsigned int N, typename C>
>inline bool
>endpoint_representable_p (const poly_int_pod<N, C> &pos,
> const poly_int_pod<N, C> &size)
>{
> if (known_size_p (size))
> for (unsigned int i = 0; i < N; ++i)
> if (pos.coeffs[i] > poly_coeff_traits<C>::max_value - size.coeffs[i])
> return false;
> return true;
>}
>
>template<unsigned int N, typename C>
>void
>gt_ggc_mx (poly_int_pod<N, C> *)
>{
>}
>
>template<unsigned int N, typename C>
>void
>gt_pch_nx (poly_int_pod<N, C> *)
>{
>}
>
>template<unsigned int N, typename C>
>void
>gt_pch_nx (poly_int_pod<N, C> *, void (*) (void *, void *), void *)
>{
>}
># 450 "../../gcc/coretypes.h" 2
># 1 "../../gcc/poly-int-types.h" 1
># 23 "../../gcc/poly-int-types.h"
>typedef poly_int_pod<1, unsigned short> poly_uint16_pod;
>typedef poly_int_pod<1, long> poly_int64_pod;
>typedef poly_int_pod<1,
> unsigned long> poly_uint64_pod;
>typedef poly_int_pod<1, offset_int> poly_offset_int_pod;
>typedef poly_int_pod<1, wide_int> poly_wide_int_pod;
>typedef poly_int_pod<1, widest_int> poly_widest_int_pod;
>
>typedef poly_int<1, unsigned short> poly_uint16;
>typedef poly_int<1, long> poly_int64;
>typedef poly_int<1, unsigned long> poly_uint64;
>typedef poly_int<1, offset_int> poly_offset_int;
>typedef poly_int<1, wide_int> poly_wide_int;
>typedef poly_int<1, wide_int_ref> poly_wide_int_ref;
>typedef poly_int<1, widest_int> poly_widest_int;
># 451 "../../gcc/coretypes.h" 2
># 1 "./insn-modes-inline.h" 1
># 10 "./insn-modes-inline.h"
>inline __attribute__((__always_inline__))
>
>
>
>poly_uint16
>mode_size_inline (machine_mode mode)
>{
> extern poly_uint16_pod mode_size[NUM_MACHINE_MODES];
> ((void)(!(mode >= 0 && mode < NUM_MACHINE_MODES) ? fancy_abort ("./insn-modes-inline.h", 18, __FUNCTION__), 0 : 0));
> switch (mode)
> {
> case E_VOIDmode: return 0;
> case E_BLKmode: return 0;
> case E_CCmode: return 4;
> case E_CCGCmode: return 4;
> case E_CCGOCmode: return 4;
> case E_CCNOmode: return 4;
> case E_CCGZmode: return 4;
> case E_CCAmode: return 4;
> case E_CCCmode: return 4;
> case E_CCOmode: return 4;
> case E_CCPmode: return 4;
> case E_CCSmode: return 4;
> case E_CCZmode: return 4;
> case E_CCFPmode: return 4;
> case E_BImode: return 1;
> case E_QImode: return 1;
> case E_HImode: return 2;
> case E_SImode: return 4;
> case E_DImode: return 8;
> case E_TImode: return 16;
> case E_OImode: return 32;
> case E_XImode: return 64;
> case E_P2QImode: return 2;
> case E_P2HImode: return 4;
> case E_POImode: return 32;
> case E_QQmode: return 1;
> case E_HQmode: return 2;
> case E_SQmode: return 4;
> case E_DQmode: return 8;
> case E_TQmode: return 16;
> case E_UQQmode: return 1;
> case E_UHQmode: return 2;
> case E_USQmode: return 4;
> case E_UDQmode: return 8;
> case E_UTQmode: return 16;
> case E_HAmode: return 2;
> case E_SAmode: return 4;
> case E_DAmode: return 8;
> case E_TAmode: return 16;
> case E_UHAmode: return 2;
> case E_USAmode: return 4;
> case E_UDAmode: return 8;
> case E_UTAmode: return 16;
> case E_SFmode: return 4;
> case E_DFmode: return 8;
> case E_TFmode: return 16;
> case E_SDmode: return 4;
> case E_DDmode: return 8;
> case E_TDmode: return 16;
> case E_CQImode: return 2;
> case E_CP2QImode: return 4;
> case E_CHImode: return 4;
> case E_CP2HImode: return 8;
> case E_CSImode: return 8;
> case E_CDImode: return 16;
> case E_CTImode: return 32;
> case E_CPOImode: return 64;
> case E_COImode: return 64;
> case E_CXImode: return 128;
> case E_SCmode: return 8;
> case E_DCmode: return 16;
> case E_TCmode: return 32;
> case E_V2QImode: return 2;
> case E_V4QImode: return 4;
> case E_V2HImode: return 4;
> case E_V1SImode: return 4;
> case E_V8QImode: return 8;
> case E_V4HImode: return 8;
> case E_V2SImode: return 8;
> case E_V1DImode: return 8;
> case E_V12QImode: return 12;
> case E_V6HImode: return 12;
> case E_V14QImode: return 14;
> case E_V16QImode: return 16;
> case E_V8HImode: return 16;
> case E_V4SImode: return 16;
> case E_V2DImode: return 16;
> case E_V1TImode: return 16;
> case E_V32QImode: return 32;
> case E_V16HImode: return 32;
> case E_V8SImode: return 32;
> case E_V4DImode: return 32;
> case E_V2TImode: return 32;
> case E_V64QImode: return 64;
> case E_V32HImode: return 64;
> case E_V16SImode: return 64;
> case E_V8DImode: return 64;
> case E_V4TImode: return 64;
> case E_V128QImode: return 128;
> case E_V64HImode: return 128;
> case E_V32SImode: return 128;
> case E_V16DImode: return 128;
> case E_V8TImode: return 128;
> case E_V64SImode: return 256;
> case E_V2SFmode: return 8;
> case E_V4SFmode: return 16;
> case E_V2DFmode: return 16;
> case E_V8SFmode: return 32;
> case E_V4DFmode: return 32;
> case E_V2TFmode: return 32;
> case E_V16SFmode: return 64;
> case E_V8DFmode: return 64;
> case E_V4TFmode: return 64;
> case E_V32SFmode: return 128;
> case E_V16DFmode: return 128;
> case E_V8TFmode: return 128;
> case E_V64SFmode: return 256;
> case E_V32DFmode: return 256;
> case E_V16TFmode: return 256;
> default: return mode_size[mode];
> }
>}
>
>
>inline __attribute__((__always_inline__))
>
>
>
>poly_uint16
>mode_nunits_inline (machine_mode mode)
>{
> extern const poly_uint16_pod mode_nunits[NUM_MACHINE_MODES];
> switch (mode)
> {
> case E_VOIDmode: return 0;
> case E_BLKmode: return 0;
> case E_CCmode: return 1;
> case E_CCGCmode: return 1;
> case E_CCGOCmode: return 1;
> case E_CCNOmode: return 1;
> case E_CCGZmode: return 1;
> case E_CCAmode: return 1;
> case E_CCCmode: return 1;
> case E_CCOmode: return 1;
> case E_CCPmode: return 1;
> case E_CCSmode: return 1;
> case E_CCZmode: return 1;
> case E_CCFPmode: return 1;
> case E_BImode: return 1;
> case E_QImode: return 1;
> case E_HImode: return 1;
> case E_SImode: return 1;
> case E_DImode: return 1;
> case E_TImode: return 1;
> case E_OImode: return 1;
> case E_XImode: return 1;
> case E_P2QImode: return 1;
> case E_P2HImode: return 1;
> case E_POImode: return 1;
> case E_QQmode: return 1;
> case E_HQmode: return 1;
> case E_SQmode: return 1;
> case E_DQmode: return 1;
> case E_TQmode: return 1;
> case E_UQQmode: return 1;
> case E_UHQmode: return 1;
> case E_USQmode: return 1;
> case E_UDQmode: return 1;
> case E_UTQmode: return 1;
> case E_HAmode: return 1;
> case E_SAmode: return 1;
> case E_DAmode: return 1;
> case E_TAmode: return 1;
> case E_UHAmode: return 1;
> case E_USAmode: return 1;
> case E_UDAmode: return 1;
> case E_UTAmode: return 1;
> case E_SFmode: return 1;
> case E_DFmode: return 1;
> case E_XFmode: return 1;
> case E_TFmode: return 1;
> case E_SDmode: return 1;
> case E_DDmode: return 1;
> case E_TDmode: return 1;
> case E_CQImode: return 2;
> case E_CP2QImode: return 2;
> case E_CHImode: return 2;
> case E_CP2HImode: return 2;
> case E_CSImode: return 2;
> case E_CDImode: return 2;
> case E_CTImode: return 2;
> case E_CPOImode: return 2;
> case E_COImode: return 2;
> case E_CXImode: return 2;
> case E_SCmode: return 2;
> case E_DCmode: return 2;
> case E_XCmode: return 2;
> case E_TCmode: return 2;
> case E_V2QImode: return 2;
> case E_V4QImode: return 4;
> case E_V2HImode: return 2;
> case E_V1SImode: return 1;
> case E_V8QImode: return 8;
> case E_V4HImode: return 4;
> case E_V2SImode: return 2;
> case E_V1DImode: return 1;
> case E_V12QImode: return 12;
> case E_V6HImode: return 6;
> case E_V14QImode: return 14;
> case E_V16QImode: return 16;
> case E_V8HImode: return 8;
> case E_V4SImode: return 4;
> case E_V2DImode: return 2;
> case E_V1TImode: return 1;
> case E_V32QImode: return 32;
> case E_V16HImode: return 16;
> case E_V8SImode: return 8;
> case E_V4DImode: return 4;
> case E_V2TImode: return 2;
> case E_V64QImode: return 64;
> case E_V32HImode: return 32;
> case E_V16SImode: return 16;
> case E_V8DImode: return 8;
> case E_V4TImode: return 4;
> case E_V128QImode: return 128;
> case E_V64HImode: return 64;
> case E_V32SImode: return 32;
> case E_V16DImode: return 16;
> case E_V8TImode: return 8;
> case E_V64SImode: return 64;
> case E_V2SFmode: return 2;
> case E_V4SFmode: return 4;
> case E_V2DFmode: return 2;
> case E_V8SFmode: return 8;
> case E_V4DFmode: return 4;
> case E_V2TFmode: return 2;
> case E_V16SFmode: return 16;
> case E_V8DFmode: return 8;
> case E_V4TFmode: return 4;
> case E_V32SFmode: return 32;
> case E_V16DFmode: return 16;
> case E_V8TFmode: return 8;
> case E_V64SFmode: return 64;
> case E_V32DFmode: return 32;
> case E_V16TFmode: return 16;
> default: return mode_nunits[mode];
> }
>}
>
>
>inline __attribute__((__always_inline__))
>
>
>
>unsigned char
>mode_inner_inline (machine_mode mode)
>{
> extern const unsigned char mode_inner[NUM_MACHINE_MODES];
> ((void)(!(mode >= 0 && mode < NUM_MACHINE_MODES) ? fancy_abort ("./insn-modes-inline.h", 269, __FUNCTION__), 0 : 0));
> switch (mode)
> {
> case E_VOIDmode: return E_VOIDmode;
> case E_BLKmode: return E_BLKmode;
> case E_CCmode: return E_CCmode;
> case E_CCGCmode: return E_CCGCmode;
> case E_CCGOCmode: return E_CCGOCmode;
> case E_CCNOmode: return E_CCNOmode;
> case E_CCGZmode: return E_CCGZmode;
> case E_CCAmode: return E_CCAmode;
> case E_CCCmode: return E_CCCmode;
> case E_CCOmode: return E_CCOmode;
> case E_CCPmode: return E_CCPmode;
> case E_CCSmode: return E_CCSmode;
> case E_CCZmode: return E_CCZmode;
> case E_CCFPmode: return E_CCFPmode;
> case E_BImode: return E_BImode;
> case E_QImode: return E_QImode;
> case E_HImode: return E_HImode;
> case E_SImode: return E_SImode;
> case E_DImode: return E_DImode;
> case E_TImode: return E_TImode;
> case E_OImode: return E_OImode;
> case E_XImode: return E_XImode;
> case E_P2QImode: return E_P2QImode;
> case E_P2HImode: return E_P2HImode;
> case E_POImode: return E_POImode;
> case E_QQmode: return E_QQmode;
> case E_HQmode: return E_HQmode;
> case E_SQmode: return E_SQmode;
> case E_DQmode: return E_DQmode;
> case E_TQmode: return E_TQmode;
> case E_UQQmode: return E_UQQmode;
> case E_UHQmode: return E_UHQmode;
> case E_USQmode: return E_USQmode;
> case E_UDQmode: return E_UDQmode;
> case E_UTQmode: return E_UTQmode;
> case E_HAmode: return E_HAmode;
> case E_SAmode: return E_SAmode;
> case E_DAmode: return E_DAmode;
> case E_TAmode: return E_TAmode;
> case E_UHAmode: return E_UHAmode;
> case E_USAmode: return E_USAmode;
> case E_UDAmode: return E_UDAmode;
> case E_UTAmode: return E_UTAmode;
> case E_SFmode: return E_SFmode;
> case E_DFmode: return E_DFmode;
> case E_XFmode: return E_XFmode;
> case E_TFmode: return E_TFmode;
> case E_SDmode: return E_SDmode;
> case E_DDmode: return E_DDmode;
> case E_TDmode: return E_TDmode;
> case E_CQImode: return E_QImode;
> case E_CP2QImode: return E_P2QImode;
> case E_CHImode: return E_HImode;
> case E_CP2HImode: return E_P2HImode;
> case E_CSImode: return E_SImode;
> case E_CDImode: return E_DImode;
> case E_CTImode: return E_TImode;
> case E_CPOImode: return E_POImode;
> case E_COImode: return E_OImode;
> case E_CXImode: return E_XImode;
> case E_SCmode: return E_SFmode;
> case E_DCmode: return E_DFmode;
> case E_XCmode: return E_XFmode;
> case E_TCmode: return E_TFmode;
> case E_V2QImode: return E_QImode;
> case E_V4QImode: return E_QImode;
> case E_V2HImode: return E_HImode;
> case E_V1SImode: return E_SImode;
> case E_V8QImode: return E_QImode;
> case E_V4HImode: return E_HImode;
> case E_V2SImode: return E_SImode;
> case E_V1DImode: return E_DImode;
> case E_V12QImode: return E_QImode;
> case E_V6HImode: return E_HImode;
> case E_V14QImode: return E_QImode;
> case E_V16QImode: return E_QImode;
> case E_V8HImode: return E_HImode;
> case E_V4SImode: return E_SImode;
> case E_V2DImode: return E_DImode;
> case E_V1TImode: return E_TImode;
> case E_V32QImode: return E_QImode;
> case E_V16HImode: return E_HImode;
> case E_V8SImode: return E_SImode;
> case E_V4DImode: return E_DImode;
> case E_V2TImode: return E_TImode;
> case E_V64QImode: return E_QImode;
> case E_V32HImode: return E_HImode;
> case E_V16SImode: return E_SImode;
> case E_V8DImode: return E_DImode;
> case E_V4TImode: return E_TImode;
> case E_V128QImode: return E_QImode;
> case E_V64HImode: return E_HImode;
> case E_V32SImode: return E_SImode;
> case E_V16DImode: return E_DImode;
> case E_V8TImode: return E_TImode;
> case E_V64SImode: return E_SImode;
> case E_V2SFmode: return E_SFmode;
> case E_V4SFmode: return E_SFmode;
> case E_V2DFmode: return E_DFmode;
> case E_V8SFmode: return E_SFmode;
> case E_V4DFmode: return E_DFmode;
> case E_V2TFmode: return E_TFmode;
> case E_V16SFmode: return E_SFmode;
> case E_V8DFmode: return E_DFmode;
> case E_V4TFmode: return E_TFmode;
> case E_V32SFmode: return E_SFmode;
> case E_V16DFmode: return E_DFmode;
> case E_V8TFmode: return E_TFmode;
> case E_V64SFmode: return E_SFmode;
> case E_V32DFmode: return E_DFmode;
> case E_V16TFmode: return E_TFmode;
> default: return mode_inner[mode];
> }
>}
>
>
>inline __attribute__((__always_inline__))
>
>
>
>unsigned char
>mode_unit_size_inline (machine_mode mode)
>{
> extern unsigned char mode_unit_size[NUM_MACHINE_MODES];
> ((void)(!(mode >= 0 && mode < NUM_MACHINE_MODES) ? fancy_abort ("./insn-modes-inline.h", 396, __FUNCTION__), 0 : 0));
> switch (mode)
> {
> case E_VOIDmode: return 0;
> case E_BLKmode: return 0;
> case E_CCmode: return 4;
> case E_CCGCmode: return 4;
> case E_CCGOCmode: return 4;
> case E_CCNOmode: return 4;
> case E_CCGZmode: return 4;
> case E_CCAmode: return 4;
> case E_CCCmode: return 4;
> case E_CCOmode: return 4;
> case E_CCPmode: return 4;
> case E_CCSmode: return 4;
> case E_CCZmode: return 4;
> case E_CCFPmode: return 4;
> case E_BImode: return 1;
> case E_QImode: return 1;
> case E_HImode: return 2;
> case E_SImode: return 4;
> case E_DImode: return 8;
> case E_TImode: return 16;
> case E_OImode: return 32;
> case E_XImode: return 64;
> case E_P2QImode: return 2;
> case E_P2HImode: return 4;
> case E_POImode: return 32;
> case E_QQmode: return 1;
> case E_HQmode: return 2;
> case E_SQmode: return 4;
> case E_DQmode: return 8;
> case E_TQmode: return 16;
> case E_UQQmode: return 1;
> case E_UHQmode: return 2;
> case E_USQmode: return 4;
> case E_UDQmode: return 8;
> case E_UTQmode: return 16;
> case E_HAmode: return 2;
> case E_SAmode: return 4;
> case E_DAmode: return 8;
> case E_TAmode: return 16;
> case E_UHAmode: return 2;
> case E_USAmode: return 4;
> case E_UDAmode: return 8;
> case E_UTAmode: return 16;
> case E_SFmode: return 4;
> case E_DFmode: return 8;
> case E_TFmode: return 16;
> case E_SDmode: return 4;
> case E_DDmode: return 8;
> case E_TDmode: return 16;
> case E_CQImode: return 1;
> case E_CP2QImode: return 2;
> case E_CHImode: return 2;
> case E_CP2HImode: return 4;
> case E_CSImode: return 4;
> case E_CDImode: return 8;
> case E_CTImode: return 16;
> case E_CPOImode: return 32;
> case E_COImode: return 32;
> case E_CXImode: return 64;
> case E_SCmode: return 4;
> case E_DCmode: return 8;
> case E_TCmode: return 16;
> case E_V2QImode: return 1;
> case E_V4QImode: return 1;
> case E_V2HImode: return 2;
> case E_V1SImode: return 4;
> case E_V8QImode: return 1;
> case E_V4HImode: return 2;
> case E_V2SImode: return 4;
> case E_V1DImode: return 8;
> case E_V12QImode: return 1;
> case E_V6HImode: return 2;
> case E_V14QImode: return 1;
> case E_V16QImode: return 1;
> case E_V8HImode: return 2;
> case E_V4SImode: return 4;
> case E_V2DImode: return 8;
> case E_V1TImode: return 16;
> case E_V32QImode: return 1;
> case E_V16HImode: return 2;
> case E_V8SImode: return 4;
> case E_V4DImode: return 8;
> case E_V2TImode: return 16;
> case E_V64QImode: return 1;
> case E_V32HImode: return 2;
> case E_V16SImode: return 4;
> case E_V8DImode: return 8;
> case E_V4TImode: return 16;
> case E_V128QImode: return 1;
> case E_V64HImode: return 2;
> case E_V32SImode: return 4;
> case E_V16DImode: return 8;
> case E_V8TImode: return 16;
> case E_V64SImode: return 4;
> case E_V2SFmode: return 4;
> case E_V4SFmode: return 4;
> case E_V2DFmode: return 8;
> case E_V8SFmode: return 4;
> case E_V4DFmode: return 8;
> case E_V2TFmode: return 16;
> case E_V16SFmode: return 4;
> case E_V8DFmode: return 8;
> case E_V4TFmode: return 16;
> case E_V32SFmode: return 4;
> case E_V16DFmode: return 8;
> case E_V8TFmode: return 16;
> case E_V64SFmode: return 4;
> case E_V32DFmode: return 8;
> case E_V16TFmode: return 16;
> default: return mode_unit_size[mode];
> }
>}
>
>
>inline __attribute__((__always_inline__))
>
>
>
>unsigned short
>mode_unit_precision_inline (machine_mode mode)
>{
> extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES];
> ((void)(!(mode >= 0 && mode < NUM_MACHINE_MODES) ? fancy_abort ("./insn-modes-inline.h", 521, __FUNCTION__), 0 : 0));
> switch (mode)
> {
> case E_VOIDmode: return 0;
> case E_BLKmode: return 0;
> case E_CCmode: return 4*(8);
> case E_CCGCmode: return 4*(8);
> case E_CCGOCmode: return 4*(8);
> case E_CCNOmode: return 4*(8);
> case E_CCGZmode: return 4*(8);
> case E_CCAmode: return 4*(8);
> case E_CCCmode: return 4*(8);
> case E_CCOmode: return 4*(8);
> case E_CCPmode: return 4*(8);
> case E_CCSmode: return 4*(8);
> case E_CCZmode: return 4*(8);
> case E_CCFPmode: return 4*(8);
> case E_BImode: return 1;
> case E_QImode: return 1*(8);
> case E_HImode: return 2*(8);
> case E_SImode: return 4*(8);
> case E_DImode: return 8*(8);
> case E_TImode: return 16*(8);
> case E_OImode: return 32*(8);
> case E_XImode: return 64*(8);
> case E_P2QImode: return 16;
> case E_P2HImode: return 32;
> case E_POImode: return 160;
> case E_QQmode: return 1*(8);
> case E_HQmode: return 2*(8);
> case E_SQmode: return 4*(8);
> case E_DQmode: return 8*(8);
> case E_TQmode: return 16*(8);
> case E_UQQmode: return 1*(8);
> case E_UHQmode: return 2*(8);
> case E_USQmode: return 4*(8);
> case E_UDQmode: return 8*(8);
> case E_UTQmode: return 16*(8);
> case E_HAmode: return 2*(8);
> case E_SAmode: return 4*(8);
> case E_DAmode: return 8*(8);
> case E_TAmode: return 16*(8);
> case E_UHAmode: return 2*(8);
> case E_USAmode: return 4*(8);
> case E_UDAmode: return 8*(8);
> case E_UTAmode: return 16*(8);
> case E_SFmode: return 4*(8);
> case E_DFmode: return 8*(8);
> case E_XFmode: return 80;
> case E_TFmode: return 16*(8);
> case E_SDmode: return 4*(8);
> case E_DDmode: return 8*(8);
> case E_TDmode: return 16*(8);
> case E_CQImode: return 1*(8);
> case E_CP2QImode: return 16;
> case E_CHImode: return 2*(8);
> case E_CP2HImode: return 32;
> case E_CSImode: return 4*(8);
> case E_CDImode: return 8*(8);
> case E_CTImode: return 16*(8);
> case E_CPOImode: return 160;
> case E_COImode: return 32*(8);
> case E_CXImode: return 64*(8);
> case E_SCmode: return 4*(8);
> case E_DCmode: return 8*(8);
> case E_XCmode: return 80;
> case E_TCmode: return 16*(8);
> case E_V2QImode: return 1*(8);
> case E_V4QImode: return 1*(8);
> case E_V2HImode: return 2*(8);
> case E_V1SImode: return 4*(8);
> case E_V8QImode: return 1*(8);
> case E_V4HImode: return 2*(8);
> case E_V2SImode: return 4*(8);
> case E_V1DImode: return 8*(8);
> case E_V12QImode: return 1*(8);
> case E_V6HImode: return 2*(8);
> case E_V14QImode: return 1*(8);
> case E_V16QImode: return 1*(8);
> case E_V8HImode: return 2*(8);
> case E_V4SImode: return 4*(8);
> case E_V2DImode: return 8*(8);
> case E_V1TImode: return 16*(8);
> case E_V32QImode: return 1*(8);
> case E_V16HImode: return 2*(8);
> case E_V8SImode: return 4*(8);
> case E_V4DImode: return 8*(8);
> case E_V2TImode: return 16*(8);
> case E_V64QImode: return 1*(8);
> case E_V32HImode: return 2*(8);
> case E_V16SImode: return 4*(8);
> case E_V8DImode: return 8*(8);
> case E_V4TImode: return 16*(8);
> case E_V128QImode: return 1*(8);
> case E_V64HImode: return 2*(8);
> case E_V32SImode: return 4*(8);
> case E_V16DImode: return 8*(8);
> case E_V8TImode: return 16*(8);
> case E_V64SImode: return 4*(8);
> case E_V2SFmode: return 4*(8);
> case E_V4SFmode: return 4*(8);
> case E_V2DFmode: return 8*(8);
> case E_V8SFmode: return 4*(8);
> case E_V4DFmode: return 8*(8);
> case E_V2TFmode: return 16*(8);
> case E_V16SFmode: return 4*(8);
> case E_V8DFmode: return 8*(8);
> case E_V4TFmode: return 16*(8);
> case E_V32SFmode: return 4*(8);
> case E_V16DFmode: return 8*(8);
> case E_V8TFmode: return 16*(8);
> case E_V64SFmode: return 4*(8);
> case E_V32DFmode: return 8*(8);
> case E_V16TFmode: return 16*(8);
> default: return mode_unit_precision[mode];
> }
>}
># 452 "../../gcc/coretypes.h" 2
># 1 "../../gcc/machmode.h" 1
># 23 "../../gcc/machmode.h"
>typedef opt_mode<machine_mode> opt_machine_mode;
>
>extern poly_uint16_pod mode_size[NUM_MACHINE_MODES];
>extern const poly_uint16_pod mode_precision[NUM_MACHINE_MODES];
>extern const unsigned char mode_inner[NUM_MACHINE_MODES];
>extern const poly_uint16_pod mode_nunits[NUM_MACHINE_MODES];
>extern unsigned char mode_unit_size[NUM_MACHINE_MODES];
>extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES];
>extern const unsigned char mode_wider[NUM_MACHINE_MODES];
>extern const unsigned char mode_2xwider[NUM_MACHINE_MODES];
>
>template<typename T>
>struct mode_traits
>{
># 68 "../../gcc/machmode.h"
> enum from_int { dummy = MAX_MACHINE_MODE };
>
>};
>
>template<>
>struct mode_traits<machine_mode>
>{
>
> typedef machine_mode from_int;
>};
># 89 "../../gcc/machmode.h"
>extern const char * const mode_name[NUM_MACHINE_MODES];
>
>
>
>
># 1 "../../gcc/mode-classes.def" 1
># 95 "../../gcc/machmode.h" 2
>
>enum mode_class { MODE_RANDOM, MODE_CC, MODE_INT, MODE_PARTIAL_INT, MODE_FRACT, MODE_UFRACT, MODE_ACCUM, MODE_UACCUM, MODE_FLOAT, MODE_DECIMAL_FLOAT, MODE_COMPLEX_INT, MODE_COMPLEX_FLOAT, MODE_VECTOR_BOOL, MODE_VECTOR_INT, MODE_VECTOR_FRACT, MODE_VECTOR_UFRACT, MODE_VECTOR_ACCUM, MODE_VECTOR_UACCUM, MODE_VECTOR_FLOAT, MAX_MODE_CLASS };
>
>
>
>
>
>
>extern const unsigned char mode_class[NUM_MACHINE_MODES];
># 241 "../../gcc/machmode.h"
>template<typename T>
>class opt_mode
>{
>public:
> enum from_int { dummy = MAX_MACHINE_MODE };
>
> inline __attribute__ ((always_inline)) constexpr opt_mode () : m_mode (E_VOIDmode) {}
> inline __attribute__ ((always_inline)) constexpr opt_mode (const T &m) : m_mode (m) {}
> template<typename U>
> inline __attribute__ ((always_inline)) constexpr opt_mode (const U &m) : m_mode (T (m)) {}
> inline __attribute__ ((always_inline)) constexpr opt_mode (from_int m) : m_mode (machine_mode (m)) {}
>
> machine_mode else_void () const;
> machine_mode else_blk () const { return else_mode (((void) 0, E_BLKmode)); }
> machine_mode else_mode (machine_mode) const;
> T require () const;
>
> bool exists () const;
> template<typename U> bool exists (U *) const;
>
> bool operator== (const T &m) const { return m_mode == m; }
> bool operator!= (const T &m) const { return m_mode != m; }
>
>private:
> machine_mode m_mode;
>};
>
>
>
>
>template<typename T>
>inline __attribute__ ((always_inline)) machine_mode
>opt_mode<T>::else_void () const
>{
> return m_mode;
>}
>
>
>
>template<typename T>
>inline machine_mode
>opt_mode<T>::else_mode (machine_mode fallback) const
>{
> return m_mode == E_VOIDmode ? fallback : m_mode;
>}
>
>
>
>template<typename T>
>inline T
>opt_mode<T>::require () const
>{
> ((void)(!(m_mode != E_VOIDmode) ? fancy_abort ("../../gcc/machmode.h", 293, __FUNCTION__), 0 : 0));
> return typename mode_traits<T>::from_int (m_mode);
>}
>
>
>
>template<typename T>
>inline __attribute__ ((always_inline)) bool
>opt_mode<T>::exists () const
>{
> return m_mode != E_VOIDmode;
>}
>
>
>
>template<typename T>
>template<typename U>
>inline bool
>opt_mode<T>::exists (U *mode) const
>{
> if (m_mode != E_VOIDmode)
> {
> *mode = T (typename mode_traits<T>::from_int (m_mode));
> return true;
> }
> return false;
>}
>
>
>
>template<typename T>
>struct pod_mode
>{
> typedef typename mode_traits<T>::from_int from_int;
> typedef typename T::measurement_type measurement_type;
>
> machine_mode m_mode;
> inline __attribute__ ((always_inline)) constexpr
> operator machine_mode () const { return m_mode; }
>
> inline __attribute__ ((always_inline)) constexpr
> operator T () const { return from_int (m_mode); }
>
> inline __attribute__ ((always_inline)) pod_mode &operator = (const T &m) { m_mode = m; return *this; }
>};
>
>
>
>template<typename T>
>inline bool
>is_a (machine_mode m)
>{
> return T::includes_p (m);
>}
>
>template<typename T, typename U>
>inline bool
>is_a (const opt_mode &m)
>{
> return T::includes_p (m.else_void ());
>}
>
>
>
>template<typename T>
>inline T
>as_a (machine_mode m)
>{
> ((void)(!(T::includes_p (m)) ? fancy_abort ("../../gcc/machmode.h", 361, __FUNCTION__), 0 : 0));
> return typename mode_traits<T>::from_int (m);
>}
>
>template<typename T, typename U>
>inline T
>as_a (const opt_mode &m)
>{
> return as_a <T> (m.else_void ());
>}
>
>
>
>template<typename T>
>inline opt_mode<T>
>dyn_cast (machine_mode m)
>{
> if (T::includes_p (m))
> return T (typename mode_traits<T>::from_int (m));
> return opt_mode<T> ();
>}
>
>template<typename T, typename U>
>inline opt_mode<T>
>dyn_cast (const opt_mode &m)
>{
> return dyn_cast <T> (m.else_void ());
>}
>
>
>
>
>template<typename T, typename U>
>inline bool
>is_a (machine_mode m, U *result)
>{
> if (T::includes_p (m))
> {
> *result = T (typename mode_traits<T>::from_int (m));
> return true;
> }
> return false;
>}
>
>
>class scalar_int_mode
>{
>public:
> typedef mode_traits<scalar_int_mode>::from_int from_int;
> typedef unsigned short measurement_type;
>
> inline __attribute__ ((always_inline)) scalar_int_mode () {}
>
> inline __attribute__ ((always_inline)) constexpr
> scalar_int_mode (from_int m) : m_mode (machine_mode (m)) {}
>
> inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
>
> static bool includes_p (machine_mode);
>
>protected:
> machine_mode m_mode;
>};
>
>
>
>inline bool
>scalar_int_mode::includes_p (machine_mode m)
>{
> return (((enum mode_class) mode_class[m]) == MODE_INT || ((enum mode_class) mode_class[m]) == MODE_PARTIAL_INT);
>}
>
>
>class scalar_float_mode
>{
>public:
> typedef mode_traits<scalar_float_mode>::from_int from_int;
> typedef unsigned short measurement_type;
>
> inline __attribute__ ((always_inline)) scalar_float_mode () {}
>
> inline __attribute__ ((always_inline)) constexpr
> scalar_float_mode (from_int m) : m_mode (machine_mode (m)) {}
>
> inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
>
> static bool includes_p (machine_mode);
>
>protected:
> machine_mode m_mode;
>};
>
>
>
>inline bool
>scalar_float_mode::includes_p (machine_mode m)
>{
> return (((enum mode_class) mode_class[m]) == MODE_FLOAT || ((enum mode_class) mode_class[m]) == MODE_DECIMAL_FLOAT);
>}
>
>
>class scalar_mode
>{
>public:
> typedef mode_traits<scalar_mode>::from_int from_int;
> typedef unsigned short measurement_type;
>
> inline __attribute__ ((always_inline)) scalar_mode () {}
>
> inline __attribute__ ((always_inline)) constexpr
> scalar_mode (from_int m) : m_mode (machine_mode (m)) {}
>
> inline __attribute__ ((always_inline)) constexpr
> scalar_mode (const scalar_int_mode &m) : m_mode (m) {}
>
> inline __attribute__ ((always_inline)) constexpr
> scalar_mode (const scalar_float_mode &m) : m_mode (m) {}
>
> inline __attribute__ ((always_inline)) constexpr
> scalar_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
>
> inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
>
> static bool includes_p (machine_mode);
>
>protected:
> machine_mode m_mode;
>};
>
>
>
>inline bool
>scalar_mode::includes_p (machine_mode m)
>{
> switch (((enum mode_class) mode_class[m]))
> {
> case MODE_INT:
> case MODE_PARTIAL_INT:
> case MODE_FRACT:
> case MODE_UFRACT:
> case MODE_ACCUM:
> case MODE_UACCUM:
> case MODE_FLOAT:
> case MODE_DECIMAL_FLOAT:
> return true;
> default:
> return false;
> }
>}
>
>
>class complex_mode
>{
>public:
> typedef mode_traits<complex_mode>::from_int from_int;
> typedef unsigned short measurement_type;
>
> inline __attribute__ ((always_inline)) complex_mode () {}
>
> inline __attribute__ ((always_inline)) constexpr
> complex_mode (from_int m) : m_mode (machine_mode (m)) {}
>
> inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
>
> static bool includes_p (machine_mode);
>
>protected:
> machine_mode m_mode;
>};
>
>
>
>inline bool
>complex_mode::includes_p (machine_mode m)
>{
> return (((enum mode_class) mode_class[m]) == MODE_COMPLEX_INT || ((enum mode_class) mode_class[m]) == MODE_COMPLEX_FLOAT);
>}
>
>
>
>inline __attribute__ ((always_inline)) poly_uint16
>mode_to_bytes (machine_mode mode)
>{
>
> return (__builtin_constant_p (mode)
> ? mode_size_inline (mode) : mode_size[mode]);
>
>
>
>}
>
>
>
>inline __attribute__ ((always_inline)) poly_uint16
>mode_to_bits (machine_mode mode)
>{
> return mode_to_bytes (mode) * (8);
>}
>
>
>
>inline __attribute__ ((always_inline)) poly_uint16
>mode_to_precision (machine_mode mode)
>{
> return mode_precision[mode];
>}
>
>
>
>inline __attribute__ ((always_inline)) scalar_mode
>mode_to_inner (machine_mode mode)
>{
>
> return scalar_mode::from_int (__builtin_constant_p (mode)
> ? mode_inner_inline (mode)
> : mode_inner[mode]);
>
>
>
>}
>
>
>
>inline __attribute__ ((always_inline)) unsigned char
>mode_to_unit_size (machine_mode mode)
>{
>
> return (__builtin_constant_p (mode)
> ? mode_unit_size_inline (mode) : mode_unit_size[mode]);
>
>
>
>}
>
>
>
>inline __attribute__ ((always_inline)) unsigned short
>mode_to_unit_precision (machine_mode mode)
>{
>
> return (__builtin_constant_p (mode)
> ? mode_unit_precision_inline (mode) : mode_unit_precision[mode]);
>
>
>
>}
>
>
>
>inline __attribute__ ((always_inline)) poly_uint16
>mode_to_nunits (machine_mode mode)
>{
>
> return (__builtin_constant_p (mode)
> ? mode_nunits_inline (mode) : mode_nunits[mode]);
>
>
>
>}
>
>
>
>
>
>
>inline __attribute__ ((always_inline)) poly_uint16
>GET_MODE_SIZE (machine_mode mode)
>{
> return mode_to_bytes (mode);
>}
>
>template<typename T>
>inline __attribute__ ((always_inline)) typename if_poly<typename T::measurement_type>::type
>GET_MODE_SIZE (const T &mode)
>{
> return mode_to_bytes (mode);
>}
>
>template<typename T>
>inline __attribute__ ((always_inline)) typename if_nonpoly<typename T::measurement_type>::type
>GET_MODE_SIZE (const T &mode)
>{
> return mode_to_bytes (mode).coeffs[0];
>}
>
>
>
>
>
>
>
>inline __attribute__ ((always_inline)) poly_uint16
>GET_MODE_BITSIZE (machine_mode mode)
>{
> return mode_to_bits (mode);
>}
>
>template<typename T>
>inline __attribute__ ((always_inline)) typename if_poly<typename T::measurement_type>::type
>GET_MODE_BITSIZE (const T &mode)
>{
> return mode_to_bits (mode);
>}
>
>template<typename T>
>inline __attribute__ ((always_inline)) typename if_nonpoly<typename T::measurement_type>::type
>GET_MODE_BITSIZE (const T &mode)
>{
> return mode_to_bits (mode).coeffs[0];
>}
># 679 "../../gcc/machmode.h"
>inline __attribute__ ((always_inline)) poly_uint16
>GET_MODE_PRECISION (machine_mode mode)
>{
> return mode_to_precision (mode);
>}
>
>template<typename T>
>inline __attribute__ ((always_inline)) typename if_poly<typename T::measurement_type>::type
>GET_MODE_PRECISION (const T &mode)
>{
> return mode_to_precision (mode);
>}
>
>template<typename T>
>inline __attribute__ ((always_inline)) typename if_nonpoly<typename T::measurement_type>::type
>GET_MODE_PRECISION (const T &mode)
>{
> return mode_to_precision (mode).coeffs[0];
>}
>
>
>
>extern const unsigned char mode_ibit[NUM_MACHINE_MODES];
>
>
>
>extern const unsigned char mode_fbit[NUM_MACHINE_MODES];
>
>
>
>
>
>extern const unsigned long mode_mask_array[NUM_MACHINE_MODES];
># 737 "../../gcc/machmode.h"
>inline __attribute__ ((always_inline)) poly_uint16
>GET_MODE_NUNITS (machine_mode mode)
>{
> return mode_to_nunits (mode);
>}
>
>template<typename T>
>inline __attribute__ ((always_inline)) typename if_poly<typename T::measurement_type>::type
>GET_MODE_NUNITS (const T &mode)
>{
> return mode_to_nunits (mode);
>}
>
>template<typename T>
>inline __attribute__ ((always_inline)) typename if_nonpoly<typename T::measurement_type>::type
>GET_MODE_NUNITS (const T &mode)
>{
> return mode_to_nunits (mode).coeffs[0];
>}
>
>
>
>
>template<typename T>
>inline __attribute__ ((always_inline)) opt_mode<T>
>GET_MODE_WIDER_MODE (const T &m)
>{
> return typename opt_mode<T>::from_int (mode_wider[m]);
>}
>
>
>
>
>template<typename T>
>inline __attribute__ ((always_inline)) opt_mode<T>
>GET_MODE_2XWIDER_MODE (const T &m)
>{
> return typename opt_mode<T>::from_int (mode_2xwider[m]);
>}
>
>
>extern const unsigned char mode_complex[NUM_MACHINE_MODES];
>
>
>
>
>
>
>class fixed_size_mode
>{
>public:
> typedef mode_traits<fixed_size_mode>::from_int from_int;
> typedef unsigned short measurement_type;
>
> inline __attribute__ ((always_inline)) fixed_size_mode () {}
>
> inline __attribute__ ((always_inline)) constexpr
> fixed_size_mode (from_int m) : m_mode (machine_mode (m)) {}
>
> inline __attribute__ ((always_inline)) constexpr
> fixed_size_mode (const scalar_mode &m) : m_mode (m) {}
>
> inline __attribute__ ((always_inline)) constexpr
> fixed_size_mode (const scalar_int_mode &m) : m_mode (m) {}
>
> inline __attribute__ ((always_inline)) constexpr
> fixed_size_mode (const scalar_float_mode &m) : m_mode (m) {}
>
> inline __attribute__ ((always_inline)) constexpr
> fixed_size_mode (const scalar_mode_pod &m) : m_mode (m) {}
>
> inline __attribute__ ((always_inline)) constexpr
> fixed_size_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
>
> inline __attribute__ ((always_inline)) constexpr
> fixed_size_mode (const complex_mode &m) : m_mode (m) {}
>
> inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
>
> static bool includes_p (machine_mode);
>
>protected:
> machine_mode m_mode;
>};
>
>
>
>inline bool
>fixed_size_mode::includes_p (machine_mode mode)
>{
> return mode_to_bytes (mode).is_constant ();
>}
># 841 "../../gcc/machmode.h"
>extern opt_machine_mode mode_for_size (poly_uint64, enum mode_class, int);
>
>
>
>
>
>inline opt_scalar_int_mode
>int_mode_for_size (poly_uint64 size, int limit)
>{
> return dyn_cast <scalar_int_mode> (mode_for_size (size, MODE_INT, limit));
>}
>
>
>
>
>inline opt_scalar_float_mode
>float_mode_for_size (poly_uint64 size)
>{
> return dyn_cast <scalar_float_mode> (mode_for_size (size, MODE_FLOAT, 0));
>}
>
>
>
>inline opt_scalar_float_mode
>decimal_float_mode_for_size (unsigned int size)
>{
> return dyn_cast <scalar_float_mode>
> (mode_for_size (size, MODE_DECIMAL_FLOAT, 0));
>}
>
>extern machine_mode smallest_mode_for_size (poly_uint64, enum mode_class);
>
>
>
>
>inline scalar_int_mode
>smallest_int_mode_for_size (poly_uint64 size)
>{
> return as_a <scalar_int_mode> (smallest_mode_for_size (size, MODE_INT));
>}
>
>extern opt_scalar_int_mode int_mode_for_mode (machine_mode);
>extern opt_machine_mode bitwise_mode_for_mode (machine_mode);
>extern opt_machine_mode mode_for_vector (scalar_mode, poly_uint64);
>extern opt_machine_mode related_vector_mode (machine_mode, scalar_mode,
> poly_uint64 = 0);
>extern opt_machine_mode related_int_vector_mode (machine_mode);
>
>
>class bit_field_mode_iterator
>{
>public:
> bit_field_mode_iterator (long, long,
> poly_int64, poly_int64,
> unsigned int, bool);
> bool next_mode (scalar_int_mode *);
> bool prefer_smaller_modes ();
>
>private:
> opt_scalar_int_mode m_mode;
>
>
> long m_bitsize;
> long m_bitpos;
> poly_int64 m_bitregion_start;
> poly_int64 m_bitregion_end;
> unsigned int m_align;
> bool m_volatilep;
> int m_count;
>};
>
>
>
>extern bool get_best_mode (int, int, poly_uint64, poly_uint64, unsigned int,
> unsigned long, bool, scalar_int_mode *);
>
>
>
>extern unsigned short mode_base_align[NUM_MACHINE_MODES];
>
>extern unsigned get_mode_alignment (machine_mode);
>
>
>
>
>
>extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
># 939 "../../gcc/machmode.h"
>template<typename T>
>inline T
>get_narrowest_mode (T mode)
>{
> return typename mode_traits<T>::from_int
> (class_narrowest_mode[((enum mode_class) mode_class[mode])]);
>}
>
>
>
>
>extern scalar_int_mode byte_mode;
>extern scalar_int_mode word_mode;
>extern scalar_int_mode ptr_mode;
>
>
>extern void init_adjust_machine_modes (void);
># 964 "../../gcc/machmode.h"
>inline bool
>HWI_COMPUTABLE_MODE_P (machine_mode mode)
>{
> machine_mode mme = mode;
> return ((((enum mode_class) mode_class[mme]) == MODE_INT || ((enum mode_class) mode_class[mme]) == MODE_PARTIAL_INT)
> && mode_to_precision (mme).coeffs[0] <= 64);
>}
>
>inline bool
>HWI_COMPUTABLE_MODE_P (scalar_int_mode mode)
>{
> return GET_MODE_PRECISION (mode) <= 64;
>}
>
>struct int_n_data_t {
>
> unsigned int bitsize;
> scalar_int_mode_pod m;
>
>};
>
>
>
>extern bool int_n_enabled_p[1];
>extern const int_n_data_t int_n_data[1];
>
>
>
>
>template<typename T>
>inline bool
>is_int_mode (machine_mode mode, T *int_mode)
>{
> if (((enum mode_class) mode_class[mode]) == MODE_INT)
> {
> *int_mode = scalar_int_mode (scalar_int_mode::from_int (mode));
> return true;
> }
> return false;
>}
>
>
>
>
>template<typename T>
>inline bool
>is_float_mode (machine_mode mode, T *float_mode)
>{
> if (((enum mode_class) mode_class[mode]) == MODE_FLOAT)
> {
> *float_mode = scalar_float_mode (scalar_float_mode::from_int (mode));
> return true;
> }
> return false;
>}
>
>
>
>
>template<typename T>
>inline bool
>is_complex_int_mode (machine_mode mode, T *cmode)
>{
> if (((enum mode_class) mode_class[mode]) == MODE_COMPLEX_INT)
> {
> *cmode = complex_mode (complex_mode::from_int (mode));
> return true;
> }
> return false;
>}
>
>
>
>
>template<typename T>
>inline bool
>is_complex_float_mode (machine_mode mode, T *cmode)
>{
> if (((enum mode_class) mode_class[mode]) == MODE_COMPLEX_FLOAT)
> {
> *cmode = complex_mode (complex_mode::from_int (mode));
> return true;
> }
> return false;
>}
>
>
>
>
>inline bool
>is_narrower_int_mode (machine_mode mode, scalar_int_mode limit)
>{
> scalar_int_mode int_mode;
> return (is_a <scalar_int_mode> (mode, &int_mode)
> && GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (limit));
>}
>
>namespace mode_iterator
>{
>
>
> template<typename T>
> inline void
> start (opt_mode<T> *iter, enum mode_class mclass)
> {
> if (((machine_mode) class_narrowest_mode[mclass]) == E_VOIDmode)
> *iter = opt_mode<T> ();
> else
> *iter = as_a<T> (((machine_mode) class_narrowest_mode[mclass]));
> }
>
> inline void
> start (machine_mode *iter, enum mode_class mclass)
> {
> *iter = ((machine_mode) class_narrowest_mode[mclass]);
> }
>
>
>
> template<typename T>
> inline bool
> iterate_p (opt_mode<T> *iter)
> {
> return iter->exists ();
> }
>
> inline bool
> iterate_p (machine_mode *iter)
> {
> return *iter != E_VOIDmode;
> }
>
>
>
>
> template<typename T>
> inline void
> get_wider (opt_mode<T> *iter)
> {
> *iter = GET_MODE_WIDER_MODE (iter->require ());
> }
>
> inline void
> get_wider (machine_mode *iter)
> {
> *iter = GET_MODE_WIDER_MODE (*iter).else_void ();
> }
>
>
>
>
> template<typename T>
> inline void
> get_known_wider (T *iter)
> {
> *iter = GET_MODE_WIDER_MODE (*iter).require ();
> }
>
>
>
>
> template<typename T>
> inline void
> get_2xwider (opt_mode<T> *iter)
> {
> *iter = GET_MODE_2XWIDER_MODE (iter->require ());
> }
>
> inline void
> get_2xwider (machine_mode *iter)
> {
> *iter = GET_MODE_2XWIDER_MODE (*iter).else_void ();
> }
>}
># 1183 "../../gcc/machmode.h"
>template<typename T>
>void
>gt_ggc_mx (pod_mode<T> *)
>{
>}
>
>template<typename T>
>void
>gt_pch_nx (pod_mode<T> *)
>{
>}
>
>template<typename T>
>void
>gt_pch_nx (pod_mode<T> *, void (*) (void *, void *), void *)
>{
>}
># 453 "../../gcc/coretypes.h" 2
># 1 "../../gcc/double-int.h" 1
># 49 "../../gcc/double-int.h"
>struct double_int
>{
>
>
>
>
>
>
>
> static double_int from_uhwi (unsigned long cst);
> static double_int from_shwi (long cst);
> static double_int from_pair (long high, unsigned long low);
>
>
>
> static double_int from_buffer (const unsigned char *buffer, int len);
>
>
>
>
>
> static double_int mask (unsigned prec);
> static double_int max_value (unsigned int prec, bool uns);
> static double_int min_value (unsigned int prec, bool uns);
>
>
>
> double_int &operator ++ ();
> double_int &operator -- ();
> double_int &operator *= (double_int);
> double_int &operator += (double_int);
> double_int &operator -= (double_int);
> double_int &operator &= (double_int);
> double_int &operator ^= (double_int);
> double_int &operator |= (double_int);
>
>
>
>
>
> long to_shwi () const;
> unsigned long to_uhwi () const;
>
>
>
> bool fits_uhwi () const;
> bool fits_shwi () const;
> bool fits_hwi (bool uns) const;
>
>
>
> int trailing_zeros () const;
> int popcount () const;
>
>
>
> bool multiple_of (double_int, bool, double_int *) const;
>
>
>
>
>
>
>
> double_int set_bit (unsigned) const;
> double_int mul_with_sign (double_int, bool unsigned_p, bool *overflow) const;
> double_int wide_mul_with_sign (double_int, bool unsigned_p,
> double_int *higher, bool *overflow) const;
> double_int add_with_sign (double_int, bool unsigned_p, bool *overflow) const;
> double_int sub_with_overflow (double_int, bool *overflow) const;
> double_int neg_with_overflow (bool *overflow) const;
>
> double_int operator * (double_int) const;
> double_int operator + (double_int) const;
> double_int operator - (double_int) const;
> double_int operator - () const;
> double_int operator ~ () const;
> double_int operator & (double_int) const;
> double_int operator | (double_int) const;
> double_int operator ^ (double_int) const;
> double_int and_not (double_int) const;
>
> double_int lshift (long count) const;
> double_int lshift (long count, unsigned int prec, bool arith) const;
> double_int rshift (long count) const;
> double_int rshift (long count, unsigned int prec, bool arith) const;
> double_int alshift (long count, unsigned int prec) const;
> double_int arshift (long count, unsigned int prec) const;
> double_int llshift (long count, unsigned int prec) const;
> double_int lrshift (long count, unsigned int prec) const;
> double_int lrotate (long count, unsigned int prec) const;
> double_int rrotate (long count, unsigned int prec) const;
>
>
>
>
>
> double_int div (double_int, bool, unsigned) const;
> double_int sdiv (double_int, unsigned) const;
> double_int udiv (double_int, unsigned) const;
> double_int mod (double_int, bool, unsigned) const;
> double_int smod (double_int, unsigned) const;
> double_int umod (double_int, unsigned) const;
> double_int divmod_with_overflow (double_int, bool, unsigned,
> double_int *, bool *) const;
> double_int divmod (double_int, bool, unsigned, double_int *) const;
> double_int sdivmod (double_int, unsigned, double_int *) const;
> double_int udivmod (double_int, unsigned, double_int *) const;
>
>
>
> double_int ext (unsigned prec, bool uns) const;
> double_int zext (unsigned prec) const;
> double_int sext (unsigned prec) const;
>
>
>
> bool is_zero () const;
> bool is_one () const;
> bool is_minus_one () const;
> bool is_negative () const;
>
> int cmp (double_int b, bool uns) const;
> int ucmp (double_int b) const;
> int scmp (double_int b) const;
>
> bool ult (double_int b) const;
> bool ule (double_int b) const;
> bool ugt (double_int b) const;
> bool slt (double_int b) const;
> bool sle (double_int b) const;
> bool sgt (double_int b) const;
>
> double_int max (double_int b, bool uns);
> double_int smax (double_int b);
> double_int umax (double_int b);
>
> double_int min (double_int b, bool uns);
> double_int smin (double_int b);
> double_int umin (double_int b);
>
> bool operator == (double_int cst2) const;
> bool operator != (double_int cst2) const;
>
>
>
> unsigned long low;
> long high;
>
>};
># 207 "../../gcc/double-int.h"
>inline double_int
>double_int::from_shwi (long cst)
>{
> double_int r;
> r.low = (unsigned long) cst;
> r.high = cst < 0 ? -1 : 0;
> return r;
>}
># 230 "../../gcc/double-int.h"
>inline double_int
>double_int::from_uhwi (unsigned long cst)
>{
> double_int r;
> r.low = cst;
> r.high = 0;
> return r;
>}
>
>inline double_int
>double_int::from_pair (long high, unsigned long low)
>{
> double_int r;
> r.low = low;
> r.high = high;
> return r;
>}
>
>inline double_int &
>double_int::operator ++ ()
>{
> *this += (double_int::from_shwi (1));
> return *this;
>}
>
>inline double_int &
>double_int::operator -- ()
>{
> *this -= (double_int::from_shwi (1));
> return *this;
>}
>
>inline double_int &
>double_int::operator &= (double_int b)
>{
> *this = *this & b;
> return *this;
>}
>
>inline double_int &
>double_int::operator ^= (double_int b)
>{
> *this = *this ^ b;
> return *this;
>}
>
>inline double_int &
>double_int::operator |= (double_int b)
>{
> *this = *this | b;
> return *this;
>}
>
>
>
>
>inline long
>double_int::to_shwi () const
>{
> return (long) low;
>}
>
>
>
>
>inline unsigned long
>double_int::to_uhwi () const
>{
> return low;
>}
>
>
>
>inline bool
>double_int::fits_uhwi () const
>{
> return high == 0;
>}
>
>
>
>
>
>inline double_int
>double_int::operator ~ () const
>{
> double_int result;
> result.low = ~low;
> result.high = ~high;
> return result;
>}
>
>
>
>inline double_int
>double_int::operator | (double_int b) const
>{
> double_int result;
> result.low = low | b.low;
> result.high = high | b.high;
> return result;
>}
>
>
>
>inline double_int
>double_int::operator & (double_int b) const
>{
> double_int result;
> result.low = low & b.low;
> result.high = high & b.high;
> return result;
>}
>
>
>
>inline double_int
>double_int::and_not (double_int b) const
>{
> double_int result;
> result.low = low & ~b.low;
> result.high = high & ~b.high;
> return result;
>}
>
>
>
>inline double_int
>double_int::operator ^ (double_int b) const
>{
> double_int result;
> result.low = low ^ b.low;
> result.high = high ^ b.high;
> return result;
>}
>
>void dump_double_int (FILE *, double_int, bool);
># 376 "../../gcc/double-int.h"
>inline bool
>double_int::is_zero () const
>{
> return low == 0 && high == 0;
>}
>
>
>
>inline bool
>double_int::is_one () const
>{
> return low == 1 && high == 0;
>}
>
>
>
>inline bool
>double_int::is_minus_one () const
>{
> return low == -1UL && high == -1;
>}
>
>
>
>inline bool
>double_int::is_negative () const
>{
> return high < 0;
>}
>
>
>
>inline bool
>double_int::operator == (double_int cst2) const
>{
> return low == cst2.low && high == cst2.high;
>}
>
>
>
>inline bool
>double_int::operator != (double_int cst2) const
>{
> return low != cst2.low || high != cst2.high;
>}
>
>
>
>inline int
>double_int::popcount () const
>{
> return popcount_hwi (high) + popcount_hwi (low);
>}
># 438 "../../gcc/double-int.h"
>namespace wi
>{
> template <>
> struct int_traits <double_int>
> {
> static const enum precision_type precision_type = CONST_PRECISION;
> static const bool host_dependent_precision = true;
> static const unsigned int precision = (2 * 64);
> static unsigned int get_precision (const double_int &);
> static wi::storage_ref decompose (long *, unsigned int,
> const double_int &);
> };
>}
>
>inline unsigned int
>wi::int_traits <double_int>::get_precision (const double_int &)
>{
> return precision;
>}
>
>inline wi::storage_ref
>wi::int_traits <double_int>::decompose (long *scratch, unsigned int p,
> const double_int &x)
>{
> ((void)(!(precision == p) ? fancy_abort ("../../gcc/double-int.h", 462, __FUNCTION__), 0 : 0));
> scratch[0] = x.low;
> if ((x.high == 0 && scratch[0] >= 0) || (x.high == -1 && scratch[0] < 0))
> return wi::storage_ref (scratch, 1, precision);
> scratch[1] = x.high;
> return wi::storage_ref (scratch, 2, precision);
>}
># 454 "../../gcc/coretypes.h" 2
># 1 "../../gcc/align.h" 1
># 22 "../../gcc/align.h"
>struct align_flags_tuple
>{
>
>
>
> int log;
> int maxskip;
>
>
> void normalize ()
> {
> int n = (1 << log);
> if (maxskip > n)
> maxskip = n - 1;
> }
>
>
> int get_value ()
> {
> return maxskip + 1;
> }
>};
>
>
>
>
>class align_flags
>{
>public:
>
> align_flags (int log0 = 0, int maxskip0 = 0, int log1 = 0, int maxskip1 = 0)
> {
> levels[0].log = log0;
> levels[0].maxskip = maxskip0;
> levels[1].log = log1;
> levels[1].maxskip = maxskip1;
> normalize ();
> }
>
>
> void normalize ()
> {
> for (unsigned i = 0; i < 2; i++)
> levels[i].normalize ();
> }
>
>
> static align_flags max (const align_flags f0, const align_flags f1)
> {
> int log0 = ((f0.levels[0].log) > (f1.levels[0].log) ? (f0.levels[0].log) : (f1.levels[0].log));
> int maxskip0 = ((f0.levels[0].maxskip) > (f1.levels[0].maxskip) ? (f0.levels[0].maxskip) : (f1.levels[0].maxskip));
> int log1 = ((f0.levels[1].log) > (f1.levels[1].log) ? (f0.levels[1].log) : (f1.levels[1].log));
> int maxskip1 = ((f0.levels[1].maxskip) > (f1.levels[1].maxskip) ? (f0.levels[1].maxskip) : (f1.levels[1].maxskip));
> return align_flags (log0, maxskip0, log1, maxskip1);
> }
>
> align_flags_tuple levels[2];
>};
># 455 "../../gcc/coretypes.h" 2
># 29 "../../gcc/read-md.c" 2
>
># 1 "../../gcc/errors.h" 1
># 31 "../../gcc/errors.h"
>extern void warning (const char *, ...) __attribute__ ((__format__ (__printf__, 1, 2))) __attribute__ ((__nonnull__ (1))) __attribute__ ((__cold__));
>extern void error (const char *, ...) __attribute__ ((__format__ (__printf__, 1, 2))) __attribute__ ((__nonnull__ (1))) __attribute__ ((__cold__));
>extern void fatal (const char *, ...) __attribute__ ((__noreturn__)) __attribute__ ((__format__ (__printf__, 1, 2))) __attribute__ ((__nonnull__ (1))) __attribute__ ((__cold__));
>extern void internal_error (const char *, ...) __attribute__ ((__noreturn__)) __attribute__ ((__format__ (__printf__, 1, 2))) __attribute__ ((__nonnull__ (1))) __attribute__ ((__cold__));
>extern const char *trim_filename (const char *);
>
>extern int have_error;
>extern const char *progname;
># 31 "../../gcc/read-md.c" 2
>
># 1 "../../gcc/statistics.h" 1
># 61 "../../gcc/statistics.h"
>struct function;
>
>
>extern void statistics_early_init (void);
>extern void statistics_init (void);
>extern void statistics_fini (void);
>extern void statistics_fini_pass (void);
>extern void statistics_counter_event (struct function *, const char *, int);
>extern void statistics_histogram_event (struct function *, const char *, int);
># 33 "../../gcc/read-md.c" 2
># 1 "../../gcc/vec.h" 1
># 30 "../../gcc/vec.h"
>extern void ggc_free (void *);
>extern size_t ggc_round_alloc_size (size_t requested_size);
>extern void *ggc_realloc (void *, size_t );
># 183 "../../gcc/vec.h"
>extern void dump_vec_loc_statistics (void);
>
>
>extern htab_t vec_mem_usage_hash;
>
>
>
>
>struct vec_prefix
>{
>
>
>
>
> void register_overhead (void *, size_t, size_t );
> void release_overhead (void *, size_t, size_t, bool );
> static unsigned calculate_allocation (vec_prefix *, unsigned, bool);
> static unsigned calculate_allocation_1 (unsigned, unsigned);
>
>
>
>
>
>
>
> template <typename, typename, typename> friend struct vec;
>
>
> friend struct va_gc;
> friend struct va_gc_atomic;
> friend struct va_heap;
>
> unsigned m_alloc : 31;
> unsigned m_using_auto_storage : 1;
> unsigned m_num;
>};
>
>
>
>
>
>inline unsigned
>vec_prefix::calculate_allocation (vec_prefix *pfx, unsigned reserve,
> bool exact)
>{
> if (exact)
> return (pfx ? pfx->m_num : 0) + reserve;
> else if (!pfx)
> return ((4) > (reserve) ? (4) : (reserve));
> return calculate_allocation_1 (pfx->m_alloc, pfx->m_num + reserve);
>}
>
>template<typename, typename, typename> struct vec;
>
>
>
>
>
>
>struct vl_embed { };
>struct vl_ptr { };
># 254 "../../gcc/vec.h"
>struct va_heap
>{
>
>
> typedef vl_ptr default_layout;
>
> template<typename T>
> static void reserve (vec<T, va_heap, vl_embed> *&, unsigned, bool
> );
>
> template<typename T>
> static void release (vec<T, va_heap, vl_embed> *&);
>};
>
>
>
>
>
>
>
>template<typename T>
>inline void
>va_heap::reserve (vec<T, va_heap, vl_embed> *&v, unsigned reserve, bool exact
> )
>{
> size_t elt_size = sizeof (T);
> unsigned alloc
> = vec_prefix::calculate_allocation (v ? &v->m_vecpfx : 0, reserve, exact);
> ((void)(!(alloc) ? fancy_abort ("../../gcc/vec.h", 282, __FUNCTION__), 0 : 0));
>
> if (0 && v)
> v->m_vecpfx.release_overhead (v, elt_size * v->allocated (),
> v->allocated (), false);
>
> size_t size = vec<T, va_heap, vl_embed>::embedded_size (alloc);
> unsigned nelem = v ? v->length () : 0;
> v = static_cast <vec<T, va_heap, vl_embed> *> (xrealloc (v, size));
> v->embedded_init (alloc, nelem);
>
> if (0)
> v->m_vecpfx.register_overhead (v, alloc, elt_size );
>}
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wfree-nonheap-object"
>
>
>
>
>template<typename T>
>void
>va_heap::release (vec<T, va_heap, vl_embed> *&v)
>{
> size_t elt_size = sizeof (T);
> if (v == 
># 310 "../../gcc/vec.h" 3 4
> 0L
># 310 "../../gcc/vec.h"
> )
> return;
>
> if (0)
> v->m_vecpfx.release_overhead (v, elt_size * v->allocated (),
> v->allocated (), true);
> ::free (v);
> v = 
># 317 "../../gcc/vec.h" 3 4
> 0L
># 317 "../../gcc/vec.h"
> ;
>}
>
>
>#pragma GCC diagnostic pop
>
>
>
>
>
>struct va_gc
>{
>
>
>
>
> typedef vl_embed default_layout;
>
> template<typename T, typename A>
> static void reserve (vec<T, A, vl_embed> *&, unsigned, bool
> );
>
> template<typename T, typename A>
> static void release (vec<T, A, vl_embed> *&v);
>};
>
>
>
>
>template<typename T, typename A>
>inline void
>va_gc::release (vec<T, A, vl_embed> *&v)
>{
> if (v)
> ::ggc_free (v);
> v = 
># 352 "../../gcc/vec.h" 3 4
> 0L
># 352 "../../gcc/vec.h"
> ;
>}
>
>
>
>
>
>
>
>template<typename T, typename A>
>void
>va_gc::reserve (vec<T, A, vl_embed> *&v, unsigned reserve, bool exact
> )
>{
> unsigned alloc
> = vec_prefix::calculate_allocation (v ? &v->m_vecpfx : 0, reserve, exact);
> if (!alloc)
> {
> ::ggc_free (v);
> v = 
># 371 "../../gcc/vec.h" 3 4
> 0L
># 371 "../../gcc/vec.h"
> ;
> return;
> }
>
>
> size_t size = vec<T, A, vl_embed>::embedded_size (alloc);
>
>
> size = ::ggc_round_alloc_size (size);
>
>
> size_t vec_offset = sizeof (vec_prefix);
> size_t elt_size = sizeof (T);
> alloc = (size - vec_offset) / elt_size;
>
>
> size = vec_offset + alloc * elt_size;
>
> unsigned nelem = v ? v->length () : 0;
> v = static_cast <vec<T, A, vl_embed> *> (::ggc_realloc (v, size
> ));
> v->embedded_init (alloc, nelem);
>}
>
>
>
>
>
>struct va_gc_atomic : va_gc
>{
>};
># 415 "../../gcc/vec.h"
>template<typename T,
> typename A = va_heap,
> typename L = typename A::default_layout>
>struct vec
>{
>};
># 433 "../../gcc/vec.h"
>template<typename T>
>void
>debug_helper (vec<T> &ref)
>{
> unsigned i;
> for (i = 0; i < ref.length (); ++i)
> {
> fprintf (
># 440 "../../gcc/vec.h" 3 4
> (stderr)
># 440 "../../gcc/vec.h"
> , "[%d] = ", i);
> debug_slim (ref[i]);
> fputc_unlocked ('\n', 
># 442 "../../gcc/vec.h" 3 4
> (stderr)
># 442 "../../gcc/vec.h"
> );
> }
>}
>
>
>
>
>
>
>template<typename T>
>void
>debug_helper (vec<T, va_gc> &ref)
>{
> unsigned i;
> for (i = 0; i < ref.length (); ++i)
> {
> fprintf (
># 458 "../../gcc/vec.h" 3 4
> (stderr)
># 458 "../../gcc/vec.h"
> , "[%d] = ", i);
> debug_slim (ref[i]);
> fputc_unlocked ('\n', 
># 460 "../../gcc/vec.h" 3 4
> (stderr)
># 460 "../../gcc/vec.h"
> );
> }
>}
># 501 "../../gcc/vec.h"
>template <typename T>
>inline void
>vec_default_construct (T *dst, unsigned n)
>{
># 520 "../../gcc/vec.h"
> for ( ; n; ++dst, --n)
> ::new (static_cast<void*>(dst)) T ();
>}
>
>
>
>template <typename T>
>inline void
>vec_copy_construct (T *dst, const T *src, unsigned n)
>{
> for ( ; n; ++dst, ++src, --n)
> ::new (static_cast<void*>(dst)) T (*src);
>}
>
>
>
>
>
>
>
>struct vnull
>{
> template <typename T, typename A, typename L>
> constexpr operator vec<T, A, L> () { return vec<T, A, L>(); }
>};
>extern vnull vNULL;
># 574 "../../gcc/vec.h"
>template<typename T, typename A>
>struct vec<T, A, vl_embed>
>{
>public:
> unsigned allocated (void) const { return m_vecpfx.m_alloc; }
> unsigned length (void) const { return m_vecpfx.m_num; }
> bool is_empty (void) const { return m_vecpfx.m_num == 0; }
> T *address (void) { return m_vecdata; }
> const T *address (void) const { return m_vecdata; }
> T *begin () { return address (); }
> const T *begin () const { return address (); }
> T *end () { return address () + length (); }
> const T *end () const { return address () + length (); }
> const T &operator[] (unsigned) const;
> T &operator[] (unsigned);
> T &last (void);
> bool space (unsigned) const;
> bool iterate (unsigned, T *) const;
> bool iterate (unsigned, T **) const;
> vec *copy () const;
> void splice (const vec &);
> void splice (const vec *src);
> T *quick_push (const T &);
> T &pop (void);
> void truncate (unsigned);
> void quick_insert (unsigned, const T &);
> void ordered_remove (unsigned);
> void unordered_remove (unsigned);
> void block_remove (unsigned, unsigned);
> void qsort (int (*) (const void *, const void *));
> void sort (int (*) (const void *, const void *, void *), void *);
> T *bsearch (const void *key, int (*compar)(const void *, const void *));
> T *bsearch (const void *key,
> int (*compar)(const void *, const void *, void *), void *);
> unsigned lower_bound (T, bool (*)(const T &, const T &)) const;
> bool contains (const T &search) const;
> static size_t embedded_size (unsigned);
> void embedded_init (unsigned, unsigned = 0, unsigned = 0);
> void quick_grow (unsigned len);
> void quick_grow_cleared (unsigned len);
>
>
> template <typename, typename, typename> friend struct vec;
>
>
> friend struct va_gc;
> friend struct va_gc_atomic;
> friend struct va_heap;
>
>
>
> vec_prefix m_vecpfx;
> T m_vecdata[1];
>};
># 645 "../../gcc/vec.h"
>template<typename T, typename A>
>inline bool
>vec_safe_space (const vec<T, A, vl_embed> *v, unsigned nelems)
>{
> return v ? v->space (nelems) : nelems == 0;
>}
>
>
>
>template<typename T, typename A>
>inline unsigned
>vec_safe_length (const vec<T, A, vl_embed> *v)
>{
> return v ? v->length () : 0;
>}
>
>
>
>template<typename T, typename A>
>inline T *
>vec_safe_address (vec<T, A, vl_embed> *v)
>{
> return v ? v->address () : 
># 667 "../../gcc/vec.h" 3 4
> 0L
># 667 "../../gcc/vec.h"
> ;
>}
>
>
>
>template<typename T, typename A>
>inline bool
>vec_safe_is_empty (vec<T, A, vl_embed> *v)
>{
> return v ? v->is_empty () : true;
>}
>
>
>
>template<typename T, typename A>
>inline bool
>vec_safe_reserve (vec<T, A, vl_embed> *&v, unsigned nelems, bool exact = false
> )
>{
> bool extend = nelems ? !vec_safe_space (v, nelems) : false;
> if (extend)
> A::reserve (v, nelems, exact );
> return extend;
>}
>
>template<typename T, typename A>
>inline bool
>vec_safe_reserve_exact (vec<T, A, vl_embed> *&v, unsigned nelems
> )
>{
> return vec_safe_reserve (v, nelems, true );
>}
>
>
>
>
>
>template<typename T, typename A>
>inline void
>vec_alloc (vec<T, A, vl_embed> *&v, unsigned nelems )
>{
> v = 
># 708 "../../gcc/vec.h" 3 4
> 0L
># 708 "../../gcc/vec.h"
> ;
> vec_safe_reserve (v, nelems, false );
>}
>
>
>
>
>template<typename T, typename A>
>inline void
>vec_free (vec<T, A, vl_embed> *&v)
>{
> A::release (v);
>}
>
>
>
>template<typename T, typename A>
>inline void
>vec_safe_grow (vec<T, A, vl_embed> *&v, unsigned len )
>{
> unsigned oldlen = vec_safe_length (v);
> ((void)(!(len >= oldlen) ? fancy_abort ("../../gcc/vec.h", 729, __FUNCTION__), 0 : 0));
> vec_safe_reserve_exact (v, len - oldlen );
> v->quick_grow (len);
>}
>
>
>
>template<typename T, typename A>
>inline void
>vec_safe_grow_cleared (vec<T, A, vl_embed> *&v, unsigned len )
>{
> unsigned oldlen = vec_safe_length (v);
> vec_safe_grow (v, len );
> vec_default_construct (v->address () + oldlen, len - oldlen);
>}
>
>
>
>
>template<typename T>
>inline void
>vec_safe_grow_cleared (vec<T, va_heap, vl_ptr> *&v,
> unsigned len )
>{
> v->safe_grow_cleared (len );
>}
>
>
>
>template<typename T, typename A>
>inline bool
>vec_safe_iterate (const vec<T, A, vl_embed> *v, unsigned ix, T **ptr)
>{
> if (v)
> return v->iterate (ix, ptr);
> else
> {
> *ptr = 0;
> return false;
> }
>}
>
>template<typename T, typename A>
>inline bool
>vec_safe_iterate (const vec<T, A, vl_embed> *v, unsigned ix, T *ptr)
>{
> if (v)
> return v->iterate (ix, ptr);
> else
> {
> *ptr = 0;
> return false;
> }
>}
>
>
>
>
>template<typename T, typename A>
>inline T *
>vec_safe_push (vec<T, A, vl_embed> *&v, const T &obj )
>{
> vec_safe_reserve (v, 1, false );
> return v->quick_push (obj);
>}
>
>
>
>
>template<typename T, typename A>
>inline void
>vec_safe_insert (vec<T, A, vl_embed> *&v, unsigned ix, const T &obj
> )
>{
> vec_safe_reserve (v, 1, false );
> v->quick_insert (ix, obj);
>}
>
>
>
>template<typename T, typename A>
>inline void
>vec_safe_truncate (vec<T, A, vl_embed> *v, unsigned size)
>{
> if (v)
> v->truncate (size);
>}
>
>
>
>template<typename T, typename A>
>inline vec<T, A, vl_embed> *
>vec_safe_copy (vec<T, A, vl_embed> *src )
>{
> return src ? src->copy () : 
># 823 "../../gcc/vec.h" 3 4
> 0L
># 823 "../../gcc/vec.h"
> ;
>}
>
>
>
>template<typename T, typename A>
>inline void
>vec_safe_splice (vec<T, A, vl_embed> *&dst, const vec<T, A, vl_embed> *src
> )
>{
> unsigned src_len = vec_safe_length (src);
> if (src_len)
> {
> vec_safe_reserve_exact (dst, vec_safe_length (dst) + src_len
> );
> dst->splice (*src);
> }
>}
>
>
>
>
>template<typename T, typename A>
>inline bool
>vec_safe_contains (vec<T, A, vl_embed> *v, const T &search)
>{
> return v ? v->contains (search) : false;
>}
>
>
>
>
>template<typename T, typename A>
>inline const T &
>vec<T, A, vl_embed>::operator[] (unsigned ix) const
>{
> ((void)(!(ix < m_vecpfx.m_num) ? fancy_abort ("../../gcc/vec.h", 859, __FUNCTION__), 0 : 0));
> return m_vecdata[ix];
>}
>
>template<typename T, typename A>
>inline T &
>vec<T, A, vl_embed>::operator[] (unsigned ix)
>{
> ((void)(!(ix < m_vecpfx.m_num) ? fancy_abort ("../../gcc/vec.h", 867, __FUNCTION__), 0 : 0));
> return m_vecdata[ix];
>}
>
>
>
>
>template<typename T, typename A>
>inline T &
>vec<T, A, vl_embed>::last (void)
>{
> ((void)(!(m_vecpfx.m_num > 0) ? fancy_abort ("../../gcc/vec.h", 878, __FUNCTION__), 0 : 0));
> return (*this)[m_vecpfx.m_num - 1];
>}
># 889 "../../gcc/vec.h"
>template<typename T, typename A>
>inline bool
>vec<T, A, vl_embed>::space (unsigned nelems) const
>{
> return m_vecpfx.m_alloc - m_vecpfx.m_num >= nelems;
>}
># 904 "../../gcc/vec.h"
>template<typename T, typename A>
>inline bool
>vec<T, A, vl_embed>::iterate (unsigned ix, T *ptr) const
>{
> if (ix < m_vecpfx.m_num)
> {
> *ptr = m_vecdata[ix];
> return true;
> }
> else
> {
> *ptr = 0;
> return false;
> }
>}
># 930 "../../gcc/vec.h"
>template<typename T, typename A>
>inline bool
>vec<T, A, vl_embed>::iterate (unsigned ix, T **ptr) const
>{
> if (ix < m_vecpfx.m_num)
> {
> *ptr = (const_cast<T *> ((&m_vecdata[ix])));
> return true;
> }
> else
> {
> *ptr = 0;
> return false;
> }
>}
>
>
>
>
>template<typename T, typename A>
>inline vec<T, A, vl_embed> *
>vec<T, A, vl_embed>::copy (void) const
>{
> vec<T, A, vl_embed> *new_vec = 
># 953 "../../gcc/vec.h" 3 4
> 0L
># 953 "../../gcc/vec.h"
> ;
> unsigned len = length ();
> if (len)
> {
> vec_alloc (new_vec, len );
> new_vec->embedded_init (len, len);
> vec_copy_construct (new_vec->address (), m_vecdata, len);
> }
> return new_vec;
>}
>
>
>
>
>
>template<typename T, typename A>
>inline void
>vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> &src)
>{
> unsigned len = src.length ();
> if (len)
> {
> ((void)(!(space (len)) ? fancy_abort ("../../gcc/vec.h", 975, __FUNCTION__), 0 : 0));
> vec_copy_construct (end (), src.address (), len);
> m_vecpfx.m_num += len;
> }
>}
>
>template<typename T, typename A>
>inline void
>vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> *src)
>{
> if (src)
> splice (*src);
>}
>
>
>
>
>
>
>template<typename T, typename A>
>inline T *
>vec<T, A, vl_embed>::quick_push (const T &obj)
>{
> ((void)(!(space (1)) ? fancy_abort ("../../gcc/vec.h", 998, __FUNCTION__), 0 : 0));
> T *slot = &m_vecdata[m_vecpfx.m_num++];
> *slot = obj;
> return slot;
>}
>
>
>
>
>template<typename T, typename A>
>inline T &
>vec<T, A, vl_embed>::pop (void)
>{
> ((void)(!(length () > 0) ? fancy_abort ("../../gcc/vec.h", 1011, __FUNCTION__), 0 : 0));
> return m_vecdata[--m_vecpfx.m_num];
>}
>
>
>
>
>
>template<typename T, typename A>
>inline void
>vec<T, A, vl_embed>::truncate (unsigned size)
>{
> ((void)(!(length () >= size) ? fancy_abort ("../../gcc/vec.h", 1023, __FUNCTION__), 0 : 0));
> m_vecpfx.m_num = size;
>}
>
>
>
>
>
>template<typename T, typename A>
>inline void
>vec<T, A, vl_embed>::quick_insert (unsigned ix, const T &obj)
>{
> ((void)(!(length () < allocated ()) ? fancy_abort ("../../gcc/vec.h", 1035, __FUNCTION__), 0 : 0));
> ((void)(!(ix <= length ()) ? fancy_abort ("../../gcc/vec.h", 1036, __FUNCTION__), 0 : 0));
> T *slot = &m_vecdata[ix];
> memmove (slot + 1, slot, (m_vecpfx.m_num++ - ix) * sizeof (T));
> *slot = obj;
>}
>
>
>
>
>
>
>template<typename T, typename A>
>inline void
>vec<T, A, vl_embed>::ordered_remove (unsigned ix)
>{
> ((void)(!(ix < length ()) ? fancy_abort ("../../gcc/vec.h", 1051, __FUNCTION__), 0 : 0));
> T *slot = &m_vecdata[ix];
> memmove (slot, slot + 1, (--m_vecpfx.m_num - ix) * sizeof (T));
>}
># 1094 "../../gcc/vec.h"
>template<typename T, typename A>
>inline void
>vec<T, A, vl_embed>::unordered_remove (unsigned ix)
>{
> ((void)(!(ix < length ()) ? fancy_abort ("../../gcc/vec.h", 1098, __FUNCTION__), 0 : 0));
> m_vecdata[ix] = m_vecdata[--m_vecpfx.m_num];
>}
>
>
>
>
>
>template<typename T, typename A>
>inline void
>vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len)
>{
> ((void)(!(ix + len <= length ()) ? fancy_abort ("../../gcc/vec.h", 1110, __FUNCTION__), 0 : 0));
> T *slot = &m_vecdata[ix];
> m_vecpfx.m_num -= len;
> memmove (slot, slot + len, (m_vecpfx.m_num - ix) * sizeof (T));
>}
>
>
>
>
>
>template<typename T, typename A>
>inline void
>vec<T, A, vl_embed>::qsort (int (*cmp) (const void *, const void *))
>{
> if (length () > 1)
> gcc_qsort (address (), length (), sizeof (T), cmp);
>}
>
>
>
>
>template<typename T, typename A>
>inline void
>vec<T, A, vl_embed>::sort (int (*cmp) (const void *, const void *, void *),
> void *data)
>{
> if (length () > 1)
> gcc_sort_r (address (), length (), sizeof (T), cmp, data);
>}
>
>
>
>
>
>template<typename T, typename A>
>inline T *
>vec<T, A, vl_embed>::bsearch (const void *key,
> int (*compar) (const void *, const void *))
>{
> const void *base = this->address ();
> size_t nmemb = this->length ();
> size_t size = sizeof (T);
>
> size_t l, u, idx;
> const void *p;
> int comparison;
>
> l = 0;
> u = nmemb;
> while (l < u)
> {
> idx = (l + u) / 2;
> p = (const void *) (((const char *) base) + (idx * size));
> comparison = (*compar) (key, p);
> if (comparison < 0)
> u = idx;
> else if (comparison > 0)
> l = idx + 1;
> else
> return (T *)const_cast<void *>(p);
> }
>
> return 
># 1172 "../../gcc/vec.h" 3 4
> 0L
># 1172 "../../gcc/vec.h"
> ;
>}
>
>
>
>
>template<typename T, typename A>
>inline T *
>vec<T, A, vl_embed>::bsearch (const void *key,
> int (*compar) (const void *, const void *,
> void *), void *data)
>{
> const void *base = this->address ();
> size_t nmemb = this->length ();
> size_t size = sizeof (T);
>
> size_t l, u, idx;
> const void *p;
> int comparison;
>
> l = 0;
> u = nmemb;
> while (l < u)
> {
> idx = (l + u) / 2;
> p = (const void *) (((const char *) base) + (idx * size));
> comparison = (*compar) (key, p, data);
> if (comparison < 0)
> u = idx;
> else if (comparison > 0)
> l = idx + 1;
> else
> return (T *)const_cast<void *>(p);
> }
>
> return 
># 1207 "../../gcc/vec.h" 3 4
> 0L
># 1207 "../../gcc/vec.h"
> ;
>}
>
>
>
>
>template<typename T, typename A>
>inline bool
>vec<T, A, vl_embed>::contains (const T &search) const
>{
> unsigned int len = length ();
> for (unsigned int i = 0; i < len; i++)
> if ((*this)[i] == search)
> return true;
>
> return false;
>}
>
>
>
>
>
>
>template<typename T, typename A>
>unsigned
>vec<T, A, vl_embed>::lower_bound (T obj, bool (*lessthan)(const T &, const T &))
> const
>{
> unsigned int len = length ();
> unsigned int half, middle;
> unsigned int first = 0;
> while (len > 0)
> {
> half = len / 2;
> middle = first;
> middle += half;
> T middle_elem = (*this)[middle];
> if (lessthan (middle_elem, obj))
> {
> first = middle;
> ++first;
> len = len - half - 1;
> }
> else
> len = half;
> }
> return first;
>}
># 1269 "../../gcc/vec.h"
>template<typename T, typename A>
>inline size_t
>vec<T, A, vl_embed>::embedded_size (unsigned alloc)
>{
> typedef vec<T, A, vl_embed> vec_embedded;
> return 
># 1274 "../../gcc/vec.h" 3 4
> __builtin_offsetof (
># 1274 "../../gcc/vec.h"
> vec_embedded
># 1274 "../../gcc/vec.h" 3 4
> , 
># 1274 "../../gcc/vec.h"
> m_vecdata
># 1274 "../../gcc/vec.h" 3 4
> ) 
># 1274 "../../gcc/vec.h"
> + alloc * sizeof (T);
>}
>
>
>
>
>
>template<typename T, typename A>
>inline void
>vec<T, A, vl_embed>::embedded_init (unsigned alloc, unsigned num, unsigned aut)
>{
> m_vecpfx.m_alloc = alloc;
> m_vecpfx.m_using_auto_storage = aut;
> m_vecpfx.m_num = num;
>}
>
>
>
>
>
>template<typename T, typename A>
>inline void
>vec<T, A, vl_embed>::quick_grow (unsigned len)
>{
> ((void)(!(length () <= len && len <= m_vecpfx.m_alloc) ? fancy_abort ("../../gcc/vec.h", 1298, __FUNCTION__), 0 : 0));
> m_vecpfx.m_num = len;
>}
>
>
>
>
>
>template<typename T, typename A>
>inline void
>vec<T, A, vl_embed>::quick_grow_cleared (unsigned len)
>{
> unsigned oldlen = length ();
> size_t growby = len - oldlen;
> quick_grow (len);
> if (growby != 0)
> vec_default_construct (address () + oldlen, growby);
>}
>
>
>
>template<typename T>
>void
>gt_ggc_mx (vec<T, va_gc> *v)
>{
> extern void gt_ggc_mx (T &);
> for (unsigned i = 0; i < v->length (); i++)
> gt_ggc_mx ((*v)[i]);
>}
>
>template<typename T>
>void
>gt_ggc_mx (vec<T, va_gc_atomic, vl_embed> *v __attribute__ ((__unused__)))
>{
>
>
>}
>
>
>
>
>template<typename T, typename A>
>void
>gt_pch_nx (vec<T, A, vl_embed> *v)
>{
> extern void gt_pch_nx (T &);
> for (unsigned i = 0; i < v->length (); i++)
> gt_pch_nx ((*v)[i]);
>}
>
>template<typename T, typename A>
>void
>gt_pch_nx (vec<T *, A, vl_embed> *v, gt_pointer_operator op, void *cookie)
>{
> for (unsigned i = 0; i < v->length (); i++)
> op (&((*v)[i]), cookie);
>}
>
>template<typename T, typename A>
>void
>gt_pch_nx (vec<T, A, vl_embed> *v, gt_pointer_operator op, void *cookie)
>{
> extern void gt_pch_nx (T *, gt_pointer_operator, void *);
> for (unsigned i = 0; i < v->length (); i++)
> gt_pch_nx (&((*v)[i]), op, cookie);
>}
># 1394 "../../gcc/vec.h"
>template<typename T>
>struct vec<T, va_heap, vl_ptr>
>{
>public:
>
>
> void create (unsigned nelems );
> void release (void);
>
>
> bool exists (void) const
> { return m_vec != 
># 1405 "../../gcc/vec.h" 3 4
> 0L
># 1405 "../../gcc/vec.h"
> ; }
>
> bool is_empty (void) const
> { return m_vec ? m_vec->is_empty () : true; }
>
> unsigned length (void) const
> { return m_vec ? m_vec->length () : 0; }
>
> T *address (void)
> { return m_vec ? m_vec->m_vecdata : 
># 1414 "../../gcc/vec.h" 3 4
> 0L
># 1414 "../../gcc/vec.h"
> ; }
>
> const T *address (void) const
> { return m_vec ? m_vec->m_vecdata : 
># 1417 "../../gcc/vec.h" 3 4
> 0L
># 1417 "../../gcc/vec.h"
> ; }
>
> T *begin () { return address (); }
> const T *begin () const { return address (); }
> T *end () { return begin () + length (); }
> const T *end () const { return begin () + length (); }
> const T &operator[] (unsigned ix) const
> { return (*m_vec)[ix]; }
>
> bool operator!=(const vec &other) const
> { return !(*this == other); }
>
> bool operator==(const vec &other) const
> { return address () == other.address (); }
>
> T &operator[] (unsigned ix)
> { return (*m_vec)[ix]; }
>
> T &last (void)
> { return m_vec->last (); }
>
> bool space (int nelems) const
> { return m_vec ? m_vec->space (nelems) : nelems == 0; }
>
> bool iterate (unsigned ix, T *p) const;
> bool iterate (unsigned ix, T **p) const;
> vec copy () const;
> bool reserve (unsigned, bool = false );
> bool reserve_exact (unsigned );
> void splice (const vec &);
> void safe_splice (const vec & );
> T *quick_push (const T &);
> T *safe_push (const T &);
> T &pop (void);
> void truncate (unsigned);
> void safe_grow (unsigned );
> void safe_grow_cleared (unsigned );
> void quick_grow (unsigned);
> void quick_grow_cleared (unsigned);
> void quick_insert (unsigned, const T &);
> void safe_insert (unsigned, const T & );
> void ordered_remove (unsigned);
> void unordered_remove (unsigned);
> void block_remove (unsigned, unsigned);
> void qsort (int (*) (const void *, const void *));
> void sort (int (*) (const void *, const void *, void *), void *);
> T *bsearch (const void *key, int (*compar)(const void *, const void *));
> T *bsearch (const void *key,
> int (*compar)(const void *, const void *, void *), void *);
> unsigned lower_bound (T, bool (*)(const T &, const T &)) const;
> bool contains (const T &search) const;
> void reverse (void);
>
> bool using_auto_storage () const;
>
>
>
> vec<T, va_heap, vl_embed> *m_vec;
>};
># 1484 "../../gcc/vec.h"
>template<typename T, size_t N = 0>
>class auto_vec : public vec<T, va_heap>
>{
>public:
> auto_vec ()
> {
> m_auto.embedded_init (((N) > (2) ? (N) : (2)), 0, 1);
> this->m_vec = &m_auto;
> }
>
> auto_vec (size_t s)
> {
> if (s > N)
> {
> this->create (s);
> return;
> }
>
> m_auto.embedded_init (((N) > (2) ? (N) : (2)), 0, 1);
> this->m_vec = &m_auto;
> }
>
> ~auto_vec ()
> {
> this->release ();
> }
>
>private:
> vec<T, va_heap, vl_embed> m_auto;
> T m_data[((N - 1) > (1) ? (N - 1) : (1))];
>};
>
>
>
>template<typename T>
>class auto_vec<T, 0> : public vec<T, va_heap>
>{
>public:
> auto_vec () { this->m_vec = 
># 1522 "../../gcc/vec.h" 3 4
> 0L
># 1522 "../../gcc/vec.h"
> ; }
> auto_vec (size_t n) { this->create (n); }
> ~auto_vec () { this->release (); }
>};
>
>
>
>
>
>
>template<typename T>
>inline void
>vec_alloc (vec<T> *&v, unsigned nelems )
>{
> v = new vec<T>;
> v->create (nelems );
>}
>
>
>
>
>
>class auto_string_vec : public auto_vec <char *>
>{
> public:
> ~auto_string_vec ();
>};
># 1562 "../../gcc/vec.h"
>template <typename T>
>class auto_delete_vec : public auto_vec <T *>
>{
> public:
> auto_delete_vec () {}
> auto_delete_vec (size_t s) : auto_vec <T *> (s) {}
>
> ~auto_delete_vec ();
>
>private:
> auto_delete_vec<T> (const auto_delete_vec<T>&) = delete; void operator= (const auto_delete_vec<T> &) = delete;
>};
>
>
>
>template<typename T>
>inline void
>vec_check_alloc (vec<T, va_heap> *&vec, unsigned nelems )
>{
> if (!vec)
> vec_alloc (vec, nelems );
>}
>
>
>
>
>template<typename T>
>inline void
>vec_free (vec<T> *&v)
>{
> if (v == 
># 1592 "../../gcc/vec.h" 3 4
> 0L
># 1592 "../../gcc/vec.h"
> )
> return;
>
> v->release ();
> delete v;
> v = 
># 1597 "../../gcc/vec.h" 3 4
> 0L
># 1597 "../../gcc/vec.h"
> ;
>}
># 1608 "../../gcc/vec.h"
>template<typename T>
>inline bool
>vec<T, va_heap, vl_ptr>::iterate (unsigned ix, T *ptr) const
>{
> if (m_vec)
> return m_vec->iterate (ix, ptr);
> else
> {
> *ptr = 0;
> return false;
> }
>}
># 1631 "../../gcc/vec.h"
>template<typename T>
>inline bool
>vec<T, va_heap, vl_ptr>::iterate (unsigned ix, T **ptr) const
>{
> if (m_vec)
> return m_vec->iterate (ix, ptr);
> else
> {
> *ptr = 0;
> return false;
> }
>}
># 1670 "../../gcc/vec.h"
>inline
>auto_string_vec::~auto_string_vec ()
>{
> int i;
> char *str;
> for (i = 0; (*this).iterate ((i), &(str)); ++(i))
> free (str);
>}
>
>
>
>
>template <typename T>
>inline
>auto_delete_vec<T>::~auto_delete_vec ()
>{
> int i;
> T *item;
> for (i = 0; (*this).iterate ((i), &(item)); ++(i))
> delete item;
>}
>
>
>
>
>template<typename T>
>inline vec<T, va_heap, vl_ptr>
>vec<T, va_heap, vl_ptr>::copy (void) const
>{
> vec<T, va_heap, vl_ptr> new_vec = vNULL;
> if (length ())
> new_vec.m_vec = m_vec->copy ();
> return new_vec;
>}
># 1715 "../../gcc/vec.h"
>template<typename T>
>inline bool
>vec<T, va_heap, vl_ptr>::reserve (unsigned nelems, bool exact )
>{
> if (space (nelems))
> return false;
>
>
>
>
> vec<T, va_heap, vl_embed> *oldvec = m_vec;
> unsigned int oldsize = 0;
> bool handle_auto_vec = m_vec && using_auto_storage ();
> if (handle_auto_vec)
> {
> m_vec = 
># 1730 "../../gcc/vec.h" 3 4
> 0L
># 1730 "../../gcc/vec.h"
> ;
> oldsize = oldvec->length ();
> nelems += oldsize;
> }
>
> va_heap::reserve (m_vec, nelems, exact );
> if (handle_auto_vec)
> {
> vec_copy_construct (m_vec->address (), oldvec->address (), oldsize);
> m_vec->m_vecpfx.m_num = oldsize;
> }
>
> return true;
>}
>
>
>
>
>
>
>
>template<typename T>
>inline bool
>vec<T, va_heap, vl_ptr>::reserve_exact (unsigned nelems )
>{
> return reserve (nelems, true );
>}
>
>
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::create (unsigned nelems )
>{
> m_vec = 
># 1768 "../../gcc/vec.h" 3 4
> 0L
># 1768 "../../gcc/vec.h"
> ;
> if (nelems > 0)
> reserve_exact (nelems );
>}
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::release (void)
>{
> if (!m_vec)
> return;
>
> if (using_auto_storage ())
> {
> m_vec->m_vecpfx.m_num = 0;
> return;
> }
>
> va_heap::release (m_vec);
>}
>
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::splice (const vec<T, va_heap, vl_ptr> &src)
>{
> if (src.length ())
> m_vec->splice (*(src.m_vec));
>}
>
>
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::safe_splice (const vec<T, va_heap, vl_ptr> &src
> )
>{
> if (src.length ())
> {
> reserve_exact (src.length ());
> splice (src);
> }
>}
>
>
>
>
>
>
>template<typename T>
>inline T *
>vec<T, va_heap, vl_ptr>::quick_push (const T &obj)
>{
> return m_vec->quick_push (obj);
>}
>
>
>
>
>
>
>template<typename T>
>inline T *
>vec<T, va_heap, vl_ptr>::safe_push (const T &obj )
>{
> reserve (1, false );
> return quick_push (obj);
>}
>
>
>
>
>template<typename T>
>inline T &
>vec<T, va_heap, vl_ptr>::pop (void)
>{
> return m_vec->pop ();
>}
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::truncate (unsigned size)
>{
> if (m_vec)
> m_vec->truncate (size);
> else
> ((void)(!(size == 0) ? fancy_abort ("../../gcc/vec.h", 1869, __FUNCTION__), 0 : 0));
>}
>
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::safe_grow (unsigned len )
>{
> unsigned oldlen = length ();
> ((void)(!(oldlen <= len) ? fancy_abort ("../../gcc/vec.h", 1882, __FUNCTION__), 0 : 0));
> reserve_exact (len - oldlen );
> if (m_vec)
> m_vec->quick_grow (len);
> else
> ((void)(!(len == 0) ? fancy_abort ("../../gcc/vec.h", 1887, __FUNCTION__), 0 : 0));
>}
>
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::safe_grow_cleared (unsigned len )
>{
> unsigned oldlen = length ();
> size_t growby = len - oldlen;
> safe_grow (len );
> if (growby != 0)
> vec_default_construct (address () + oldlen, growby);
>}
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::quick_grow (unsigned len)
>{
> ((void)(!(m_vec) ? fancy_abort ("../../gcc/vec.h", 1914, __FUNCTION__), 0 : 0));
> m_vec->quick_grow (len);
>}
>
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::quick_grow_cleared (unsigned len)
>{
> ((void)(!(m_vec) ? fancy_abort ("../../gcc/vec.h", 1927, __FUNCTION__), 0 : 0));
> m_vec->quick_grow_cleared (len);
>}
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::quick_insert (unsigned ix, const T &obj)
>{
> m_vec->quick_insert (ix, obj);
>}
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::safe_insert (unsigned ix, const T &obj )
>{
> reserve (1, false );
> quick_insert (ix, obj);
>}
>
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::ordered_remove (unsigned ix)
>{
> m_vec->ordered_remove (ix);
>}
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::unordered_remove (unsigned ix)
>{
> m_vec->unordered_remove (ix);
>}
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::block_remove (unsigned ix, unsigned len)
>{
> m_vec->block_remove (ix, len);
>}
>
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::qsort (int (*cmp) (const void *, const void *))
>{
> if (m_vec)
> m_vec->qsort (cmp);
>}
>
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::sort (int (*cmp) (const void *, const void *,
> void *), void *data)
>{
> if (m_vec)
> m_vec->sort (cmp, data);
>}
>
>
>
>
>
>template<typename T>
>inline T *
>vec<T, va_heap, vl_ptr>::bsearch (const void *key,
> int (*cmp) (const void *, const void *))
>{
> if (m_vec)
> return m_vec->bsearch (key, cmp);
> return 
># 2023 "../../gcc/vec.h" 3 4
> 0L
># 2023 "../../gcc/vec.h"
> ;
>}
>
>
>
>
>template<typename T>
>inline T *
>vec<T, va_heap, vl_ptr>::bsearch (const void *key,
> int (*cmp) (const void *, const void *,
> void *), void *data)
>{
> if (m_vec)
> return m_vec->bsearch (key, cmp, data);
> return 
># 2037 "../../gcc/vec.h" 3 4
> 0L
># 2037 "../../gcc/vec.h"
> ;
>}
>
>
>
>
>
>
>
>template<typename T>
>inline unsigned
>vec<T, va_heap, vl_ptr>::lower_bound (T obj,
> bool (*lessthan)(const T &, const T &))
> const
>{
> return m_vec ? m_vec->lower_bound (obj, lessthan) : 0;
>}
>
>
>
>
>template<typename T>
>inline bool
>vec<T, va_heap, vl_ptr>::contains (const T &search) const
>{
> return m_vec ? m_vec->contains (search) : false;
>}
>
>
>
>template<typename T>
>inline void
>vec<T, va_heap, vl_ptr>::reverse (void)
>{
> unsigned l = length ();
> T *ptr = address ();
>
> for (unsigned i = 0; i < l / 2; i++)
> std::swap (ptr[i], ptr[l - i - 1]);
>}
>
>template<typename T>
>inline bool
>vec<T, va_heap, vl_ptr>::using_auto_storage () const
>{
> return m_vec->m_vecpfx.m_using_auto_storage;
>}
>
>
>
>template<typename T>
>inline void
>release_vec_vec (vec<vec<T> > &vec)
>{
> for (unsigned i = 0; i < vec.length (); i++)
> vec[i].release ();
>
> vec.release ();
>}
>
>
> 
># 34 "../../gcc/read-md.c" 2
># 1 "../../gcc/read-md.h" 1
># 23 "../../gcc/read-md.h"
># 1 "../../gcc/../include/obstack.h" 1
># 111 "../../gcc/../include/obstack.h"
># 1 "/home/iii/gcc/regtest-f8a59086423e/build/prev-gcc/include/stddef.h" 1 3 4
># 112 "../../gcc/../include/obstack.h" 2
># 153 "../../gcc/../include/obstack.h"
>extern "C" {
>
>
>struct _obstack_chunk
>{
> char *limit;
> struct _obstack_chunk *prev;
> char contents[4];
>};
>
>struct obstack
>{
> size_t chunk_size;
> struct _obstack_chunk *chunk;
> char *object_base;
> char *next_free;
> char *chunk_limit;
> union
> {
> size_t i;
> void *p;
> } temp;
> size_t alignment_mask;
>
>
> union
> {
> void *(*plain) (size_t);
> void *(*extra) (void *, size_t);
> } chunkfun;
> union
> {
> void (*plain) (void *);
> void (*extra) (void *, void *);
> } freefun;
>
> void *extra_arg;
> unsigned use_extra_arg : 1;
> unsigned maybe_empty_object : 1;
>
>
>
> unsigned alloc_failed : 1;
>
>
>};
>
>
>
>extern void _obstack_newchunk (struct obstack *, size_t);
>extern void _obstack_free (struct obstack *, void *);
>extern int _obstack_begin (struct obstack *,
> size_t, size_t,
> void *(*) (size_t), void (*) (void *));
>extern int _obstack_begin_1 (struct obstack *,
> size_t, size_t,
> void *(*) (void *, size_t),
> void (*) (void *, void *), void *);
>extern size_t _obstack_memory_used (struct obstack *)
> __attribute__ ((__pure__));
>
>
>
>
>
>
>extern void (*obstack_alloc_failed_handler) (void);
>
>
>extern int obstack_exit_failure;
># 532 "../../gcc/../include/obstack.h"
>}
># 24 "../../gcc/read-md.h" 2
>
>
>class file_location {
>public:
> file_location () {}
> file_location (const char *, int, int);
>
> const char *filename;
> int lineno;
> int colno;
>};
>
>inline file_location::file_location (const char *filename_in, int lineno_in, int colno_in)
>: filename (filename_in), lineno (lineno_in), colno (colno_in) {}
>
>
>struct md_name {
>
>
> char buffer[256];
>
>
>
> char *string;
>};
>
>
>
>struct md_constant {
>
> char *name;
>
>
> char *value;
>
>
>
> struct enum_type *parent_enum;
>};
>
>
>struct enum_value {
>
> struct enum_value *next;
>
>
> char *name;
>
>
> struct md_constant *def;
>};
>
>
>struct enum_type {
>
> char *name;
>
>
>
> bool md_p;
>
>
> struct enum_value *values;
>
>
> struct enum_value **tail_ptr;
>
>
> unsigned int num_values;
>};
>
>
>struct overloaded_instance {
>
> overloaded_instance *next;
>
>
>
> vec<const char *> arg_values;
>
>
> const char *name;
>
>
> rtx insn;
>};
>
>
>
>
>
>struct overloaded_name {
>
> overloaded_name *next;
>
>
>
> const char *name;
>
>
>
>
> vec<const char *> arg_types;
>
>
> overloaded_instance *first_instance;
>
>
> overloaded_instance **next_instance_ptr;
>};
>
>struct mapping;
># 149 "../../gcc/read-md.h"
>class md_reader
>{
> public:
>
>
> struct ptr_loc {
> const void *ptr;
> file_location loc;
> };
>
> md_reader (bool compact);
> virtual ~md_reader ();
>
> bool read_md_files (int, const char **, bool (*) (const char *));
> bool read_file (const char *filename);
> bool read_file_fragment (const char *filename,
> int first_line,
> int last_line);
>
>
>
>
>
> virtual void handle_unknown_directive (file_location, const char *) = 0;
>
> file_location get_current_location () const;
>
> bool is_compact () const { return m_compact; }
>
>
> int read_char (void);
> void unread_char (int ch);
> file_location read_name (struct md_name *name);
> file_location read_name_or_nil (struct md_name *);
> void read_escape ();
> char *read_quoted_string ();
> char *read_braced_string ();
> char *read_string (int star_if_braced);
> void read_skip_construct (int depth, file_location loc);
> void require_char (char expected);
> void require_char_ws (char expected);
> void require_word_ws (const char *expected);
> int peek_char (void);
>
> void set_md_ptr_loc (const void *ptr, file_location);
> const struct ptr_loc *get_md_ptr_loc (const void *ptr);
> void copy_md_ptr_loc (const void *new_ptr, const void *old_ptr);
> void fprint_md_ptr_loc (FILE *outf, const void *ptr);
> void print_md_ptr_loc (const void *ptr);
>
> struct enum_type *lookup_enum_type (const char *name);
> void traverse_enum_types (htab_trav callback, void *info);
>
> void handle_constants ();
> void traverse_md_constants (htab_trav callback, void *info);
> void handle_enum (file_location loc, bool md_p);
>
> const char *join_c_conditions (const char *cond1, const char *cond2);
> void fprint_c_condition (FILE *outf, const char *cond);
> void print_c_condition (const char *cond);
>
>
> const char *apply_iterator_to_string (const char *string);
> rtx copy_rtx_for_iterators (rtx original);
> void read_conditions ();
> void record_potential_iterator_use (struct iterator_group *group,
> file_location loc, rtx x,
> unsigned int index, const char *name);
> struct mapping *read_mapping (struct iterator_group *group, htab_t table);
> overloaded_name *handle_overloaded_name (rtx, vec<mapping *> *);
>
> const char *get_top_level_filename () const { return m_toplevel_fname; }
> const char *get_filename () const { return m_read_md_filename; }
> int get_lineno () const { return m_read_md_lineno; }
> int get_colno () const { return m_read_md_colno; }
>
> struct obstack *get_string_obstack () { return &m_string_obstack; }
> htab_t get_md_constants () { return m_md_constants; }
>
> overloaded_name *get_overloads () const { return m_first_overload; }
>
> private:
>
> struct file_name_list {
> struct file_name_list *next;
> const char *fname;
> };
>
> private:
> void handle_file ();
> void handle_toplevel_file ();
> void handle_include (file_location loc);
> void add_include_path (const char *arg);
>
> bool read_name_1 (struct md_name *name, file_location *out_loc);
>
> private:
>
> bool m_compact;
>
>
>
> const char *m_toplevel_fname;
>
>
>
> char *m_base_dir;
>
>
> FILE *m_read_md_file;
>
>
> const char *m_read_md_filename;
>
>
> int m_read_md_lineno;
>
>
> int m_read_md_colno;
>
>
>
>
> int m_last_line_colno;
>
>
> file_name_list *m_first_dir_md_include;
>
>
> file_name_list **m_last_dir_md_include_ptr;
>
>
> struct obstack m_string_obstack;
>
>
> htab_t m_ptr_locs;
>
>
>
> struct obstack m_ptr_loc_obstack;
>
>
>
>
>
> htab_t m_joined_conditions;
>
>
> struct obstack m_joined_conditions_obstack;
>
>
>
> htab_t m_md_constants;
>
>
> htab_t m_enum_types;
>
>
> int m_first_line;
> int m_last_line;
>
>
> overloaded_name *m_first_overload;
>
>
> overloaded_name **m_next_overload_ptr;
>
>
>
> htab_t m_overloads_htab;
>};
>
>
>extern md_reader *md_reader_ptr;
>
>
>
>
>class noop_reader : public md_reader
>{
> public:
> noop_reader () : md_reader (false) {}
>
>
> void handle_unknown_directive (file_location, const char *);
>};
>
>
>
>
>
>
>class rtx_reader : public md_reader
>{
> public:
> rtx_reader (bool compact);
> ~rtx_reader ();
>
> bool read_rtx (const char *rtx_name, vec<rtx> *rtxen);
> rtx rtx_alloc_for_name (const char *);
> rtx read_rtx_code (const char *code_name);
> virtual rtx read_rtx_operand (rtx return_rtx, int idx);
> rtx read_nested_rtx ();
> rtx read_rtx_variadic (rtx form);
> char *read_until (const char *terminator_chars, bool consume_terminator);
>
> virtual void handle_any_trailing_information (rtx) {}
> virtual rtx postprocess (rtx x) { return x; }
>
>
>
>
> virtual const char *finalize_string (char *stringbuf) { return stringbuf; }
>
> protected:
>
> bool m_in_call_function_usage;
>
>
> auto_vec<rtx> m_reuse_rtx_by_id;
>};
>
>
>extern rtx_reader *rtx_reader_ptr;
>
>extern void (*include_callback) (const char *);
>
>
>
>static inline int
>read_char (void)
>{
> return md_reader_ptr->read_char ();
>}
>
>
>
>static inline void
>unread_char (int ch)
>{
> md_reader_ptr->unread_char (ch);
>}
>
>extern hashval_t leading_string_hash (const void *);
>extern int leading_string_eq_p (const void *, const void *);
>extern const char *join_c_conditions (const char *, const char *);
>extern void message_at (file_location, const char *, ...) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__nonnull__ (2)));
>extern void error_at (file_location, const char *, ...) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__nonnull__ (2)));
>extern void fatal_at (file_location, const char *, ...) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__nonnull__ (2)));
>extern void fatal_with_file_and_line (const char *, ...)
> __attribute__ ((__format__ (__printf__, 1, 2))) __attribute__ ((__nonnull__ (1))) __attribute__ ((__noreturn__));
>extern void fatal_expected_char (int, int) __attribute__ ((__noreturn__));
>extern int read_skip_spaces (void);
>extern int n_comma_elts (const char *);
>extern const char *scan_comma_elt (const char **);
>extern void upcase_string (char *);
>extern void traverse_enum_types (htab_trav, void *);
>extern struct enum_type *lookup_enum_type (const char *);
># 35 "../../gcc/read-md.c" 2
># 48 "../../gcc/read-md.c"
>void (*include_callback) (const char *);
>
>
>
>md_reader *md_reader_ptr;
>
>
>
>
>hashval_t
>leading_string_hash (const void *def)
>{
> return htab_hash_string (*(const char *const *) def);
>}
>
>
>
>
>int
>leading_string_eq_p (const void *def1, const void *def2)
>{
> return strcmp (*(const char *const *) def1,
> *(const char *const *) def2) == 0;
>}
>
>
>
>static hashval_t
>leading_ptr_hash (const void *def)
>{
> return htab_hash_pointer (*(const void *const *) def);
>}
>
>
>
>static int
>leading_ptr_eq_p (const void *def1, const void *def2)
>{
> return *(const void *const *) def1 == *(const void *const *) def2;
>}
>
>
>
>void
>md_reader::set_md_ptr_loc (const void *ptr, file_location file_loc)
>{
> struct ptr_loc *loc;
>
> loc = (struct ptr_loc *) __extension__ ({ struct obstack *__h = (&m_ptr_loc_obstack); __extension__ ({ struct obstack *__o = (__h); size_t __len = ((sizeof (struct ptr_loc))); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < __len) _obstack_newchunk (__o, __len); ((void) ((__o)->next_free += (__len))); }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (ptrdiff_t) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (ptrdiff_t) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if ((size_t) (__o1->next_free - (char *) __o1->chunk) > (size_t) (__o1->chunk_limit - (char *) __o1->chunk)) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); })
> ;
> loc->ptr = ptr;
> loc->loc = file_loc;
> *htab_find_slot (m_ptr_locs, loc, INSERT) = loc;
>}
>
>
>
>
>const md_reader::ptr_loc *
>md_reader::get_md_ptr_loc (const void *ptr)
>{
> return (const struct ptr_loc *) htab_find (m_ptr_locs, &ptr);
>}
>
>
>
>void
>md_reader::copy_md_ptr_loc (const void *new_ptr, const void *old_ptr)
>{
> const struct ptr_loc *loc = get_md_ptr_loc (old_ptr);
> if (loc != 0)
> set_md_ptr_loc (new_ptr, loc->loc);
>}
>
>
>
>
>void
>md_reader::fprint_md_ptr_loc (FILE *outf, const void *ptr)
>{
> const struct ptr_loc *loc = get_md_ptr_loc (ptr);
> if (loc != 0)
> fprintf (outf, "#line %d \"%s\"\n", loc->loc.lineno, loc->loc.filename);
>}
>
>
>void
>md_reader::print_md_ptr_loc (const void *ptr)
>{
> fprint_md_ptr_loc (
># 137 "../../gcc/read-md.c" 3 4
> (stdout)
># 137 "../../gcc/read-md.c"
> , ptr);
>}
>
>
>
>
>const char *
>md_reader::join_c_conditions (const char *cond1, const char *cond2)
>{
> char *result;
> const void **entry;
>
> if (cond1 == 0 || cond1[0] == 0)
> return cond2;
>
> if (cond2 == 0 || cond2[0] == 0)
> return cond1;
>
> if (strcmp (cond1, cond2) == 0)
> return cond1;
>
> result = concat ("(", cond1, ") && (", cond2, ")", 
># 158 "../../gcc/read-md.c" 3 4
> 0L
># 158 "../../gcc/read-md.c"
> );
> __extension__ ({ struct obstack *__o = (&m_joined_conditions_obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < sizeof (void *)) _obstack_newchunk (__o, sizeof (void *)); __extension__ ({ struct obstack *__o1 = (__o); void *__p1 = __o1->next_free; *(const void **) __p1 = (result); __o1->next_free += sizeof (const void *); (void) 0; }); });
> __extension__ ({ struct obstack *__o = (&m_joined_conditions_obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < sizeof (void *)) _obstack_newchunk (__o, sizeof (void *)); __extension__ ({ struct obstack *__o1 = (__o); void *__p1 = __o1->next_free; *(const void **) __p1 = (cond1); __o1->next_free += sizeof (const void *); (void) 0; }); });
> __extension__ ({ struct obstack *__o = (&m_joined_conditions_obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < sizeof (void *)) _obstack_newchunk (__o, sizeof (void *)); __extension__ ({ struct obstack *__o1 = (__o); void *__p1 = __o1->next_free; *(const void **) __p1 = (cond2); __o1->next_free += sizeof (const void *); (void) 0; }); });
> entry = ((const void **) __extension__ ({ struct obstack *__o1 = ((&m_joined_conditions_obstack)); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (ptrdiff_t) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (ptrdiff_t) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if ((size_t) (__o1->next_free - (char *) __o1->chunk) > (size_t) (__o1->chunk_limit - (char *) __o1->chunk)) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }));
> *htab_find_slot (m_joined_conditions, entry, INSERT) = entry;
> return result;
>}
>
>
>
>
>
>
>void
>md_reader::fprint_c_condition (FILE *outf, const char *cond)
>{
> const char **halves = (const char **) htab_find (m_joined_conditions, &cond);
> if (halves != 0)
> {
> fprintf (outf, "(");
> fprint_c_condition (outf, halves[1]);
> fprintf (outf, " && ");
> fprint_c_condition (outf, halves[2]);
> fprintf (outf, ")");
> }
> else
> {
> fputc_unlocked ('\n', outf);
> fprint_md_ptr_loc (outf, cond);
> fprintf (outf, "(%s)", cond);
> }
>}
>
>
>
>void
>md_reader::print_c_condition (const char *cond)
>{
> fprint_c_condition (
># 197 "../../gcc/read-md.c" 3 4
> (stdout)
># 197 "../../gcc/read-md.c"
> , cond);
>}
>
>
>
>
>static void __attribute__ ((__format__ (__printf__, 2, 0))) __attribute__ ((__nonnull__ (2)))
>message_at_1 (file_location loc, const char *msg, va_list ap)
>{
> fprintf (
># 206 "../../gcc/read-md.c" 3 4
> (stderr)
># 206 "../../gcc/read-md.c"
> , "%s:%d:%d: ", loc.filename, loc.lineno, loc.colno);
> vfprintf (
># 207 "../../gcc/read-md.c" 3 4
> (stderr)
># 207 "../../gcc/read-md.c"
> , msg, ap);
> fputc_unlocked ('\n', 
># 208 "../../gcc/read-md.c" 3 4
> (stderr)
># 208 "../../gcc/read-md.c"
> );
>}
>
>
>
>void
>message_at (file_location loc, const char *msg, ...)
>{
> va_list ap;
>
> 
># 218 "../../gcc/read-md.c" 3 4
> __builtin_va_start(
># 218 "../../gcc/read-md.c"
> ap
># 218 "../../gcc/read-md.c" 3 4
> ,
># 218 "../../gcc/read-md.c"
> msg
># 218 "../../gcc/read-md.c" 3 4
> )
># 218 "../../gcc/read-md.c"
> ;
> message_at_1 (loc, msg, ap);
> 
># 220 "../../gcc/read-md.c" 3 4
> __builtin_va_end(
># 220 "../../gcc/read-md.c"
> ap
># 220 "../../gcc/read-md.c" 3 4
> )
># 220 "../../gcc/read-md.c"
> ;
>}
>
>
>
>void
>error_at (file_location loc, const char *msg, ...)
>{
> va_list ap;
>
> 
># 230 "../../gcc/read-md.c" 3 4
> __builtin_va_start(
># 230 "../../gcc/read-md.c"
> ap
># 230 "../../gcc/read-md.c" 3 4
> ,
># 230 "../../gcc/read-md.c"
> msg
># 230 "../../gcc/read-md.c" 3 4
> )
># 230 "../../gcc/read-md.c"
> ;
> message_at_1 (loc, msg, ap);
> 
># 232 "../../gcc/read-md.c" 3 4
> __builtin_va_end(
># 232 "../../gcc/read-md.c"
> ap
># 232 "../../gcc/read-md.c" 3 4
> )
># 232 "../../gcc/read-md.c"
> ;
> have_error = 1;
>}
>
>
>
>void
>fatal_at (file_location loc, const char *msg, ...)
>{
> va_list ap;
>
> 
># 243 "../../gcc/read-md.c" 3 4
> __builtin_va_start(
># 243 "../../gcc/read-md.c"
> ap
># 243 "../../gcc/read-md.c" 3 4
> ,
># 243 "../../gcc/read-md.c"
> msg
># 243 "../../gcc/read-md.c" 3 4
> )
># 243 "../../gcc/read-md.c"
> ;
> message_at_1 (loc, msg, ap);
> 
># 245 "../../gcc/read-md.c" 3 4
> __builtin_va_end(
># 245 "../../gcc/read-md.c"
> ap
># 245 "../../gcc/read-md.c" 3 4
> )
># 245 "../../gcc/read-md.c"
> ;
> exit (1);
>}
>
>
>
>
>void
>fatal_with_file_and_line (const char *msg, ...)
>{
> char context[64];
> size_t i;
> int c;
> va_list ap;
>
> 
># 260 "../../gcc/read-md.c" 3 4
> __builtin_va_start(
># 260 "../../gcc/read-md.c"
> ap
># 260 "../../gcc/read-md.c" 3 4
> ,
># 260 "../../gcc/read-md.c"
> msg
># 260 "../../gcc/read-md.c" 3 4
> )
># 260 "../../gcc/read-md.c"
> ;
>
> fprintf (
># 262 "../../gcc/read-md.c" 3 4
> (stderr)
># 262 "../../gcc/read-md.c"
> , "%s:%d:%d: error: ", md_reader_ptr->get_filename (),
> md_reader_ptr->get_lineno (),
> md_reader_ptr->get_colno ());
> vfprintf (
># 265 "../../gcc/read-md.c" 3 4
> (stderr)
># 265 "../../gcc/read-md.c"
> , msg, ap);
> putc_unlocked ('\n', 
># 266 "../../gcc/read-md.c" 3 4
> (stderr)
># 266 "../../gcc/read-md.c"
> );
>
>
> for (i = 0; i < sizeof (context)-1; ++i)
> {
> c = read_char ();
> if (c == 
># 272 "../../gcc/read-md.c" 3 4
> (-1)
># 272 "../../gcc/read-md.c"
> )
> break;
> if (c == '\r' || c == '\n')
> {
> unread_char (c);
> break;
> }
> context[i] = c;
> }
> context[i] = '\0';
>
> fprintf (
># 283 "../../gcc/read-md.c" 3 4
> (stderr)
># 283 "../../gcc/read-md.c"
> , "%s:%d:%d: note: following context is `%s'\n",
> md_reader_ptr->get_filename (),
> md_reader_ptr->get_lineno (),
> md_reader_ptr->get_colno (), context);
>
> 
># 288 "../../gcc/read-md.c" 3 4
> __builtin_va_end(
># 288 "../../gcc/read-md.c"
> ap
># 288 "../../gcc/read-md.c" 3 4
> )
># 288 "../../gcc/read-md.c"
> ;
> exit (1);
>}
>
>
>
>
>void
>fatal_expected_char (int expected, int actual)
>{
> if (actual == 
># 298 "../../gcc/read-md.c" 3 4
> (-1)
># 298 "../../gcc/read-md.c"
> )
> fatal_with_file_and_line ("expected character `%c', found EOF",
> expected);
> else
> fatal_with_file_and_line ("expected character `%c', found `%c'",
> expected, actual);
>}
>
>
>
>
>int
>read_skip_spaces (void)
>{
> int c;
>
> while (1)
> {
> c = read_char ();
> switch (c)
> {
> case ' ': case '\t': case '\f': case '\r': case '\n':
> break;
>
> case ';':
> do
> c = read_char ();
> while (c != '\n' && c != 
># 325 "../../gcc/read-md.c" 3 4
> (-1)
># 325 "../../gcc/read-md.c"
> );
> break;
>
> case '/':
> {
> int prevc;
> c = read_char ();
> if (c != '*')
> {
> unread_char (c);
> fatal_with_file_and_line ("stray '/' in file");
> }
>
> prevc = 0;
> while ((c = read_char ()) && c != 
># 339 "../../gcc/read-md.c" 3 4
> (-1)
># 339 "../../gcc/read-md.c"
> )
> {
> if (prevc == '*' && c == '/')
> break;
> prevc = c;
> }
> }
> break;
>
> default:
> return c;
> }
> }
>}
>
>
>
>
>void
>md_reader::require_char (char expected)
>{
> int ch = read_char ();
> if (ch != expected)
> fatal_expected_char (expected, ch);
>}
>
>
>
>
>void
>md_reader::require_char_ws (char expected)
>{
> int ch = read_skip_spaces ();
> if (ch != expected)
> fatal_expected_char (expected, ch);
>}
>
>
>
>
>void
>md_reader::require_word_ws (const char *expected)
>{
> struct md_name name;
> read_name (&name);
> if (strcmp (name.string, expected))
> fatal_with_file_and_line ("missing '%s'", expected);
>}
>
>
>
>int
>md_reader::read_char (void)
>{
> int ch;
>
> ch = getc_unlocked (m_read_md_file);
> if (ch == '\n')
> {
> m_read_md_lineno++;
> m_last_line_colno = m_read_md_colno;
> m_read_md_colno = 0;
> }
> else
> m_read_md_colno++;
>
>
>
> if (m_first_line && m_last_line)
> {
> if (m_read_md_lineno < m_first_line)
> return ' ';
> if (m_read_md_lineno > m_last_line)
> return 
># 412 "../../gcc/read-md.c" 3 4
> (-1)
># 412 "../../gcc/read-md.c"
> ;
> }
>
> return ch;
>}
>
>
>
>void
>md_reader::unread_char (int ch)
>{
> if (ch == '\n')
> {
> m_read_md_lineno--;
> m_read_md_colno = m_last_line_colno;
> }
> else
> m_read_md_colno--;
> ungetc (ch, m_read_md_file);
>}
>
>
>
>int
>md_reader::peek_char (void)
>{
> int ch = read_char ();
> unread_char (ch);
> return ch;
>}
>
>
>
>
>bool
>md_reader::read_name_1 (struct md_name *name, file_location *out_loc)
>{
> int c;
> size_t i;
> int angle_bracket_depth;
>
> c = read_skip_spaces ();
>
> *out_loc = get_current_location ();
>
> i = 0;
> angle_bracket_depth = 0;
> while (1)
> {
> if (c == '<')
> angle_bracket_depth++;
>
> if ((c == '>') && (angle_bracket_depth > 0))
> angle_bracket_depth--;
>
> if (c == ' ' || c == '\n' || c == '\t' || c == '\f' || c == '\r'
> || c == 
># 468 "../../gcc/read-md.c" 3 4
> (-1)
># 468 "../../gcc/read-md.c"
> )
> break;
> if (angle_bracket_depth == 0)
> {
> if (c == ':' || c == ')' || c == ']'
> || c == '"' || c == '/' || c == '(' || c == '[')
> {
> unread_char (c);
> break;
> }
> }
>
> if (i == sizeof (name->buffer) - 1)
> fatal_with_file_and_line ("name too long");
> name->buffer[i++] = c;
>
> c = read_char ();
> }
>
> if (i == 0)
> return false;
>
> name->buffer[i] = 0;
> name->string = name->buffer;
>
> if (m_md_constants)
> {
>
> struct md_constant *def;
>
> do
> {
> struct md_constant tmp_def;
>
> tmp_def.name = name->string;
> def = (struct md_constant *) htab_find (m_md_constants, &tmp_def);
> if (def)
> name->string = def->value;
> }
> while (def);
> }
>
> return true;
>}
>
>
>
>
>file_location
>md_reader::read_name (struct md_name *name)
>{
> file_location loc;
> if (!read_name_1 (name, &loc))
> fatal_with_file_and_line ("missing name or number");
> return loc;
>}
>
>file_location
>md_reader::read_name_or_nil (struct md_name *name)
>{
> file_location loc;
> if (!read_name_1 (name, &loc))
> {
> file_location loc = get_current_location ();
> read_skip_construct (0, loc);
>
> read_char ();
> name->buffer[0] = 0;
> name->string = name->buffer;
> }
> return loc;
>}
>
>
>
>
>void
>md_reader::read_escape ()
>{
> int c = read_char ();
>
> switch (c)
> {
>
> case '\n':
> return;
>
>
> case '\\':
> case '"':
> case '\'':
> break;
># 570 "../../gcc/read-md.c"
> case 'a': case 'b': case 'f': case 'n': case 'r': case 't': case 'v':
> case '0': case '1': case '2': case '3': case '4': case '5': case '6':
> case '7': case 'x':
> __extension__ ({ struct obstack *__o = (&m_string_obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)++ = ('\\'))); });
> break;
>
>
>
> case ';':
> __extension__ ({ struct obstack *__o = (&m_string_obstack); size_t __len = (4); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o->next_free, "\\n\\t", __len); __o->next_free += __len; (void) 0; });
> return;
>
>
> default:
> fprintf (
># 584 "../../gcc/read-md.c" 3 4
> (stderr)
># 584 "../../gcc/read-md.c"
> , "%s:%d: warning: unrecognized escape \\%c\n",
> get_filename (), get_lineno (),
> c);
> __extension__ ({ struct obstack *__o = (&m_string_obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)++ = ('\\'))); });
> break;
> }
>
> __extension__ ({ struct obstack *__o = (&m_string_obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)++ = (c))); });
>}
>
>
>
>
>char *
>md_reader::read_quoted_string ()
>{
> int c;
>
> while (1)
> {
> c = read_char ();
> if (c == '\\')
> {
> read_escape ();
> continue;
> }
> else if (c == '"' || c == 
># 610 "../../gcc/read-md.c" 3 4
> (-1)
># 610 "../../gcc/read-md.c"
> )
> break;
>
> __extension__ ({ struct obstack *__o = (&m_string_obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)++ = (c))); });
> }
>
> __extension__ ({ struct obstack *__o = (&m_string_obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)++ = (0))); });
> return ((char *) __extension__ ({ struct obstack *__o1 = ((&m_string_obstack)); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (ptrdiff_t) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (ptrdiff_t) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if ((size_t) (__o1->next_free - (char *) __o1->chunk) > (size_t) (__o1->chunk_limit - (char *) __o1->chunk)) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }));
>}
>
>
>
>
>
>char *
>md_reader::read_braced_string ()
>{
> int c;
> int brace_depth = 1;
> unsigned long starting_read_md_lineno = get_lineno ();
>
> __extension__ ({ struct obstack *__o = (&m_string_obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)++ = ('{'))); });
> while (brace_depth)
> {
> c = read_char ();
>
> if (c == '{')
> brace_depth++;
> else if (c == '}')
> brace_depth--;
> else if (c == '\\')
> {
> read_escape ();
> continue;
> }
> else if (c == 
># 645 "../../gcc/read-md.c" 3 4
> (-1)
># 645 "../../gcc/read-md.c"
> )
> fatal_with_file_and_line
> ("missing closing } for opening brace on line %lu",
> starting_read_md_lineno);
>
> __extension__ ({ struct obstack *__o = (&m_string_obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)++ = (c))); });
> }
>
> __extension__ ({ struct obstack *__o = (&m_string_obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)++ = (0))); });
> return ((char *) __extension__ ({ struct obstack *__o1 = ((&m_string_obstack)); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (ptrdiff_t) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (ptrdiff_t) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if ((size_t) (__o1->next_free - (char *) __o1->chunk) > (size_t) (__o1->chunk_limit - (char *) __o1->chunk)) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }));
>}
>
>
>
>
>
>char *
>md_reader::read_string (int star_if_braced)
>{
> char *stringbuf;
> int saw_paren = 0;
> int c;
>
> c = read_skip_spaces ();
> if (c == '(')
> {
> saw_paren = 1;
> c = read_skip_spaces ();
> }
>
> file_location loc = get_current_location ();
> if (c == '"')
> stringbuf = read_quoted_string ();
> else if (c == '{')
> {
> if (star_if_braced)
> __extension__ ({ struct obstack *__o = (&m_string_obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)++ = ('*'))); });
> stringbuf = read_braced_string ();
> }
> else if (saw_paren && c == 'n')
> {
>
> require_char ('i');
> require_char ('l');
> require_char_ws (')');
> return 
># 690 "../../gcc/read-md.c" 3 4
> 0L
># 690 "../../gcc/read-md.c"
> ;
> }
> else
> fatal_with_file_and_line ("expected `\"' or `{', found `%c'", c);
>
> if (saw_paren)
> require_char_ws (')');
>
> set_md_ptr_loc (stringbuf, loc);
> return stringbuf;
>}
>
>
>
>
>void
>md_reader::read_skip_construct (int depth, file_location loc)
>{
> struct md_name name;
> int c;
>
> do
> {
> c = read_skip_spaces ();
> if (c == 
># 714 "../../gcc/read-md.c" 3 4
> (-1)
># 714 "../../gcc/read-md.c"
> )
> {
> error_at (loc, "unterminated construct");
> exit (1);
> }
> switch (c)
> {
> case '(':
> depth++;
> break;
>
> case ')':
> depth--;
> break;
>
> case ':':
> case '[':
> case ']':
> case '/':
> break;
>
> case '\"':
> case '{':
> unread_char (c);
> read_string (false);
> break;
>
> default:
> unread_char (c);
> read_name (&name);
> break;
> }
> }
> while (depth > 0);
> unread_char (c);
>}
>
>
>
>
>int
>n_comma_elts (const char *s)
>{
> int n;
>
> if (*s == '\0')
> return 0;
>
> for (n = 1; *s; s++)
> if (*s == ',')
> n++;
>
> return n;
>}
>
>
>
>
>
>
>
>const char *
>scan_comma_elt (const char **pstr)
>{
> const char *start;
> const char *p = *pstr;
>
> if (*p == ',')
> p++;
> while ((_sch_istable[(*p) & 0xff] & (unsigned short)(_sch_isspace)))
> p++;
>
> if (*p == '\0')
> return 
># 787 "../../gcc/read-md.c" 3 4
> 0L
># 787 "../../gcc/read-md.c"
> ;
>
> start = p;
>
> while (*p != ',' && *p != '\0')
> p++;
>
> *pstr = p;
> return start;
>}
>
>
>
>void
>upcase_string (char *string)
>{
> int i;
>
> for (i = 0; string[i]; i++)
> string[i] = _sch_toupper[(string[i]) & 0xff];
>}
>
>
>
>
>
>static struct md_constant *
>add_constant (htab_t defs, char *name, char *value,
> struct enum_type *parent_enum)
>{
> struct md_constant *def, tmp_def;
> void **entry_ptr;
>
> tmp_def.name = name;
> entry_ptr = htab_find_slot (defs, &tmp_def, INSERT);
> if (*entry_ptr)
> {
> def = (struct md_constant *) *entry_ptr;
> if (strcmp (def->value, value) != 0)
> fatal_with_file_and_line ("redefinition of `%s', was `%s', now `%s'",
> def->name, def->value, value);
> else if (parent_enum || def->parent_enum)
> fatal_with_file_and_line ("redefinition of `%s'", def->name);
> free (name);
> free (value);
> }
> else
> {
> def = ((struct md_constant *) xmalloc (sizeof (struct md_constant)));
> def->name = name;
> def->value = value;
> def->parent_enum = parent_enum;
> *entry_ptr = def;
> }
> return def;
>}
>
>
>
>
>void
>md_reader::handle_constants ()
>{
> int c;
> htab_t defs;
>
> require_char_ws ('[');
>
>
> defs = m_md_constants;
> m_md_constants = 0;
> while ( (c = read_skip_spaces ()) != ']')
> {
> struct md_name name, value;
>
> if (c != '(')
> fatal_expected_char ('(', c);
>
> read_name (&name);
> read_name (&value);
> add_constant (defs, xstrdup (name.string), xstrdup (value.string), 0);
>
> require_char_ws (')');
> }
> m_md_constants = defs;
>}
>
>
>
>
>
>void
>md_reader::traverse_md_constants (htab_trav callback, void *info)
>{
> htab_traverse (get_md_constants (), callback, info);
>}
>
>
>
>static char *
>md_decimal_string (int number)
>{
>
> char buffer[sizeof (int) * 8 + 1 + 1];
>
> sprintf (buffer, "%d", number);
> return xstrdup (buffer);
>}
>
>
>
>
>
>
>void
>md_reader::handle_enum (file_location loc, bool md_p)
>{
> char *enum_name, *value_name;
> struct md_name name;
> struct enum_type *def;
> struct enum_value *ev;
> void **slot;
> int c;
>
> enum_name = read_string (false);
> slot = htab_find_slot (m_enum_types, &enum_name, INSERT);
> if (*slot)
> {
> def = (struct enum_type *) *slot;
> if (def->md_p != md_p)
> error_at (loc, "redefining `%s' as a different type of enum",
> enum_name);
> }
> else
> {
> def = ((struct enum_type *) xmalloc (sizeof (struct enum_type)));
> def->name = enum_name;
> def->md_p = md_p;
> def->values = 0;
> def->tail_ptr = &def->values;
> def->num_values = 0;
> *slot = def;
> }
>
> require_char_ws ('[');
>
> while ((c = read_skip_spaces ()) != ']')
> {
> if (c == 
># 935 "../../gcc/read-md.c" 3 4
> (-1)
># 935 "../../gcc/read-md.c"
> )
> {
> error_at (loc, "unterminated construct");
> exit (1);
> }
> unread_char (c);
> read_name (&name);
>
> ev = ((struct enum_value *) xmalloc (sizeof (struct enum_value)));
> ev->next = 0;
> if (md_p)
> {
> value_name = concat (def->name, "_", name.string, 
># 947 "../../gcc/read-md.c" 3 4
> 0L
># 947 "../../gcc/read-md.c"
> );
> upcase_string (value_name);
> ev->name = xstrdup (name.string);
> }
> else
> {
> value_name = xstrdup (name.string);
> ev->name = value_name;
> }
> ev->def = add_constant (get_md_constants (), value_name,
> md_decimal_string (def->num_values), def);
>
> *def->tail_ptr = ev;
> def->tail_ptr = &ev->next;
> def->num_values++;
> }
>}
>
>
>
>struct enum_type *
>md_reader::lookup_enum_type (const char *name)
>{
> return (struct enum_type *) htab_find (m_enum_types, &name);
>}
>
>
>
>
>
>void
>md_reader::traverse_enum_types (htab_trav callback, void *info)
>{
> htab_traverse (m_enum_types, callback, info);
>}
>
>
>
>
>md_reader::md_reader (bool compact)
>: m_compact (compact),
> m_toplevel_fname (
># 988 "../../gcc/read-md.c" 3 4
> 0L
># 988 "../../gcc/read-md.c"
> ),
> m_base_dir (
># 989 "../../gcc/read-md.c" 3 4
> 0L
># 989 "../../gcc/read-md.c"
> ),
> m_read_md_file (
># 990 "../../gcc/read-md.c" 3 4
> 0L
># 990 "../../gcc/read-md.c"
> ),
> m_read_md_filename (
># 991 "../../gcc/read-md.c" 3 4
> 0L
># 991 "../../gcc/read-md.c"
> ),
> m_read_md_lineno (0),
> m_read_md_colno (0),
> m_first_dir_md_include (
># 994 "../../gcc/read-md.c" 3 4
> 0L
># 994 "../../gcc/read-md.c"
> ),
> m_last_dir_md_include_ptr (&m_first_dir_md_include),
> m_first_line (0),
> m_last_line (0),
> m_first_overload (
># 998 "../../gcc/read-md.c" 3 4
> 0L
># 998 "../../gcc/read-md.c"
> ),
> m_next_overload_ptr (&m_first_overload),
> m_overloads_htab (
># 1000 "../../gcc/read-md.c" 3 4
> 0L
># 1000 "../../gcc/read-md.c"
> )
>{
>
> md_reader_ptr = this;
>
> _obstack_begin ((&m_string_obstack), 0, 0, (xmalloc), (free));
>
> m_ptr_locs = htab_create (161, leading_ptr_hash, leading_ptr_eq_p, 0);
> _obstack_begin ((&m_ptr_loc_obstack), 0, 0, (xmalloc), (free));
>
> m_joined_conditions = htab_create (161, leading_ptr_hash, leading_ptr_eq_p, 0);
> _obstack_begin ((&m_joined_conditions_obstack), 0, 0, (xmalloc), (free));
>
> m_md_constants = htab_create (31, leading_string_hash,
> leading_string_eq_p, (htab_del) 0);
>
> m_enum_types = htab_create (31, leading_string_hash,
> leading_string_eq_p, (htab_del) 0);
>
>
> unlock_std_streams ();
>}
>
>
>
>md_reader::~md_reader ()
>{
> free (m_base_dir);
>
> htab_delete (m_enum_types);
>
> htab_delete (m_md_constants);
>
> __extension__ ({ struct obstack *__o = (&m_joined_conditions_obstack); void *__obj = (void *) (
># 1033 "../../gcc/read-md.c" 3 4
> 0L
># 1033 "../../gcc/read-md.c"
> ); if (__obj > (void *) __o->chunk && __obj < (void *) __o->chunk_limit) __o->next_free = __o->object_base = (char *) __obj; else _obstack_free (__o, __obj); });
> htab_delete (m_joined_conditions);
>
> __extension__ ({ struct obstack *__o = (&m_ptr_loc_obstack); void *__obj = (void *) (
># 1036 "../../gcc/read-md.c" 3 4
> 0L
># 1036 "../../gcc/read-md.c"
> ); if (__obj > (void *) __o->chunk && __obj < (void *) __o->chunk_limit) __o->next_free = __o->object_base = (char *) __obj; else _obstack_free (__o, __obj); });
> htab_delete (m_ptr_locs);
>
> __extension__ ({ struct obstack *__o = (&m_string_obstack); void *__obj = (void *) (
># 1039 "../../gcc/read-md.c" 3 4
> 0L
># 1039 "../../gcc/read-md.c"
> ); if (__obj > (void *) __o->chunk && __obj < (void *) __o->chunk_limit) __o->next_free = __o->object_base = (char *) __obj; else _obstack_free (__o, __obj); });
>
>
> md_reader_ptr = 
># 1042 "../../gcc/read-md.c" 3 4
> 0L
># 1042 "../../gcc/read-md.c"
> ;
>}
>
>
>
>
>
>
>void
>md_reader::handle_include (file_location loc)
>{
> const char *filename;
> const char *old_filename;
> int old_lineno, old_colno;
> char *pathname;
> FILE *input_file, *old_file;
>
> filename = read_string (false);
> input_file = 
># 1060 "../../gcc/read-md.c" 3 4
> 0L
># 1060 "../../gcc/read-md.c"
> ;
>
>
> if (!(((((filename)[0]) == '/') || ((((filename)[0]) == '\\') && (0))) || ((filename)[0] && ((filename)[1] == ':') && (0))))
> {
> struct file_name_list *stackp;
>
>
> for (stackp = m_first_dir_md_include; stackp; stackp = stackp->next)
> {
> static const char sep[2] = { '/', '\0' };
>
> pathname = concat (stackp->fname, sep, filename, 
># 1072 "../../gcc/read-md.c" 3 4
> 0L
># 1072 "../../gcc/read-md.c"
> );
> input_file = fopen_unlocked (pathname, "r");
> if (input_file != 
># 1074 "../../gcc/read-md.c" 3 4
> 0L
># 1074 "../../gcc/read-md.c"
> )
> break;
> free (pathname);
> }
> }
>
>
>
> if (input_file == 
># 1082 "../../gcc/read-md.c" 3 4
> 0L
># 1082 "../../gcc/read-md.c"
> )
> {
> if (m_base_dir)
> pathname = concat (m_base_dir, filename, 
># 1085 "../../gcc/read-md.c" 3 4
> 0L
># 1085 "../../gcc/read-md.c"
> );
> else
> pathname = xstrdup (filename);
> input_file = fopen_unlocked (pathname, "r");
> }
>
> if (input_file == 
># 1091 "../../gcc/read-md.c" 3 4
> 0L
># 1091 "../../gcc/read-md.c"
> )
> {
> free (pathname);
> error_at (loc, "include file `%s' not found", filename);
> return;
> }
>
>
>
>
> old_file = m_read_md_file;
> old_filename = m_read_md_filename;
> old_lineno = m_read_md_lineno;
> old_colno = m_read_md_colno;
>
> if (include_callback)
> include_callback (pathname);
>
> m_read_md_file = input_file;
> m_read_md_filename = pathname;
>
> handle_file ();
>
>
> m_read_md_file = old_file;
> m_read_md_filename = old_filename;
> m_read_md_lineno = old_lineno;
> m_read_md_colno = old_colno;
>
>
>
>}
>
>
>
>
>
>void
>md_reader::handle_file ()
>{
> struct md_name directive;
> int c;
>
> m_read_md_lineno = 1;
> m_read_md_colno = 0;
> while ((c = read_skip_spaces ()) != 
># 1136 "../../gcc/read-md.c" 3 4
> (-1)
># 1136 "../../gcc/read-md.c"
> )
> {
> file_location loc = get_current_location ();
> if (c != '(')
> fatal_expected_char ('(', c);
>
> read_name (&directive);
> if (strcmp (directive.string, "define_constants") == 0)
> handle_constants ();
> else if (strcmp (directive.string, "define_enum") == 0)
> handle_enum (loc, true);
> else if (strcmp (directive.string, "define_c_enum") == 0)
> handle_enum (loc, false);
> else if (strcmp (directive.string, "include") == 0)
> handle_include (loc);
> else
> handle_unknown_directive (loc, directive.string);
>
> require_char_ws (')');
> }
> fclose (m_read_md_file);
>}
>
>
>
>
>void
>md_reader::handle_toplevel_file ()
>{
> const char *base;
>
> m_toplevel_fname = m_read_md_filename;
> base = lbasename (m_toplevel_fname);
> if (base == m_toplevel_fname)
> m_base_dir = 
># 1170 "../../gcc/read-md.c" 3 4
> 0L
># 1170 "../../gcc/read-md.c"
> ;
> else
> m_base_dir = xstrndup (m_toplevel_fname, base - m_toplevel_fname);
>
> handle_file ();
>}
>
>file_location
>md_reader::get_current_location () const
>{
> return file_location (m_read_md_filename, m_read_md_lineno, m_read_md_colno);
>}
>
>
>
>void
>md_reader::add_include_path (const char *arg)
>{
> struct file_name_list *dirtmp;
>
> dirtmp = ((struct file_name_list *) xmalloc (sizeof (struct file_name_list)));
> dirtmp->next = 0;
> dirtmp->fname = arg;
> *m_last_dir_md_include_ptr = dirtmp;
> m_last_dir_md_include_ptr = &dirtmp->next;
>}
># 1208 "../../gcc/read-md.c"
>bool
>md_reader::read_md_files (int argc, const char **argv,
> bool (*parse_opt) (const char *))
>{
> int i;
> bool no_more_options;
> bool already_read_stdin;
> int num_files;
>
>
> for (i = 1; i < argc; i++)
> if (argv[i][0] == '-')
> {
>
>
> if (argv[i][1] == '\0')
> continue;
>
>
>
> if (argv[i][1] == '-' && argv[i][2] == '\0')
> break;
>
> if (argv[i][1] == 'I')
> {
> if (argv[i][2] != '\0')
> add_include_path (argv[i] + 2);
> else if (++i < argc)
> add_include_path (argv[i]);
> else
> fatal ("directory name missing after -I option");
> continue;
> }
>
>
>
> if (parse_opt && parse_opt (argv[i]))
> continue;
>
> fatal ("invalid option `%s'", argv[i]);
> }
>
>
> num_files = 0;
> no_more_options = false;
> already_read_stdin = false;
> for (i = 1; i < argc; i++)
> {
> if (argv[i][0] == '-')
> {
> if (argv[i][1] == '\0')
> {
>
> if (already_read_stdin)
> fatal ("cannot read standard input twice");
>
> m_read_md_file = 
># 1264 "../../gcc/read-md.c" 3 4
> (stdin)
># 1264 "../../gcc/read-md.c"
> ;
> m_read_md_filename = "<stdin>";
> handle_toplevel_file ();
> already_read_stdin = true;
> continue;
> }
> else if (argv[i][1] == '-' && argv[i][2] == '\0')
> {
>
> no_more_options = true;
> continue;
> }
> else if (!no_more_options)
> continue;
> }
>
>
>
> m_read_md_filename = argv[i];
> m_read_md_file = fopen_unlocked (m_read_md_filename, "r");
> if (m_read_md_file == 0)
> {
> perror (m_read_md_filename);
> return false;
> }
> handle_toplevel_file ();
> num_files++;
> }
>
>
>
> if (num_files == 0 && !already_read_stdin)
> {
> m_read_md_file = 
># 1297 "../../gcc/read-md.c" 3 4
> (stdin)
># 1297 "../../gcc/read-md.c"
> ;
> m_read_md_filename = "<stdin>";
> handle_toplevel_file ();
> }
>
> return !have_error;
>}
>
>
>
>
>
>bool
>md_reader::read_file (const char *filename)
>{
> m_read_md_filename = filename;
> m_read_md_file = fopen_unlocked (m_read_md_filename, "r");
> if (m_read_md_file == 0)
> {
> perror (m_read_md_filename);
> return false;
> }
> handle_toplevel_file ();
> return !have_error;
>}
>
>
>
>bool
>md_reader::read_file_fragment (const char *filename,
> int first_line,
> int last_line)
>{
> m_read_md_filename = filename;
> m_read_md_file = fopen_unlocked (m_read_md_filename, "r");
> if (m_read_md_file == 0)
> {
> perror (m_read_md_filename);
> return false;
> }
> m_first_line = first_line;
> m_last_line = last_line;
> handle_toplevel_file ();
> return !have_error;
>}
>
>
>
>
>void
>noop_reader::handle_unknown_directive (file_location loc, const char *)
>{
> read_skip_construct (1, loc);
>}

Actions: View

Attachments on bug 95700: 48740 | 48750 | 48917 | 48921