* Memory leak in ifcvt.c
@ 2008-06-28 22:16 Daniel Berlin
2008-06-28 23:52 ` Kenneth Zadeck
0 siblings, 1 reply; 8+ messages in thread
From: Daniel Berlin @ 2008-06-28 22:16 UTC (permalink / raw)
To: gcc-patches, Kenneth Zadeck
Kenny, I think you were the one who touched this file last, i could be wrong.
Anyway, cond_move_process_if_block leaks allocated vectors (about
5-10k memory per function compiled).
WHat happens is this:
check_cond_move_block pushes things onto a heap allocated vector with
vec_safe_push.
Sometimes, it decides it can't do a conditional move after pushing
things onto the vector, and returns false.
Which causes cond_move_process_if to return FALSE here:
/* Make sure the blocks are suitable. */
if (!check_cond_move_block (then_bb, then_vals, then_regs, cond)
|| (else_bb && !check_cond_move_block (else_bb, else_vals,
else_regs, cond)))
return FALSE;
However, the *only* place that then_regs and else_regs are freed is at
the bottom of cond_move_process_if right before it returns TRUE.
So when it returns false, it leaks the reg vectors.
Simple fix is to free them before we return false (note that this also
means you have to split up the conditional above, since the
conditional will leak then_regs if it returns false because of the
second part.
--Dan
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: Memory leak in ifcvt.c
2008-06-28 22:16 Memory leak in ifcvt.c Daniel Berlin
@ 2008-06-28 23:52 ` Kenneth Zadeck
2008-06-29 0:10 ` Daniel Berlin
0 siblings, 1 reply; 8+ messages in thread
From: Kenneth Zadeck @ 2008-06-28 23:52 UTC (permalink / raw)
To: Daniel Berlin; +Cc: gcc-patches
Daniel Berlin wrote:
> Kenny, I think you were the one who touched this file last, i could be wrong.
>
> Anyway, cond_move_process_if_block leaks allocated vectors (about
> 5-10k memory per function compiled).
>
> WHat happens is this:
>
> check_cond_move_block pushes things onto a heap allocated vector with
> vec_safe_push.
>
> Sometimes, it decides it can't do a conditional move after pushing
> things onto the vector, and returns false.
>
> Which causes cond_move_process_if to return FALSE here:
>
> /* Make sure the blocks are suitable. */
> if (!check_cond_move_block (then_bb, then_vals, then_regs, cond)
> || (else_bb && !check_cond_move_block (else_bb, else_vals,
> else_regs, cond)))
> return FALSE;
>
> However, the *only* place that then_regs and else_regs are freed is at
> the bottom of cond_move_process_if right before it returns TRUE.
>
> So when it returns false, it leaks the reg vectors.
>
> Simple fix is to free them before we return false (note that this also
> means you have to split up the conditional above, since the
> conditional will leak then_regs if it returns false because of the
> second part.
>
> --Dan
>
i will fix this, thanks.
is there a particular test case or platform?
kenny
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: Memory leak in ifcvt.c
2008-06-28 23:52 ` Kenneth Zadeck
@ 2008-06-29 0:10 ` Daniel Berlin
2008-06-30 12:47 ` Kenneth Zadeck
0 siblings, 1 reply; 8+ messages in thread
From: Daniel Berlin @ 2008-06-29 0:10 UTC (permalink / raw)
To: Kenneth Zadeck; +Cc: gcc-patches
[-- Attachment #1: Type: text/plain, Size: 1583 bytes --]
The way i saw it was with the attached file running valgrind
--leak-check=full ./cc1 -O2 regex.i
(It also shows df leaks memory, i sent the trace to stevenb)
I only noticed it while i was debugging something else.
On Sat, Jun 28, 2008 at 7:40 PM, Kenneth Zadeck
<zadeck@naturalbridge.com> wrote:
> Daniel Berlin wrote:
>>
>> Kenny, I think you were the one who touched this file last, i could be
>> wrong.
>>
>> Anyway, cond_move_process_if_block leaks allocated vectors (about
>> 5-10k memory per function compiled).
>>
>> WHat happens is this:
>>
>> check_cond_move_block pushes things onto a heap allocated vector with
>> vec_safe_push.
>>
>> Sometimes, it decides it can't do a conditional move after pushing
>> things onto the vector, and returns false.
>>
>> Which causes cond_move_process_if to return FALSE here:
>>
>> /* Make sure the blocks are suitable. */
>> if (!check_cond_move_block (then_bb, then_vals, then_regs, cond)
>> || (else_bb && !check_cond_move_block (else_bb, else_vals,
>> else_regs, cond)))
>> return FALSE;
>>
>> However, the *only* place that then_regs and else_regs are freed is at
>> the bottom of cond_move_process_if right before it returns TRUE.
>>
>> So when it returns false, it leaks the reg vectors.
>>
>> Simple fix is to free them before we return false (note that this also
>> means you have to split up the conditional above, since the
>> conditional will leak then_regs if it returns false because of the
>> second part.
>>
>> --Dan
>>
>
> i will fix this, thanks.
>
> is there a particular test case or platform?
>
> kenny
>
[-- Attachment #2: regex.i --]
[-- Type: application/octet-stream, Size: 151831 bytes --]
# 1 "../../libiberty/regex.c"
# 1 "/Users/dannyb/gccstuff/pre-globals/build/libiberty//"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "../../libiberty/regex.c"
# 39 "../../libiberty/regex.c"
# 1 "./config.h" 1
# 40 "../../libiberty/regex.c" 2
# 1 "../../libiberty/../include/ansidecl.h" 1
# 44 "../../libiberty/regex.c" 2
# 1 "/Users/dannyb/gccstuff/pre-globals/build/./prev-gcc/include/stddef.h" 1 3 4
# 152 "/Users/dannyb/gccstuff/pre-globals/build/./prev-gcc/include/stddef.h" 3 4
typedef int ptrdiff_t;
# 214 "/Users/dannyb/gccstuff/pre-globals/build/./prev-gcc/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 326 "/Users/dannyb/gccstuff/pre-globals/build/./prev-gcc/include/stddef.h" 3 4
typedef int wchar_t;
# 49 "../../libiberty/regex.c" 2
# 128 "../../libiberty/regex.c"
# 1 "/usr/include/stdlib.h" 1 3 4
# 61 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/available.h" 1 3 4
# 62 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/_types.h" 1 3 4
# 27 "/usr/include/_types.h" 3 4
# 1 "/usr/include/sys/_types.h" 1 3 4
# 32 "/usr/include/sys/_types.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 33 "/usr/include/sys/_types.h" 2 3 4
# 1 "/usr/include/machine/_types.h" 1 3 4
# 34 "/usr/include/machine/_types.h" 3 4
# 1 "/usr/include/i386/_types.h" 1 3 4
# 37 "/usr/include/i386/_types.h" 3 4
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef short __int16_t;
typedef unsigned short __uint16_t;
typedef int __int32_t;
typedef unsigned int __uint32_t;
typedef long long __int64_t;
typedef unsigned long long __uint64_t;
typedef long __darwin_intptr_t;
typedef unsigned int __darwin_natural_t;
# 70 "/usr/include/i386/_types.h" 3 4
typedef int __darwin_ct_rune_t;
typedef union {
char __mbstate8[128];
long long _mbstateL;
} __mbstate_t;
typedef __mbstate_t __darwin_mbstate_t;
typedef int __darwin_ptrdiff_t;
typedef long unsigned int __darwin_size_t;
typedef __builtin_va_list __darwin_va_list;
typedef int __darwin_wchar_t;
typedef __darwin_wchar_t __darwin_rune_t;
typedef int __darwin_wint_t;
typedef unsigned long __darwin_clock_t;
typedef __uint32_t __darwin_socklen_t;
typedef long __darwin_ssize_t;
typedef long __darwin_time_t;
# 35 "/usr/include/machine/_types.h" 2 3 4
# 34 "/usr/include/sys/_types.h" 2 3 4
# 58 "/usr/include/sys/_types.h" 3 4
struct __darwin_pthread_handler_rec
{
void (*__routine)(void *);
void *__arg;
struct __darwin_pthread_handler_rec *__next;
};
struct _opaque_pthread_attr_t { long __sig; char __opaque[36]; };
struct _opaque_pthread_cond_t { long __sig; char __opaque[24]; };
struct _opaque_pthread_condattr_t { long __sig; char __opaque[4]; };
struct _opaque_pthread_mutex_t { long __sig; char __opaque[40]; };
struct _opaque_pthread_mutexattr_t { long __sig; char __opaque[8]; };
struct _opaque_pthread_once_t { long __sig; char __opaque[4]; };
struct _opaque_pthread_rwlock_t { long __sig; char __opaque[124]; };
struct _opaque_pthread_rwlockattr_t { long __sig; char __opaque[12]; };
struct _opaque_pthread_t { long __sig; struct __darwin_pthread_handler_rec *__cleanup_stack; char __opaque[596]; };
# 94 "/usr/include/sys/_types.h" 3 4
typedef __int64_t __darwin_blkcnt_t;
typedef __int32_t __darwin_blksize_t;
typedef __int32_t __darwin_dev_t;
typedef unsigned int __darwin_fsblkcnt_t;
typedef unsigned int __darwin_fsfilcnt_t;
typedef __uint32_t __darwin_gid_t;
typedef __uint32_t __darwin_id_t;
typedef __uint64_t __darwin_ino64_t;
typedef __uint32_t __darwin_ino_t;
typedef __darwin_natural_t __darwin_mach_port_name_t;
typedef __darwin_mach_port_name_t __darwin_mach_port_t;
typedef __uint16_t __darwin_mode_t;
typedef __int64_t __darwin_off_t;
typedef __int32_t __darwin_pid_t;
typedef struct _opaque_pthread_attr_t
__darwin_pthread_attr_t;
typedef struct _opaque_pthread_cond_t
__darwin_pthread_cond_t;
typedef struct _opaque_pthread_condattr_t
__darwin_pthread_condattr_t;
typedef unsigned long __darwin_pthread_key_t;
typedef struct _opaque_pthread_mutex_t
__darwin_pthread_mutex_t;
typedef struct _opaque_pthread_mutexattr_t
__darwin_pthread_mutexattr_t;
typedef struct _opaque_pthread_once_t
__darwin_pthread_once_t;
typedef struct _opaque_pthread_rwlock_t
__darwin_pthread_rwlock_t;
typedef struct _opaque_pthread_rwlockattr_t
__darwin_pthread_rwlockattr_t;
typedef struct _opaque_pthread_t
*__darwin_pthread_t;
typedef __uint32_t __darwin_sigset_t;
typedef __int32_t __darwin_suseconds_t;
typedef __uint32_t __darwin_uid_t;
typedef __uint32_t __darwin_useconds_t;
typedef unsigned char __darwin_uuid_t[16];
# 28 "/usr/include/_types.h" 2 3 4
typedef int __darwin_nl_item;
typedef int __darwin_wctrans_t;
typedef unsigned long __darwin_wctype_t;
# 64 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/sys/wait.h" 1 3 4
# 79 "/usr/include/sys/wait.h" 3 4
typedef enum {
P_ALL,
P_PID,
P_PGID
} idtype_t;
typedef __darwin_pid_t pid_t;
typedef __darwin_id_t id_t;
# 116 "/usr/include/sys/wait.h" 3 4
# 1 "/usr/include/sys/signal.h" 1 3 4
# 73 "/usr/include/sys/signal.h" 3 4
# 1 "/usr/include/sys/appleapiopts.h" 1 3 4
# 74 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/machine/signal.h" 1 3 4
# 34 "/usr/include/machine/signal.h" 3 4
# 1 "/usr/include/i386/signal.h" 1 3 4
# 39 "/usr/include/i386/signal.h" 3 4
typedef int sig_atomic_t;
# 55 "/usr/include/i386/signal.h" 3 4
# 1 "/usr/include/i386/_structs.h" 1 3 4
# 56 "/usr/include/i386/signal.h" 2 3 4
# 35 "/usr/include/machine/signal.h" 2 3 4
# 82 "/usr/include/sys/signal.h" 2 3 4
# 154 "/usr/include/sys/signal.h" 3 4
# 1 "/usr/include/sys/_structs.h" 1 3 4
# 57 "/usr/include/sys/_structs.h" 3 4
# 1 "/usr/include/machine/_structs.h" 1 3 4
# 31 "/usr/include/machine/_structs.h" 3 4
# 1 "/usr/include/i386/_structs.h" 1 3 4
# 38 "/usr/include/i386/_structs.h" 3 4
# 1 "/usr/include/mach/i386/_structs.h" 1 3 4
# 43 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_thread_state
{
unsigned int __eax;
unsigned int __ebx;
unsigned int __ecx;
unsigned int __edx;
unsigned int __edi;
unsigned int __esi;
unsigned int __ebp;
unsigned int __esp;
unsigned int __ss;
unsigned int __eflags;
unsigned int __eip;
unsigned int __cs;
unsigned int __ds;
unsigned int __es;
unsigned int __fs;
unsigned int __gs;
};
# 89 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_fp_control
{
unsigned short __invalid :1,
__denorm :1,
__zdiv :1,
__ovrfl :1,
__undfl :1,
__precis :1,
:2,
__pc :2,
__rc :2,
:1,
:3;
};
typedef struct __darwin_fp_control __darwin_fp_control_t;
# 147 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_fp_status
{
unsigned short __invalid :1,
__denorm :1,
__zdiv :1,
__ovrfl :1,
__undfl :1,
__precis :1,
__stkflt :1,
__errsumm :1,
__c0 :1,
__c1 :1,
__c2 :1,
__tos :3,
__c3 :1,
__busy :1;
};
typedef struct __darwin_fp_status __darwin_fp_status_t;
# 191 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_mmst_reg
{
char __mmst_reg[10];
char __mmst_rsrv[6];
};
# 210 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_xmm_reg
{
char __xmm_reg[16];
};
# 232 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_float_state
{
int __fpu_reserved[2];
struct __darwin_fp_control __fpu_fcw;
struct __darwin_fp_status __fpu_fsw;
__uint8_t __fpu_ftw;
__uint8_t __fpu_rsrv1;
__uint16_t __fpu_fop;
__uint32_t __fpu_ip;
__uint16_t __fpu_cs;
__uint16_t __fpu_rsrv2;
__uint32_t __fpu_dp;
__uint16_t __fpu_ds;
__uint16_t __fpu_rsrv3;
__uint32_t __fpu_mxcsr;
__uint32_t __fpu_mxcsrmask;
struct __darwin_mmst_reg __fpu_stmm0;
struct __darwin_mmst_reg __fpu_stmm1;
struct __darwin_mmst_reg __fpu_stmm2;
struct __darwin_mmst_reg __fpu_stmm3;
struct __darwin_mmst_reg __fpu_stmm4;
struct __darwin_mmst_reg __fpu_stmm5;
struct __darwin_mmst_reg __fpu_stmm6;
struct __darwin_mmst_reg __fpu_stmm7;
struct __darwin_xmm_reg __fpu_xmm0;
struct __darwin_xmm_reg __fpu_xmm1;
struct __darwin_xmm_reg __fpu_xmm2;
struct __darwin_xmm_reg __fpu_xmm3;
struct __darwin_xmm_reg __fpu_xmm4;
struct __darwin_xmm_reg __fpu_xmm5;
struct __darwin_xmm_reg __fpu_xmm6;
struct __darwin_xmm_reg __fpu_xmm7;
char __fpu_rsrv4[14*16];
int __fpu_reserved1;
};
# 308 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_exception_state
{
unsigned int __trapno;
unsigned int __err;
unsigned int __faultvaddr;
};
# 326 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_debug_state32
{
unsigned int __dr0;
unsigned int __dr1;
unsigned int __dr2;
unsigned int __dr3;
unsigned int __dr4;
unsigned int __dr5;
unsigned int __dr6;
unsigned int __dr7;
};
# 358 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_thread_state64
{
__uint64_t __rax;
__uint64_t __rbx;
__uint64_t __rcx;
__uint64_t __rdx;
__uint64_t __rdi;
__uint64_t __rsi;
__uint64_t __rbp;
__uint64_t __rsp;
__uint64_t __r8;
__uint64_t __r9;
__uint64_t __r10;
__uint64_t __r11;
__uint64_t __r12;
__uint64_t __r13;
__uint64_t __r14;
__uint64_t __r15;
__uint64_t __rip;
__uint64_t __rflags;
__uint64_t __cs;
__uint64_t __fs;
__uint64_t __gs;
};
# 413 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_float_state64
{
int __fpu_reserved[2];
struct __darwin_fp_control __fpu_fcw;
struct __darwin_fp_status __fpu_fsw;
__uint8_t __fpu_ftw;
__uint8_t __fpu_rsrv1;
__uint16_t __fpu_fop;
__uint32_t __fpu_ip;
__uint16_t __fpu_cs;
__uint16_t __fpu_rsrv2;
__uint32_t __fpu_dp;
__uint16_t __fpu_ds;
__uint16_t __fpu_rsrv3;
__uint32_t __fpu_mxcsr;
__uint32_t __fpu_mxcsrmask;
struct __darwin_mmst_reg __fpu_stmm0;
struct __darwin_mmst_reg __fpu_stmm1;
struct __darwin_mmst_reg __fpu_stmm2;
struct __darwin_mmst_reg __fpu_stmm3;
struct __darwin_mmst_reg __fpu_stmm4;
struct __darwin_mmst_reg __fpu_stmm5;
struct __darwin_mmst_reg __fpu_stmm6;
struct __darwin_mmst_reg __fpu_stmm7;
struct __darwin_xmm_reg __fpu_xmm0;
struct __darwin_xmm_reg __fpu_xmm1;
struct __darwin_xmm_reg __fpu_xmm2;
struct __darwin_xmm_reg __fpu_xmm3;
struct __darwin_xmm_reg __fpu_xmm4;
struct __darwin_xmm_reg __fpu_xmm5;
struct __darwin_xmm_reg __fpu_xmm6;
struct __darwin_xmm_reg __fpu_xmm7;
struct __darwin_xmm_reg __fpu_xmm8;
struct __darwin_xmm_reg __fpu_xmm9;
struct __darwin_xmm_reg __fpu_xmm10;
struct __darwin_xmm_reg __fpu_xmm11;
struct __darwin_xmm_reg __fpu_xmm12;
struct __darwin_xmm_reg __fpu_xmm13;
struct __darwin_xmm_reg __fpu_xmm14;
struct __darwin_xmm_reg __fpu_xmm15;
char __fpu_rsrv4[6*16];
int __fpu_reserved1;
};
# 517 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_exception_state64
{
unsigned int __trapno;
unsigned int __err;
__uint64_t __faultvaddr;
};
# 535 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_debug_state64
{
__uint64_t __dr0;
__uint64_t __dr1;
__uint64_t __dr2;
__uint64_t __dr3;
__uint64_t __dr4;
__uint64_t __dr5;
__uint64_t __dr6;
__uint64_t __dr7;
};
# 39 "/usr/include/i386/_structs.h" 2 3 4
# 48 "/usr/include/i386/_structs.h" 3 4
struct __darwin_mcontext32
{
struct __darwin_i386_exception_state __es;
struct __darwin_i386_thread_state __ss;
struct __darwin_i386_float_state __fs;
};
# 68 "/usr/include/i386/_structs.h" 3 4
struct __darwin_mcontext64
{
struct __darwin_x86_exception_state64 __es;
struct __darwin_x86_thread_state64 __ss;
struct __darwin_x86_float_state64 __fs;
};
# 94 "/usr/include/i386/_structs.h" 3 4
typedef struct __darwin_mcontext32 *mcontext_t;
# 32 "/usr/include/machine/_structs.h" 2 3 4
# 58 "/usr/include/sys/_structs.h" 2 3 4
# 75 "/usr/include/sys/_structs.h" 3 4
struct __darwin_sigaltstack
{
void *ss_sp;
__darwin_size_t ss_size;
int ss_flags;
};
# 128 "/usr/include/sys/_structs.h" 3 4
struct __darwin_ucontext
{
int uc_onstack;
__darwin_sigset_t uc_sigmask;
struct __darwin_sigaltstack uc_stack;
struct __darwin_ucontext *uc_link;
__darwin_size_t uc_mcsize;
struct __darwin_mcontext32 *uc_mcontext;
};
# 218 "/usr/include/sys/_structs.h" 3 4
typedef struct __darwin_sigaltstack stack_t;
# 227 "/usr/include/sys/_structs.h" 3 4
typedef struct __darwin_ucontext ucontext_t;
# 155 "/usr/include/sys/signal.h" 2 3 4
# 163 "/usr/include/sys/signal.h" 3 4
typedef __darwin_pthread_attr_t pthread_attr_t;
typedef __darwin_sigset_t sigset_t;
# 178 "/usr/include/sys/signal.h" 3 4
typedef __darwin_uid_t uid_t;
union sigval {
int sival_int;
void *sival_ptr;
};
struct sigevent {
int sigev_notify;
int sigev_signo;
union sigval sigev_value;
void (*sigev_notify_function)(union sigval);
pthread_attr_t *sigev_notify_attributes;
};
typedef struct __siginfo {
int si_signo;
int si_errno;
int si_code;
pid_t si_pid;
uid_t si_uid;
int si_status;
void *si_addr;
union sigval si_value;
long si_band;
unsigned long __pad[7];
} siginfo_t;
# 292 "/usr/include/sys/signal.h" 3 4
union __sigaction_u {
void (*__sa_handler)(int);
void (*__sa_sigaction)(int, struct __siginfo *,
void *);
};
struct __sigaction {
union __sigaction_u __sigaction_u;
void (*sa_tramp)(void *, int, int, siginfo_t *, void *);
sigset_t sa_mask;
int sa_flags;
};
struct sigaction {
union __sigaction_u __sigaction_u;
sigset_t sa_mask;
int sa_flags;
};
# 354 "/usr/include/sys/signal.h" 3 4
typedef void (*sig_t)(int);
# 371 "/usr/include/sys/signal.h" 3 4
struct sigvec {
void (*sv_handler)(int);
int sv_mask;
int sv_flags;
};
# 390 "/usr/include/sys/signal.h" 3 4
struct sigstack {
char *ss_sp;
int ss_onstack;
};
# 412 "/usr/include/sys/signal.h" 3 4
void (*signal(int, void (*)(int)))(int);
# 117 "/usr/include/sys/wait.h" 2 3 4
# 1 "/usr/include/sys/resource.h" 1 3 4
# 76 "/usr/include/sys/resource.h" 3 4
# 1 "/usr/include/sys/_structs.h" 1 3 4
# 100 "/usr/include/sys/_structs.h" 3 4
struct timeval
{
__darwin_time_t tv_sec;
__darwin_suseconds_t tv_usec;
};
# 77 "/usr/include/sys/resource.h" 2 3 4
# 88 "/usr/include/sys/resource.h" 3 4
typedef __uint64_t rlim_t;
# 142 "/usr/include/sys/resource.h" 3 4
struct rusage {
struct timeval ru_utime;
struct timeval ru_stime;
# 153 "/usr/include/sys/resource.h" 3 4
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;
};
# 213 "/usr/include/sys/resource.h" 3 4
struct rlimit {
rlim_t rlim_cur;
rlim_t rlim_max;
};
# 235 "/usr/include/sys/resource.h" 3 4
int getpriority(int, id_t);
int getiopolicy_np(int, int);
int getrlimit(int, struct rlimit *) __asm("_" "getrlimit" "$UNIX2003");
int getrusage(int, struct rusage *);
int setpriority(int, id_t, int);
int setiopolicy_np(int, int, int);
int setrlimit(int, const struct rlimit *) __asm("_" "setrlimit" "$UNIX2003");
# 118 "/usr/include/sys/wait.h" 2 3 4
# 193 "/usr/include/sys/wait.h" 3 4
# 1 "/usr/include/machine/endian.h" 1 3 4
# 37 "/usr/include/machine/endian.h" 3 4
# 1 "/usr/include/i386/endian.h" 1 3 4
# 99 "/usr/include/i386/endian.h" 3 4
# 1 "/usr/include/sys/_endian.h" 1 3 4
# 124 "/usr/include/sys/_endian.h" 3 4
# 1 "/usr/include/libkern/_OSByteOrder.h" 1 3 4
# 66 "/usr/include/libkern/_OSByteOrder.h" 3 4
# 1 "/usr/include/libkern/i386/_OSByteOrder.h" 1 3 4
# 44 "/usr/include/libkern/i386/_OSByteOrder.h" 3 4
static __inline__
__uint16_t
_OSSwapInt16(
__uint16_t _data
)
{
return ((_data << 8) | (_data >> 8));
}
static __inline__
__uint32_t
_OSSwapInt32(
__uint32_t _data
)
{
__asm__ ("bswap %0" : "+r" (_data));
return _data;
}
static __inline__
__uint64_t
_OSSwapInt64(
__uint64_t _data
)
{
__asm__ ("bswap %%eax\n\t"
"bswap %%edx\n\t"
"xchgl %%eax, %%edx"
: "+A" (_data));
return _data;
}
# 67 "/usr/include/libkern/_OSByteOrder.h" 2 3 4
# 125 "/usr/include/sys/_endian.h" 2 3 4
# 100 "/usr/include/i386/endian.h" 2 3 4
# 38 "/usr/include/machine/endian.h" 2 3 4
# 194 "/usr/include/sys/wait.h" 2 3 4
union wait {
int w_status;
struct {
unsigned int w_Termsig:7,
w_Coredump:1,
w_Retcode:8,
w_Filler:16;
} w_T;
struct {
unsigned int w_Stopval:8,
w_Stopsig:8,
w_Filler:16;
} w_S;
};
# 254 "/usr/include/sys/wait.h" 3 4
pid_t wait(int *) __asm("_" "wait" "$UNIX2003");
pid_t waitpid(pid_t, int *, int) __asm("_" "waitpid" "$UNIX2003");
int waitid(idtype_t, id_t, siginfo_t *, int) __asm("_" "waitid" "$UNIX2003");
pid_t wait3(int *, int, struct rusage *);
pid_t wait4(pid_t, int *, int, struct rusage *);
# 66 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/alloca.h" 1 3 4
# 35 "/usr/include/alloca.h" 3 4
void *alloca(size_t);
# 68 "/usr/include/stdlib.h" 2 3 4
# 81 "/usr/include/stdlib.h" 3 4
typedef __darwin_ct_rune_t ct_rune_t;
typedef __darwin_rune_t rune_t;
# 97 "/usr/include/stdlib.h" 3 4
typedef struct {
int quot;
int rem;
} div_t;
typedef struct {
long quot;
long rem;
} ldiv_t;
typedef struct {
long long quot;
long long rem;
} lldiv_t;
# 134 "/usr/include/stdlib.h" 3 4
extern int __mb_cur_max;
# 144 "/usr/include/stdlib.h" 3 4
void abort(void) __attribute__((__noreturn__));
int abs(int) __attribute__((__const__));
int atexit(void (*)(void));
double atof(const char *);
int atoi(const char *);
long atol(const char *);
long long
atoll(const char *);
void *bsearch(const void *, const void *, size_t,
size_t, int (*)(const void *, const void *));
void *calloc(size_t, size_t);
div_t div(int, int) __attribute__((__const__));
void exit(int) __attribute__((__noreturn__));
void free(void *);
char *getenv(const char *);
long labs(long) __attribute__((__const__));
ldiv_t ldiv(long, long) __attribute__((__const__));
long long
llabs(long long);
lldiv_t lldiv(long long, long long);
void *malloc(size_t);
int mblen(const char *, size_t);
size_t mbstowcs(wchar_t * , const char * , size_t);
int mbtowc(wchar_t * , const char * , size_t);
void qsort(void *, size_t, size_t,
int (*)(const void *, const void *));
int rand(void);
void *realloc(void *, size_t);
void srand(unsigned);
double strtod(const char *, char **) __asm("_" "strtod" "$UNIX2003");
float strtof(const char *, char **) __asm("_" "strtof" "$UNIX2003");
long strtol(const char *, char **, int);
long double
strtold(const char *, char **) ;
long long
strtoll(const char *, char **, int);
unsigned long
strtoul(const char *, char **, int);
unsigned long long
strtoull(const char *, char **, int);
int system(const char *) __asm("_" "system" "$UNIX2003");
size_t wcstombs(char * , const wchar_t * , size_t);
int wctomb(char *, wchar_t);
void _Exit(int) __attribute__((__noreturn__));
long a64l(const char *);
double drand48(void);
char *ecvt(double, int, int *, int *);
double erand48(unsigned short[3]);
char *fcvt(double, int, int *, int *);
char *gcvt(double, int, char *);
int getsubopt(char **, char * const *, char **);
int grantpt(int);
char *initstate(unsigned, char *, size_t);
long jrand48(unsigned short[3]);
char *l64a(long);
void lcong48(unsigned short[7]);
long lrand48(void);
char *mktemp(char *);
int mkstemp(char *);
long mrand48(void);
long nrand48(unsigned short[3]);
int posix_openpt(int);
char *ptsname(int);
int putenv(char *) __asm("_" "putenv" "$UNIX2003");
long random(void);
int rand_r(unsigned *);
char *realpath(const char * , char * ) __asm("_" "realpath" "$DARWIN_EXTSN");
unsigned short
*seed48(unsigned short[3]);
int setenv(const char *, const char *, int) __asm("_" "setenv" "$UNIX2003");
void setkey(const char *) __asm("_" "setkey" "$UNIX2003");
char *setstate(const char *);
void srand48(long);
void srandom(unsigned);
int unlockpt(int);
int unsetenv(const char *) __asm("_" "unsetenv" "$UNIX2003");
# 1 "/usr/include/machine/types.h" 1 3 4
# 37 "/usr/include/machine/types.h" 3 4
# 1 "/usr/include/i386/types.h" 1 3 4
# 78 "/usr/include/i386/types.h" 3 4
typedef signed char int8_t;
typedef unsigned char u_int8_t;
typedef short int16_t;
typedef unsigned short u_int16_t;
typedef int int32_t;
typedef unsigned int u_int32_t;
typedef long long int64_t;
typedef unsigned long long u_int64_t;
typedef int32_t register_t;
typedef __darwin_intptr_t intptr_t;
typedef unsigned long int uintptr_t;
typedef u_int64_t user_addr_t;
typedef u_int64_t user_size_t;
typedef int64_t user_ssize_t;
typedef int64_t user_long_t;
typedef u_int64_t user_ulong_t;
typedef int64_t user_time_t;
typedef u_int64_t syscall_arg_t;
# 38 "/usr/include/machine/types.h" 2 3 4
# 255 "/usr/include/stdlib.h" 2 3 4
typedef __darwin_dev_t dev_t;
typedef __darwin_mode_t mode_t;
u_int32_t
arc4random(void);
void arc4random_addrandom(unsigned char *dat, int datlen);
void arc4random_stir(void);
char *cgetcap(char *, const char *, int);
int cgetclose(void);
int cgetent(char **, char **, const char *);
int cgetfirst(char **, char **);
int cgetmatch(const char *, const char *);
int cgetnext(char **, char **);
int cgetnum(char *, const char *, long *);
int cgetset(const char *);
int cgetstr(char *, const char *, char **);
int cgetustr(char *, const char *, char **);
int daemon(int, int) __asm("_" "daemon" "$1050") __attribute__((deprecated));
char *devname(dev_t, mode_t);
char *devname_r(dev_t, mode_t, char *buf, int len);
char *getbsize(int *, long *);
int getloadavg(double [], int);
const char
*getprogname(void);
int heapsort(void *, size_t, size_t,
int (*)(const void *, const void *));
int mergesort(void *, size_t, size_t,
int (*)(const void *, const void *));
void qsort_r(void *, size_t, size_t, void *,
int (*)(void *, const void *, const void *));
int radixsort(const unsigned char **, int, const unsigned char *,
unsigned);
void setprogname(const char *);
int sradixsort(const unsigned char **, int, const unsigned char *,
unsigned);
void sranddev(void);
void srandomdev(void);
void *reallocf(void *, size_t);
long long
strtoq(const char *, char **, int);
unsigned long long
strtouq(const char *, char **, int);
extern char *suboptarg;
void *valloc(size_t);
# 129 "../../libiberty/regex.c" 2
# 149 "../../libiberty/regex.c"
# 1 "/usr/include/string.h" 1 3 4
# 70 "/usr/include/string.h" 3 4
typedef __darwin_ssize_t ssize_t;
# 80 "/usr/include/string.h" 3 4
void *memchr(const void *, int, size_t);
int memcmp(const void *, const void *, size_t);
void *memcpy(void *, const void *, size_t);
void *memmove(void *, const void *, size_t);
void *memset(void *, int, size_t);
char *stpcpy(char *, const char *);
char *strcasestr(const char *, const char *);
char *strcat(char *, const char *);
char *strchr(const char *, int);
int strcmp(const char *, const char *);
int strcoll(const char *, const char *);
char *strcpy(char *, const char *);
size_t strcspn(const char *, const char *);
char *strerror(int) __asm("_" "strerror" "$UNIX2003");
int strerror_r(int, char *, size_t);
size_t strlen(const char *);
char *strncat(char *, const char *, size_t);
int strncmp(const char *, const char *, size_t);
char *strncpy(char *, const char *, size_t);
char *strnstr(const char *, const char *, size_t);
char *strpbrk(const char *, const char *);
char *strrchr(const char *, int);
size_t strspn(const char *, const char *);
char *strstr(const char *, const char *);
char *strtok(char *, const char *);
size_t strxfrm(char *, const char *, size_t);
void *memccpy(void *, const void *, int, size_t);
char *strtok_r(char *, const char *, char **);
char *strdup(const char *);
int bcmp(const void *, const void *, size_t);
void bcopy(const void *, void *, size_t);
void bzero(void *, size_t);
int ffs(int);
int ffsl(long);
int fls(int);
int flsl(long);
char *index(const char *, int);
void memset_pattern4(void *, const void *, size_t);
void memset_pattern8(void *, const void *, size_t);
void memset_pattern16(void *, const void *, size_t);
char *rindex(const char *, int);
int strcasecmp(const char *, const char *);
size_t strlcat(char *, const char *, size_t);
size_t strlcpy(char *, const char *, size_t);
void strmode(int, char *);
int strncasecmp(const char *, const char *, size_t);
char *strsep(char **, const char *);
char *strsignal(int sig);
void swab(const void * , void * , ssize_t);
# 150 "../../libiberty/regex.c" 2
# 185 "../../libiberty/regex.c"
# 1 "/Users/dannyb/gccstuff/pre-globals/build/./prev-gcc/include-fixed/limits.h" 1 3 4
# 11 "/Users/dannyb/gccstuff/pre-globals/build/./prev-gcc/include-fixed/limits.h" 3 4
# 1 "/Users/dannyb/gccstuff/pre-globals/build/./prev-gcc/include-fixed/syslimits.h" 1 3 4
# 1 "/Users/dannyb/gccstuff/pre-globals/build/./prev-gcc/include-fixed/limits.h" 1 3 4
# 122 "/Users/dannyb/gccstuff/pre-globals/build/./prev-gcc/include-fixed/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 64 "/usr/include/limits.h" 3 4
# 1 "/usr/include/machine/limits.h" 1 3 4
# 1 "/usr/include/i386/limits.h" 1 3 4
# 40 "/usr/include/i386/limits.h" 3 4
# 1 "/usr/include/i386/_limits.h" 1 3 4
# 41 "/usr/include/i386/limits.h" 2 3 4
# 9 "/usr/include/machine/limits.h" 2 3 4
# 65 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/sys/syslimits.h" 1 3 4
# 66 "/usr/include/limits.h" 2 3 4
# 123 "/Users/dannyb/gccstuff/pre-globals/build/./prev-gcc/include-fixed/limits.h" 2 3 4
# 8 "/Users/dannyb/gccstuff/pre-globals/build/./prev-gcc/include-fixed/syslimits.h" 2 3 4
# 12 "/Users/dannyb/gccstuff/pre-globals/build/./prev-gcc/include-fixed/limits.h" 2 3 4
# 186 "../../libiberty/regex.c" 2
# 1 "../../libiberty/../include/xregex.h" 1
# 26 "../../libiberty/../include/xregex.h"
# 1 "../../libiberty/../include/xregex2.h" 1
# 46 "../../libiberty/../include/xregex2.h"
typedef long int s_reg_t;
typedef unsigned long int active_reg_t;
typedef unsigned long int reg_syntax_t;
# 174 "../../libiberty/../include/xregex2.h"
extern reg_syntax_t xre_syntax_options;
# 291 "../../libiberty/../include/xregex2.h"
typedef enum
{
REG_NOERROR = 0,
REG_NOMATCH,
REG_BADPAT,
REG_ECOLLATE,
REG_ECTYPE,
REG_EESCAPE,
REG_ESUBREG,
REG_EBRACK,
REG_EPAREN,
REG_EBRACE,
REG_BADBR,
REG_ERANGE,
REG_ESPACE,
REG_BADRPT,
REG_EEND,
REG_ESIZE,
REG_ERPAREN
} reg_errcode_t;
# 331 "../../libiberty/../include/xregex2.h"
struct re_pattern_buffer
{
unsigned char *buffer;
unsigned long int allocated;
unsigned long int used;
reg_syntax_t syntax;
char *fastmap;
char * translate;
size_t re_nsub;
unsigned can_be_null : 1;
# 376 "../../libiberty/../include/xregex2.h"
unsigned regs_allocated : 2;
unsigned fastmap_accurate : 1;
unsigned no_sub : 1;
unsigned not_bol : 1;
unsigned not_eol : 1;
unsigned newline_anchor : 1;
};
typedef struct re_pattern_buffer regex_t;
typedef int regoff_t;
struct re_registers
{
unsigned num_regs;
regoff_t *start;
regoff_t *end;
};
# 426 "../../libiberty/../include/xregex2.h"
typedef struct
{
regoff_t rm_so;
regoff_t rm_eo;
} regmatch_t;
# 442 "../../libiberty/../include/xregex2.h"
extern reg_syntax_t xre_set_syntax (reg_syntax_t syntax);
extern const char *xre_compile_pattern (const char *pattern, size_t length,
struct re_pattern_buffer *buffer);
extern int xre_compile_fastmap (struct re_pattern_buffer *buffer);
extern int xre_search (struct re_pattern_buffer *buffer, const char *string,
int length, int start, int range,
struct re_registers *regs);
extern int xre_search_2 (struct re_pattern_buffer *buffer, const char *string1,
int length1, const char *string2, int length2,
int start, int range, struct re_registers *regs,
int stop);
extern int xre_match (struct re_pattern_buffer *buffer, const char *string,
int length, int start, struct re_registers *regs);
extern int xre_match_2 (struct re_pattern_buffer *buffer, const char *string1,
int length1, const char *string2, int length2,
int start, struct re_registers *regs, int stop);
# 499 "../../libiberty/../include/xregex2.h"
extern void xre_set_registers (struct re_pattern_buffer *buffer,
struct re_registers *regs,
unsigned num_regs, regoff_t *starts,
regoff_t *ends);
extern char *xre_comp (const char *);
extern int xre_exec (const char *);
# 535 "../../libiberty/../include/xregex2.h"
extern int xregcomp (regex_t * __preg,
const char * __pattern,
int __cflags);
__extension__
extern int xregexec (const regex_t * __preg,
const char * __string, size_t __nmatch,
regmatch_t __pmatch[],
int __eflags);
extern size_t xregerror (int __errcode, const regex_t *__preg,
char *__errbuf, size_t __errbuf_size);
extern void xregfree (regex_t *__preg);
# 27 "../../libiberty/../include/xregex.h" 2
# 194 "../../libiberty/regex.c" 2
# 1 "/usr/include/ctype.h" 1 3 4
# 69 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/runetype.h" 1 3 4
# 70 "/usr/include/runetype.h" 3 4
typedef __darwin_wint_t wint_t;
# 81 "/usr/include/runetype.h" 3 4
typedef struct {
__darwin_rune_t __min;
__darwin_rune_t __max;
__darwin_rune_t __map;
__uint32_t *__types;
} _RuneEntry;
typedef struct {
int __nranges;
_RuneEntry *__ranges;
} _RuneRange;
typedef struct {
char __name[14];
__uint32_t __mask;
} _RuneCharClass;
typedef struct {
char __magic[8];
char __encoding[32];
__darwin_rune_t (*__sgetrune)(const char *, __darwin_size_t, char const **);
int (*__sputrune)(__darwin_rune_t, char *, __darwin_size_t, char **);
__darwin_rune_t __invalid_rune;
__uint32_t __runetype[(1 <<8 )];
__darwin_rune_t __maplower[(1 <<8 )];
__darwin_rune_t __mapupper[(1 <<8 )];
_RuneRange __runetype_ext;
_RuneRange __maplower_ext;
_RuneRange __mapupper_ext;
void *__variable;
int __variable_len;
int __ncharclasses;
_RuneCharClass *__charclasses;
} _RuneLocale;
extern _RuneLocale _DefaultRuneLocale;
extern _RuneLocale *_CurrentRuneLocale;
# 70 "/usr/include/ctype.h" 2 3 4
# 145 "/usr/include/ctype.h" 3 4
unsigned long ___runetype(__darwin_ct_rune_t);
__darwin_ct_rune_t ___tolower(__darwin_ct_rune_t);
__darwin_ct_rune_t ___toupper(__darwin_ct_rune_t);
static __inline int
isascii(int _c)
{
return ((_c & ~0x7F) == 0);
}
# 164 "/usr/include/ctype.h" 3 4
int __maskrune(__darwin_ct_rune_t, unsigned long);
static __inline int
__istype(__darwin_ct_rune_t _c, unsigned long _f)
{
return (isascii(_c) ? !!(_DefaultRuneLocale.__runetype[_c] & _f)
: !!__maskrune(_c, _f));
}
static __inline __darwin_ct_rune_t
__isctype(__darwin_ct_rune_t _c, unsigned long _f)
{
return (_c < 0 || _c >= (1 <<8 )) ? 0 :
!!(_DefaultRuneLocale.__runetype[_c] & _f);
}
# 204 "/usr/include/ctype.h" 3 4
__darwin_ct_rune_t __toupper(__darwin_ct_rune_t);
__darwin_ct_rune_t __tolower(__darwin_ct_rune_t);
static __inline int
__wcwidth(__darwin_ct_rune_t _c)
{
unsigned int _x;
if (_c == 0)
return (0);
_x = (unsigned int)__maskrune(_c, 0xe0000000L|0x00040000L);
if ((_x & 0xe0000000L) != 0)
return ((_x & 0xe0000000L) >> 30);
return ((_x & 0x00040000L) != 0 ? 1 : -1);
}
static __inline int
isalnum(int _c)
{
return (__istype(_c, 0x00000100L|0x00000400L));
}
static __inline int
isalpha(int _c)
{
return (__istype(_c, 0x00000100L));
}
static __inline int
isblank(int _c)
{
return (__istype(_c, 0x00020000L));
}
static __inline int
iscntrl(int _c)
{
return (__istype(_c, 0x00000200L));
}
static __inline int
isdigit(int _c)
{
return (__isctype(_c, 0x00000400L));
}
static __inline int
isgraph(int _c)
{
return (__istype(_c, 0x00000800L));
}
static __inline int
islower(int _c)
{
return (__istype(_c, 0x00001000L));
}
static __inline int
isprint(int _c)
{
return (__istype(_c, 0x00040000L));
}
static __inline int
ispunct(int _c)
{
return (__istype(_c, 0x00002000L));
}
static __inline int
isspace(int _c)
{
return (__istype(_c, 0x00004000L));
}
static __inline int
isupper(int _c)
{
return (__istype(_c, 0x00008000L));
}
static __inline int
isxdigit(int _c)
{
return (__isctype(_c, 0x00010000L));
}
static __inline int
toascii(int _c)
{
return (_c & 0x7F);
}
static __inline int
tolower(int _c)
{
return (__tolower(_c));
}
static __inline int
toupper(int _c)
{
return (__toupper(_c));
}
static __inline int
digittoint(int _c)
{
return (__maskrune(_c, 0x0F));
}
static __inline int
ishexnumber(int _c)
{
return (__istype(_c, 0x00010000L));
}
static __inline int
isideogram(int _c)
{
return (__istype(_c, 0x00080000L));
}
static __inline int
isnumber(int _c)
{
return (__istype(_c, 0x00000400L));
}
static __inline int
isphonogram(int _c)
{
return (__istype(_c, 0x00200000L));
}
static __inline int
isrune(int _c)
{
return (__istype(_c, 0xFFFFFFF0L));
}
static __inline int
isspecial(int _c)
{
return (__istype(_c, 0x00100000L));
}
# 197 "../../libiberty/regex.c" 2
# 272 "../../libiberty/regex.c"
static char re_syntax_table[256];
static void init_syntax_once (void);
static void
init_syntax_once (void)
{
register int c;
static int done = 0;
if (done)
return;
(memset (re_syntax_table, '\0', sizeof re_syntax_table), (re_syntax_table));
for (c = 0; c < 256; ++c)
if ((1 && isalnum (c)))
re_syntax_table[c] = 1;
re_syntax_table['_'] = 1;
done = 1;
}
# 404 "../../libiberty/regex.c"
typedef char boolean;
static reg_errcode_t byte_regex_compile (const char *pattern, size_t size,
reg_syntax_t syntax,
struct re_pattern_buffer *bufp);
static int byte_re_match_2_internal (struct re_pattern_buffer *bufp,
const char *string1, int size1,
const char *string2, int size2,
int pos,
struct re_registers *regs,
int stop);
static int byte_re_search_2 (struct re_pattern_buffer *bufp,
const char *string1, int size1,
const char *string2, int size2,
int startpos, int range,
struct re_registers *regs, int stop);
static int byte_re_compile_fastmap (struct re_pattern_buffer *bufp);
# 453 "../../libiberty/regex.c"
typedef enum
{
no_op = 0,
succeed,
exactn,
anychar,
# 484 "../../libiberty/regex.c"
charset,
charset_not,
# 497 "../../libiberty/regex.c"
start_memory,
# 506 "../../libiberty/regex.c"
stop_memory,
duplicate,
begline,
endline,
begbuf,
endbuf,
jump,
jump_past_alt,
on_failure_jump,
on_failure_keep_string_jump,
pop_failure_jump,
# 553 "../../libiberty/regex.c"
maybe_pop_jump,
dummy_failure_jump,
push_dummy_failure,
succeed_n,
jump_n,
set_number_at,
wordchar,
notwordchar,
wordbeg,
wordend,
wordbound,
notwordbound
# 604 "../../libiberty/regex.c"
} re_opcode_t;
# 638 "../../libiberty/regex.c"
# 1 "../../libiberty/regex.c" 1
# 1459 "../../libiberty/regex.c"
int xre_max_failures = 4000;
union byte_fail_stack_elt
{
unsigned char *pointer;
int integer;
};
typedef union byte_fail_stack_elt byte_fail_stack_elt_t;
typedef struct
{
byte_fail_stack_elt_t *stack;
unsigned size;
unsigned avail;
} byte_fail_stack_type;
# 1794 "../../libiberty/regex.c"
typedef union
{
byte_fail_stack_elt_t word;
struct
{
unsigned match_null_string_p : 2;
unsigned is_active : 1;
unsigned matched_something : 1;
unsigned ever_matched_something : 1;
} bits;
} byte_register_info_type;
# 1838 "../../libiberty/regex.c"
static char byte_reg_unset_dummy;
static void byte_store_op1 (re_opcode_t op, unsigned char *loc, int arg);
static void byte_store_op2 (re_opcode_t op, unsigned char *loc,
int arg1, int arg2);
static void byte_insert_op1 (re_opcode_t op, unsigned char *loc,
int arg, unsigned char *end);
static void byte_insert_op2 (re_opcode_t op, unsigned char *loc,
int arg1, int arg2, unsigned char *end);
static boolean byte_at_begline_loc_p (const char *pattern,
const char *p,
reg_syntax_t syntax);
static boolean byte_at_endline_loc_p (const char *p,
const char *pend,
reg_syntax_t syntax);
# 1866 "../../libiberty/regex.c"
static reg_errcode_t byte_compile_range (unsigned int range_start,
const char **p_ptr,
const char *pend,
char *translate,
reg_syntax_t syntax,
unsigned char *b);
# 2107 "../../libiberty/regex.c"
typedef unsigned regnum_t;
typedef long pattern_offset_t;
typedef struct
{
pattern_offset_t begalt_offset;
pattern_offset_t fixup_alt_jump;
pattern_offset_t inner_group_offset;
pattern_offset_t laststart_offset;
regnum_t regnum;
} compile_stack_elt_t;
typedef struct
{
compile_stack_elt_t *stack;
unsigned size;
unsigned avail;
} compile_stack_type;
# 2250 "../../libiberty/regex.c"
static boolean group_in_compile_stack (compile_stack_type compile_stack,
regnum_t regnum);
# 2281 "../../libiberty/regex.c"
static reg_errcode_t
byte_regex_compile (const char *pattern,
size_t size, reg_syntax_t syntax,
struct re_pattern_buffer *bufp)
{
register unsigned char c, c1;
# 2304 "../../libiberty/regex.c"
const char *p1;
register unsigned char *b;
compile_stack_type compile_stack;
const char *p = pattern;
const char *pend = pattern + size;
char * translate = bufp->translate;
unsigned char *pending_exact = 0;
unsigned char *laststart = 0;
unsigned char *begalt;
unsigned char *fixup_alt_jump = 0;
regnum_t regnum = 0;
# 2385 "../../libiberty/regex.c"
compile_stack.stack = ((compile_stack_elt_t *) malloc ((32) * sizeof (compile_stack_elt_t)));
if (compile_stack.stack == ((void *)0))
{
return REG_ESPACE;
}
compile_stack.size = 32;
compile_stack.avail = 0;
bufp->syntax = syntax;
bufp->fastmap_accurate = 0;
bufp->not_bol = bufp->not_eol = 0;
bufp->used = 0;
bufp->re_nsub = 0;
init_syntax_once ();
if (bufp->allocated == 0)
{
if (bufp->buffer)
{
# 2430 "../../libiberty/regex.c"
((bufp->buffer) = (unsigned char *) realloc (bufp->buffer, ((32 * sizeof(unsigned char))) * sizeof (unsigned char)));
}
else
{
bufp->buffer = ((unsigned char *) malloc (((32 * sizeof(unsigned char)) / sizeof(unsigned char)) * sizeof (unsigned char)));
}
if (!bufp->buffer) return (free (compile_stack.stack), REG_ESPACE);
bufp->allocated = (32 * sizeof(unsigned char));
}
begalt = b = bufp->buffer;
while (p != pend)
{
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
switch (c)
{
case '^':
{
if (
p == pattern + 1
|| syntax & (((((unsigned long int) 1) << 1) << 1) << 1)
|| byte_at_begline_loc_p (pattern, p, syntax))
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (begline); } while (0);
else
goto normal_char;
}
break;
case '$':
{
if (
p == pend
|| syntax & (((((unsigned long int) 1) << 1) << 1) << 1)
|| byte_at_endline_loc_p (p, pend, syntax))
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (endline); } while (0);
else
goto normal_char;
}
break;
case '+':
case '?':
if ((syntax & (((unsigned long int) 1) << 1))
|| (syntax & ((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)))
goto normal_char;
handle_plus:
case '*':
if (!laststart)
{
if (syntax & (((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1))
return (free (compile_stack.stack), REG_BADRPT);
else if (!(syntax & ((((((unsigned long int) 1) << 1) << 1) << 1) << 1)))
goto normal_char;
}
{
boolean keep_string_p = 0;
char zero_times_ok = 0, many_times_ok = 0;
for (;;)
{
zero_times_ok |= c != '+';
many_times_ok |= c != '?';
if (p == pend)
break;
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
if (c == '*'
|| (!(syntax & (((unsigned long int) 1) << 1)) && (c == '+' || c == '?')))
;
else if (syntax & (((unsigned long int) 1) << 1) && c == '\\')
{
if (p == pend) return (free (compile_stack.stack), REG_EESCAPE);
do {if (p == pend) return REG_EEND; c1 = (unsigned char) *p++; if (translate) c1 = (unsigned char) translate[c1]; } while (0);
if (!(c1 == '+' || c1 == '?'))
{
p--;
p--;
break;
}
c = c1;
}
else
{
p--;
break;
}
}
if (!laststart)
break;
if (many_times_ok)
{
# 2572 "../../libiberty/regex.c"
;
while ((unsigned long) (b - bufp->buffer + (1 + 2)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0);
if ((translate ? (char) translate[(unsigned char) (*(p - 2))] : (char) (*(p - 2))) == (translate ? (char) translate[(unsigned char) ('.')] : (char) ('.'))
&& zero_times_ok
&& p < pend && (translate ? (char) translate[(unsigned char) (*p)] : (char) (*p)) == (translate ? (char) translate[(unsigned char) ('\n')] : (char) ('\n'))
&& !(syntax & ((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1)))
{
byte_store_op1 (jump, b, (int) ((laststart) - (b) - (1 + 2)));
keep_string_p = 1;
}
else
byte_store_op1 (maybe_pop_jump, b, (int) ((laststart - (1 + 2)) - (b) - (1 + 2)));
b += 1 + 2;
}
while ((unsigned long) (b - bufp->buffer + (1 + 2)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0);
byte_insert_op1 (keep_string_p ? on_failure_keep_string_jump : on_failure_jump, laststart, (int) ((b + 1 + 2) - (laststart) - (1 + 2)), b);
pending_exact = 0;
b += 1 + 2;
if (!zero_times_ok)
{
while ((unsigned long) (b - bufp->buffer + (1 + 2)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0);
byte_insert_op1 (dummy_failure_jump, laststart, (int) ((laststart + 2 + 2 * 2) - (laststart) - (1 + 2)), b);
b += 1 + 2;
}
}
break;
case '.':
laststart = b;
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (anychar); } while (0);
break;
case '[':
{
boolean had_char_class = 0;
unsigned int range_start = 0xffffffff;
if (p == pend) return (free (compile_stack.stack), REG_EBRACK);
# 3107 "../../libiberty/regex.c"
while ((unsigned long) (b - bufp->buffer + (34)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0);
laststart = b;
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (*p == '^' ? charset_not : charset); } while (0);
if (*p == '^')
p++;
p1 = p;
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) ((1 << 8) / 8); } while (0);
(memset (b, '\0', (1 << 8) / 8), (b));
if ((re_opcode_t) b[-2] == charset_not
&& (syntax & ((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)))
(b[((unsigned char) ('\n')) / 8] |= 1 << (((unsigned char) '\n') % 8));
for (;;)
{
if (p == pend) return (free (compile_stack.stack), REG_EBRACK);
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
if ((syntax & ((unsigned long int) 1)) && c == '\\')
{
if (p == pend) return (free (compile_stack.stack), REG_EESCAPE);
do {if (p == pend) return REG_EEND; c1 = (unsigned char) *p++; if (translate) c1 = (unsigned char) translate[c1]; } while (0);
(b[((unsigned char) (c1)) / 8] |= 1 << (((unsigned char) c1) % 8));
range_start = c1;
continue;
}
if (c == ']' && p != p1 + 1)
break;
if (had_char_class && c == '-' && *p != ']')
return (free (compile_stack.stack), REG_ERANGE);
if (c == '-'
&& !(p - 2 >= pattern && p[-2] == '[')
&& !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
&& *p != ']')
{
reg_errcode_t ret
= byte_compile_range (range_start, &p, pend, translate,
syntax, b);
if (ret != REG_NOERROR) return (free (compile_stack.stack), ret);
range_start = 0xffffffff;
}
else if (p[0] == '-' && p[1] != ']')
{
reg_errcode_t ret;
do {if (p == pend) return REG_EEND; c1 = (unsigned char) *p++; if (translate) c1 = (unsigned char) translate[c1]; } while (0);
ret = byte_compile_range (c, &p, pend, translate, syntax, b);
if (ret != REG_NOERROR) return (free (compile_stack.stack), ret);
range_start = 0xffffffff;
}
else if (syntax & ((((unsigned long int) 1) << 1) << 1) && c == '[' && *p == ':')
{
char str[6 + 1];
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
c1 = 0;
if (p == pend) return (free (compile_stack.stack), REG_EBRACK);
for (;;)
{
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
if ((c == ':' && *p == ']') || p == pend)
break;
if (c1 < 6)
str[c1++] = c;
else
str[0] = '\0';
}
str[c1] = '\0';
if (c == ':' && *p == ']')
{
# 3252 "../../libiberty/regex.c"
int ch;
boolean is_alnum = ((strcmp (str, "alnum") == 0));
boolean is_alpha = ((strcmp (str, "alpha") == 0));
boolean is_blank = ((strcmp (str, "blank") == 0));
boolean is_cntrl = ((strcmp (str, "cntrl") == 0));
boolean is_digit = ((strcmp (str, "digit") == 0));
boolean is_graph = ((strcmp (str, "graph") == 0));
boolean is_lower = ((strcmp (str, "lower") == 0));
boolean is_print = ((strcmp (str, "print") == 0));
boolean is_punct = ((strcmp (str, "punct") == 0));
boolean is_space = ((strcmp (str, "space") == 0));
boolean is_upper = ((strcmp (str, "upper") == 0));
boolean is_xdigit = ((strcmp (str, "xdigit") == 0));
if (!(((strcmp (str, "alpha") == 0)) || ((strcmp (str, "upper") == 0)) || ((strcmp (str, "lower") == 0)) || ((strcmp (str, "digit") == 0)) || ((strcmp (str, "alnum") == 0)) || ((strcmp (str, "xdigit") == 0)) || ((strcmp (str, "space") == 0)) || ((strcmp (str, "print") == 0)) || ((strcmp (str, "punct") == 0)) || ((strcmp (str, "graph") == 0)) || ((strcmp (str, "cntrl") == 0)) || ((strcmp (str, "blank") == 0))))
return (free (compile_stack.stack), REG_ECTYPE);
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
if (p == pend) return (free (compile_stack.stack), REG_EBRACK);
for (ch = 0; ch < 1 << 8; ch++)
{
if ( (is_alnum && (1 && isalnum (ch)))
|| (is_alpha && (1 && isalpha (ch)))
|| (is_blank && ((ch) == ' ' || (ch) == '\t'))
|| (is_cntrl && (1 && iscntrl (ch))))
(b[((unsigned char) (ch)) / 8] |= 1 << (((unsigned char) ch) % 8));
if ( (is_digit && (1 && isdigit (ch)))
|| (is_graph && (1 && isprint (ch) && !isspace (ch)))
|| (is_lower && (1 && islower (ch)))
|| (is_print && (1 && isprint (ch))))
(b[((unsigned char) (ch)) / 8] |= 1 << (((unsigned char) ch) % 8));
if ( (is_punct && (1 && ispunct (ch)))
|| (is_space && (1 && isspace (ch)))
|| (is_upper && (1 && isupper (ch)))
|| (is_xdigit && (1 && isxdigit (ch))))
(b[((unsigned char) (ch)) / 8] |= 1 << (((unsigned char) ch) % 8));
if ( translate && (is_upper || is_lower)
&& ((1 && isupper (ch)) || (1 && islower (ch))))
(b[((unsigned char) (ch)) / 8] |= 1 << (((unsigned char) ch) % 8));
}
had_char_class = 1;
}
else
{
c1++;
while (c1--)
p--;
(b[((unsigned char) ('[')) / 8] |= 1 << (((unsigned char) '[') % 8));
(b[((unsigned char) (':')) / 8] |= 1 << (((unsigned char) ':') % 8));
range_start = ':';
had_char_class = 0;
}
}
else if (syntax & ((((unsigned long int) 1) << 1) << 1) && c == '[' && *p == '=')
{
unsigned char str[6 + 1];
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
c1 = 0;
if (p == pend) return (free (compile_stack.stack), REG_EBRACK);
for (;;)
{
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
if ((c == '=' && *p == ']') || p == pend)
break;
if (c1 < 6)
str[c1++] = c;
else
str[0] = '\0';
}
str[c1] = '\0';
if (c == '=' && *p == ']' && str[0] != '\0')
{
# 3350 "../../libiberty/regex.c"
{
if (c1 != 1)
return (free (compile_stack.stack), REG_ECOLLATE);
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
(b[((unsigned char) (str[0])) / 8] |= 1 << (((unsigned char) str[0]) % 8));
}
# 3433 "../../libiberty/regex.c"
had_char_class = 1;
}
else
{
c1++;
while (c1--)
p--;
(b[((unsigned char) ('[')) / 8] |= 1 << (((unsigned char) '[') % 8));
(b[((unsigned char) ('=')) / 8] |= 1 << (((unsigned char) '=') % 8));
range_start = '=';
had_char_class = 0;
}
}
else if (syntax & ((((unsigned long int) 1) << 1) << 1) && c == '[' && *p == '.')
{
unsigned char str[128];
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
c1 = 0;
if (p == pend) return (free (compile_stack.stack), REG_EBRACK);
for (;;)
{
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
if ((c == '.' && *p == ']') || p == pend)
break;
if (c1 < sizeof (str))
str[c1++] = c;
else
str[0] = '\0';
}
str[c1] = '\0';
if (c == '.' && *p == ']' && str[0] != '\0')
{
# 3485 "../../libiberty/regex.c"
{
if (c1 != 1)
return (free (compile_stack.stack), REG_ECOLLATE);
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
(b[((unsigned char) (str[0])) / 8] |= 1 << (((unsigned char) str[0]) % 8));
range_start = ((const unsigned char *) str)[0];
}
# 3576 "../../libiberty/regex.c"
had_char_class = 0;
}
else
{
c1++;
while (c1--)
p--;
(b[((unsigned char) ('[')) / 8] |= 1 << (((unsigned char) '[') % 8));
(b[((unsigned char) ('.')) / 8] |= 1 << (((unsigned char) '.') % 8));
range_start = '.';
had_char_class = 0;
}
}
else
{
had_char_class = 0;
(b[((unsigned char) (c)) / 8] |= 1 << (((unsigned char) c) % 8));
range_start = c;
}
}
while ((int) b[-1] > 0 && b[b[-1] - 1] == 0)
b[-1]--;
b += b[-1];
}
break;
case '(':
if (syntax & (((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto handle_open;
else
goto normal_char;
case ')':
if (syntax & (((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto handle_close;
else
goto normal_char;
case '\n':
if (syntax & (((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto handle_alt;
else
goto normal_char;
case '|':
if (syntax & (((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto handle_alt;
else
goto normal_char;
case '{':
if (syntax & (((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) && syntax & ((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto handle_interval;
else
goto normal_char;
case '\\':
if (p == pend) return (free (compile_stack.stack), REG_EESCAPE);
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; } while (0);
switch (c)
{
case '(':
if (syntax & (((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_backslash;
handle_open:
bufp->re_nsub++;
regnum++;
if ((compile_stack.avail == compile_stack.size))
{
((compile_stack.stack) = (compile_stack_elt_t *) realloc (compile_stack.stack, (compile_stack.size << 1) * sizeof (compile_stack_elt_t)));
if (compile_stack.stack == ((void *)0)) return REG_ESPACE;
compile_stack.size <<= 1;
}
(compile_stack.stack[compile_stack.avail]).begalt_offset = begalt - bufp->buffer;
(compile_stack.stack[compile_stack.avail]).fixup_alt_jump
= fixup_alt_jump ? fixup_alt_jump - bufp->buffer + 1 : 0;
(compile_stack.stack[compile_stack.avail]).laststart_offset = b - bufp->buffer;
(compile_stack.stack[compile_stack.avail]).regnum = regnum;
if (regnum <= 255)
{
(compile_stack.stack[compile_stack.avail]).inner_group_offset = b
- bufp->buffer + 2;
do { while ((unsigned long) (b - bufp->buffer + (3)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (start_memory); *b++ = (unsigned char) (regnum); *b++ = (unsigned char) (0); } while (0);
}
compile_stack.avail++;
fixup_alt_jump = 0;
laststart = 0;
begalt = b;
pending_exact = 0;
break;
case ')':
if (syntax & (((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)) goto normal_backslash;
if ((compile_stack.avail == 0))
{
if (syntax & (((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_backslash;
else
return (free (compile_stack.stack), REG_ERPAREN);
}
handle_close:
if (fixup_alt_jump)
{
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (push_dummy_failure); } while (0);
byte_store_op1 (jump_past_alt, fixup_alt_jump, (int) ((b - 1) - (fixup_alt_jump) - (1 + 2)));
}
if ((compile_stack.avail == 0))
{
if (syntax & (((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_char;
else
return (free (compile_stack.stack), REG_ERPAREN);
}
;
{
regnum_t this_group_regnum;
compile_stack.avail--;
begalt = bufp->buffer + (compile_stack.stack[compile_stack.avail]).begalt_offset;
fixup_alt_jump
= (compile_stack.stack[compile_stack.avail]).fixup_alt_jump
? bufp->buffer + (compile_stack.stack[compile_stack.avail]).fixup_alt_jump - 1
: 0;
laststart = bufp->buffer + (compile_stack.stack[compile_stack.avail]).laststart_offset;
this_group_regnum = (compile_stack.stack[compile_stack.avail]).regnum;
pending_exact = 0;
if (this_group_regnum <= 255)
{
unsigned char *inner_group_loc
= bufp->buffer + (compile_stack.stack[compile_stack.avail]).inner_group_offset;
*inner_group_loc = regnum - this_group_regnum;
do { while ((unsigned long) (b - bufp->buffer + (3)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (stop_memory); *b++ = (unsigned char) (this_group_regnum); *b++ = (unsigned char) (regnum - this_group_regnum); } while (0);
}
}
break;
case '|':
if (syntax & ((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) || syntax & (((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_backslash;
handle_alt:
if (syntax & ((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_char;
while ((unsigned long) (b - bufp->buffer + (1 + 2)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0);
byte_insert_op1 (on_failure_jump, begalt, (int) ((b + 2 + 2 * 2) - (begalt) - (1 + 2)), b);
pending_exact = 0;
b += 1 + 2;
# 3803 "../../libiberty/regex.c"
if (fixup_alt_jump)
byte_store_op1 (jump_past_alt, fixup_alt_jump, (int) ((b) - (fixup_alt_jump) - (1 + 2)));
fixup_alt_jump = b;
while ((unsigned long) (b - bufp->buffer + (1 + 2)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0);
b += 1 + 2;
laststart = 0;
begalt = b;
break;
case '{':
if (!(syntax & (((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
|| (syntax & ((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)))
goto normal_backslash;
handle_interval:
{
int lower_bound = -1, upper_bound = -1;
const char *beg_interval = p;
if (p == pend)
goto invalid_interval;
{ while (p != pend) { do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0); if (c < '0' || c > '9') break; if (lower_bound <= (0x7fff)) { if (lower_bound < 0) lower_bound = 0; lower_bound = lower_bound * 10 + c - '0'; } } };
if (c == ',')
{
{ while (p != pend) { do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0); if (c < '0' || c > '9') break; if (upper_bound <= (0x7fff)) { if (upper_bound < 0) upper_bound = 0; upper_bound = upper_bound * 10 + c - '0'; } } };
if (upper_bound < 0)
upper_bound = (0x7fff);
}
else
upper_bound = lower_bound;
if (! (0 <= lower_bound && lower_bound <= upper_bound))
goto invalid_interval;
if (!(syntax & ((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)))
{
if (c != '\\' || p == pend)
goto invalid_interval;
do {if (p == pend) return REG_EEND; c = (unsigned char) *p++; if (translate) c = (unsigned char) translate[c]; } while (0);
}
if (c != '}')
goto invalid_interval;
if (!laststart)
{
if (syntax & (((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1)
&& !(syntax & (((((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)))
return (free (compile_stack.stack), REG_BADRPT);
else if (syntax & ((((((unsigned long int) 1) << 1) << 1) << 1) << 1))
laststart = b;
else
goto unfetch_interval;
}
if ((0x7fff) < upper_bound)
return (free (compile_stack.stack), REG_BADBR);
if (upper_bound == 0)
{
while ((unsigned long) (b - bufp->buffer + (1 + 2)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0);
byte_insert_op1 (jump, laststart, (int) ((b + 1 + 2) - (laststart) - (1 + 2)), b);
b += 1 + 2;
}
# 3904 "../../libiberty/regex.c"
else
{
unsigned nbytes = 2 + 4 * 2 +
(upper_bound > 1) * (2 + 4 * 2);
while ((unsigned long) (b - bufp->buffer + (nbytes)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0);
byte_insert_op2 (succeed_n, laststart, (int) ((b + 1 + 2 * 2 + (upper_bound > 1) * (1 + 2 * 2)) - (laststart) - (1 + 2)), lower_bound, b);
b += 1 + 2 * 2;
# 3930 "../../libiberty/regex.c"
byte_insert_op2 (set_number_at, laststart, 1
+ 2 * 2, lower_bound, b);
b += 1 + 2 * 2;
if (upper_bound > 1)
{
byte_store_op2 (jump_n, b, (int) ((laststart + 2 * 2 + 1) - (b) - (1 + 2)), upper_bound - 1);
b += 1 + 2 * 2;
# 3961 "../../libiberty/regex.c"
byte_insert_op2 (set_number_at, laststart,
b - laststart,
upper_bound - 1, b);
b += 1 + 2 * 2;
}
}
pending_exact = 0;
break;
invalid_interval:
if (!(syntax & (((((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)))
return (free (compile_stack.stack), p == pend ? REG_EBRACE : REG_BADBR);
unfetch_interval:
p = beg_interval;
c = '{';
if (syntax & ((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_char;
else
goto normal_backslash;
}
# 4004 "../../libiberty/regex.c"
case 'w':
if (syntax & (((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_char;
laststart = b;
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (wordchar); } while (0);
break;
case 'W':
if (syntax & (((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_char;
laststart = b;
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (notwordchar); } while (0);
break;
case '<':
if (syntax & (((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_char;
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (wordbeg); } while (0);
break;
case '>':
if (syntax & (((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_char;
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (wordend); } while (0);
break;
case 'b':
if (syntax & (((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_char;
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (wordbound); } while (0);
break;
case 'B':
if (syntax & (((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_char;
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (notwordbound); } while (0);
break;
case '`':
if (syntax & (((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_char;
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (begbuf); } while (0);
break;
case '\'':
if (syntax & (((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_char;
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (endbuf); } while (0);
break;
case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
if (syntax & ((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
goto normal_char;
c1 = c - '0';
if (c1 > regnum)
return (free (compile_stack.stack), REG_ESUBREG);
if (group_in_compile_stack (compile_stack, (regnum_t) c1))
goto normal_char;
laststart = b;
do { while ((unsigned long) (b - bufp->buffer + (2)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (duplicate); *b++ = (unsigned char) (c1); } while (0);
break;
case '+':
case '?':
if (syntax & (((unsigned long int) 1) << 1))
goto handle_plus;
else
goto normal_backslash;
default:
normal_backslash:
c = (translate ? (char) translate[(unsigned char) (c)] : (char) (c));
goto normal_char;
}
break;
default:
normal_char:
if (!pending_exact
|| pending_exact + *pending_exact + 1 != b
|| *pending_exact == (1 << 8) - 1
|| *p == '*' || *p == '^'
|| ((syntax & (((unsigned long int) 1) << 1))
? *p == '\\' && (p[1] == '+' || p[1] == '?')
: (*p == '+' || *p == '?'))
|| ((syntax & (((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
&& ((syntax & ((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
? *p == '{'
: (p[0] == '\\' && p[1] == '{'))))
{
laststart = b;
# 4132 "../../libiberty/regex.c"
do { while ((unsigned long) (b - bufp->buffer + (2)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (exactn); *b++ = (unsigned char) (0); } while (0);
pending_exact = b - 1;
}
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (c); } while (0);
(*pending_exact)++;
break;
}
}
if (fixup_alt_jump)
byte_store_op1 (jump_past_alt, fixup_alt_jump, (int) ((b) - (fixup_alt_jump) - (1 + 2)));
if (!(compile_stack.avail == 0))
return (free (compile_stack.stack), REG_EPAREN);
if (syntax & ((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))
do { while ((unsigned long) (b - bufp->buffer + (1)) > bufp->allocated) do { unsigned char *old_buffer = bufp->buffer; if (bufp->allocated == (1L << 16)) return REG_ESIZE; bufp->allocated <<= 1; if (bufp->allocated > (1L << 16)) bufp->allocated = (1L << 16); bufp->buffer = (unsigned char *) realloc ((bufp->buffer), (bufp->allocated)); if (bufp->buffer == ((void *)0)) return REG_ESPACE; if (old_buffer != bufp->buffer) { int incr = bufp->buffer - old_buffer; (b) += incr; (begalt) += incr; if (fixup_alt_jump) (fixup_alt_jump) += incr; if (laststart) (laststart) += incr; if (pending_exact) (pending_exact) += incr; } } while (0); *b++ = (unsigned char) (succeed); } while (0);
free (compile_stack.stack);
bufp->used = b - bufp->buffer;
# 4220 "../../libiberty/regex.c"
return REG_NOERROR;
}
static void
byte_store_op1 (re_opcode_t op, unsigned char *loc, int arg)
{
*loc = (unsigned char) op;
do { (loc + 1)[0] = (arg) & 0377; (loc + 1)[1] = (arg) >> 8; } while (0);
}
static void
byte_store_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2)
{
*loc = (unsigned char) op;
do { (loc + 1)[0] = (arg1) & 0377; (loc + 1)[1] = (arg1) >> 8; } while (0);
do { (loc + 1 + 2)[0] = (arg2) & 0377; (loc + 1 + 2)[1] = (arg2) >> 8; } while (0);
}
static void
byte_insert_op1 (re_opcode_t op, unsigned char *loc, int arg, unsigned char *end)
{
register unsigned char *pfrom = end;
register unsigned char *pto = end + 1 + 2;
while (pfrom != loc)
*--pto = *--pfrom;
byte_store_op1 (op, loc, arg);
}
static void
byte_insert_op2 (re_opcode_t op, unsigned char *loc, int arg1,
int arg2, unsigned char *end)
{
register unsigned char *pfrom = end;
register unsigned char *pto = end + 1 + 2 * 2;
while (pfrom != loc)
*--pto = *--pfrom;
byte_store_op2 (op, loc, arg1, arg2);
}
static boolean
byte_at_begline_loc_p (const char *pattern, const char *p,
reg_syntax_t syntax)
{
const char *prev = p - 2;
boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';
return
(*prev == '(' && (syntax & (((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) || prev_prev_backslash))
|| (*prev == '|' && (syntax & (((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) || prev_prev_backslash));
}
static boolean
byte_at_endline_loc_p (const char *p, const char *pend,
reg_syntax_t syntax)
{
const char *next = p;
boolean next_backslash = *next == '\\';
const char *next_next = p + 1 < pend ? p + 1 : 0;
return
(syntax & (((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) ? *next == ')'
: next_backslash && next_next && *next_next == ')')
|| (syntax & (((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) ? *next == '|'
: next_backslash && next_next && *next_next == '|');
}
# 4441 "../../libiberty/regex.c"
static reg_errcode_t
byte_compile_range (unsigned int range_start_char, const char **p_ptr,
const char *pend, char * translate,
reg_syntax_t syntax, unsigned char *b)
{
unsigned this_char;
const char *p = *p_ptr;
reg_errcode_t ret;
unsigned end_char;
if (p == pend)
return REG_ERANGE;
(*p_ptr)++;
ret = syntax & ((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) ? REG_ERANGE : REG_NOERROR;
# 4487 "../../libiberty/regex.c"
range_start_char = (translate ? (char) translate[(unsigned char) (range_start_char)] : (char) (range_start_char));
end_char = ((unsigned)(translate ? (char) translate[(unsigned char) (p[0])] : (char) (p[0])) & ((1 << 8) - 1));
for (this_char = range_start_char; this_char <= end_char; ++this_char)
{
(b[((unsigned char) ((translate ? (char) translate[(unsigned char) (this_char)] : (char) (this_char)))) / 8] |= 1 << (((unsigned char) (translate ? (char) translate[(unsigned char) (this_char)] : (char) (this_char))) % 8));
ret = REG_NOERROR;
}
return ret;
}
# 4540 "../../libiberty/regex.c"
static int
byte_re_compile_fastmap (struct re_pattern_buffer *bufp)
{
int j, k;
byte_fail_stack_type fail_stack;
char *destination;
register char *fastmap = bufp->fastmap;
unsigned char *pattern = bufp->buffer;
register unsigned char *pend = pattern + bufp->used;
unsigned char *p = pattern;
# 4574 "../../libiberty/regex.c"
boolean path_can_be_null = 1;
boolean succeed_n_p = 0;
;
do { fail_stack.stack = (byte_fail_stack_elt_t *) __builtin_alloca(5 * sizeof (byte_fail_stack_elt_t)); if (fail_stack.stack == ((void *)0)) return -2; fail_stack.size = 5; fail_stack.avail = 0; } while (0);
(memset (fastmap, '\0', 1 << 8), (fastmap));
bufp->fastmap_accurate = 1;
bufp->can_be_null = 0;
while (1)
{
if (p == pend || *p == (unsigned char) succeed)
{
if (!(fail_stack.avail == 0))
{
bufp->can_be_null |= path_can_be_null;
path_can_be_null = 1;
p = fail_stack.stack[--fail_stack.avail].pointer;
continue;
}
else
break;
}
;
switch (((re_opcode_t) *p++))
{
case duplicate:
bufp->can_be_null = 1;
goto done;
# 4630 "../../libiberty/regex.c"
case exactn:
fastmap[p[1]] = 1;
break;
# 4650 "../../libiberty/regex.c"
case charset:
for (j = *p++ * 8 - 1; j >= 0; j--)
if (p[j / 8] & (1 << (j % 8)))
fastmap[j] = 1;
break;
case charset_not:
for (j = *p * 8; j < (1 << 8); j++)
fastmap[j] = 1;
for (j = *p++ * 8 - 1; j >= 0; j--)
if (!(p[j / 8] & (1 << (j % 8))))
fastmap[j] = 1;
break;
case wordchar:
for (j = 0; j < (1 << 8); j++)
if (re_syntax_table[(unsigned char) (j)] == 1)
fastmap[j] = 1;
break;
case notwordchar:
for (j = 0; j < (1 << 8); j++)
if (re_syntax_table[(unsigned char) (j)] != 1)
fastmap[j] = 1;
break;
case anychar:
{
int fastmap_newline = fastmap['\n'];
for (j = 0; j < (1 << 8); j++)
fastmap[j] = 1;
if (!(bufp->syntax & ((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1)))
fastmap['\n'] = fastmap_newline;
else if (bufp->can_be_null)
goto done;
break;
}
# 4731 "../../libiberty/regex.c"
case no_op:
case begline:
case endline:
case begbuf:
case endbuf:
case wordbound:
case notwordbound:
case wordbeg:
case wordend:
case push_dummy_failure:
continue;
case jump_n:
case pop_failure_jump:
case maybe_pop_jump:
case jump:
case jump_past_alt:
case dummy_failure_jump:
do { do { (j) = *(p) & 0377; (j) += ((signed char) (*((p) + 1))) << 8; } while (0); (p) += 2; } while (0);
p += j;
if (j > 0)
continue;
if ((re_opcode_t) *p != on_failure_jump
&& (re_opcode_t) *p != succeed_n)
continue;
p++;
do { do { (j) = *(p) & 0377; (j) += ((signed char) (*((p) + 1))) << 8; } while (0); (p) += 2; } while (0);
p += j;
if (!(fail_stack.avail == 0)
&& fail_stack.stack[fail_stack.avail - 1].pointer == p)
fail_stack.avail--;
continue;
case on_failure_jump:
case on_failure_keep_string_jump:
handle_on_failure_jump:
do { do { (j) = *(p) & 0377; (j) += ((signed char) (*((p) + 1))) << 8; } while (0); (p) += 2; } while (0);
# 4788 "../../libiberty/regex.c"
if (p + j < pend)
{
if (!(((fail_stack.avail == fail_stack.size) && !((fail_stack).size > (unsigned) (xre_max_failures * (5 * 3 + 4)) ? 0 : ((fail_stack).stack = (byte_fail_stack_elt_t *) (destination = (char *) __builtin_alloca(((fail_stack).size << 1) * sizeof (byte_fail_stack_elt_t)), memcpy (destination, (fail_stack).stack, (fail_stack).size * sizeof (byte_fail_stack_elt_t))), (fail_stack).stack == ((void *)0) ? 0 : ((fail_stack).size <<= 1, 1)))) ? 0 : ((fail_stack).stack[(fail_stack).avail++].pointer = p + j, 1)))
{
;
return -2;
}
}
else
bufp->can_be_null = 1;
if (succeed_n_p)
{
do { do { (k) = *(p) & 0377; (k) += ((signed char) (*((p) + 1))) << 8; } while (0); (p) += 2; } while (0);
succeed_n_p = 0;
}
continue;
case succeed_n:
p += 2;
do { do { (k) = *(p) & 0377; (k) += ((signed char) (*((p) + 1))) << 8; } while (0); (p) += 2; } while (0);
if (k == 0)
{
p -= 2 * 2;
succeed_n_p = 1;
goto handle_on_failure_jump;
}
continue;
case set_number_at:
p += 2 * 2;
continue;
case start_memory:
case stop_memory:
p += 2;
continue;
default:
abort ();
}
path_can_be_null = 0;
p = pend;
}
bufp->can_be_null |= path_can_be_null;
done:
;
return 0;
}
# 5006 "../../libiberty/regex.c"
static int
byte_re_search_2 (struct re_pattern_buffer *bufp, const char *string1,
int size1, const char *string2, int size2,
int startpos, int range,
struct re_registers *regs, int stop)
{
int val;
register char *fastmap = bufp->fastmap;
register char * translate = bufp->translate;
int total_size = size1 + size2;
int endpos = startpos + range;
# 5029 "../../libiberty/regex.c"
if (startpos < 0 || startpos > total_size)
return -1;
if (endpos < 0)
range = 0 - startpos;
else if (endpos > total_size)
range = total_size - startpos;
if (bufp->used > 0 && range > 0
&& ((re_opcode_t) bufp->buffer[0] == begbuf
|| ((re_opcode_t) bufp->buffer[0] == begline
&& !bufp->newline_anchor)))
{
if (startpos > 0)
return -1;
else
range = 1;
}
# 5066 "../../libiberty/regex.c"
if (fastmap && !bufp->fastmap_accurate)
if (xre_compile_fastmap (bufp) == -2)
return -2;
# 5146 "../../libiberty/regex.c"
for (;;)
{
if (fastmap && startpos < total_size && !bufp->can_be_null)
{
if (range > 0)
{
register const char *d;
register int lim = 0;
int irange = range;
if (startpos < size1 && startpos + range >= size1)
lim = range - (size1 - startpos);
d = (startpos >= size1 ? string2 - size1 : string1) + startpos;
if (translate)
while (range > lim
&& !fastmap[(unsigned char)
translate[(unsigned char) *d++]])
range--;
else
while (range > lim && !fastmap[(unsigned char) *d++])
range--;
startpos += irange - range;
}
else
{
register char c = (size1 == 0 || startpos >= size1
? string2[startpos - size1]
: string1[startpos]);
if (!fastmap[(unsigned char) (translate ? (char) translate[(unsigned char) (c)] : (char) (c))])
goto advance;
}
}
if (range >= 0 && startpos == total_size && fastmap
&& !bufp->can_be_null)
{
return -1;
}
# 5206 "../../libiberty/regex.c"
val = byte_re_match_2_internal (bufp, string1, size1, string2,
size2, startpos, regs, stop);
# 5216 "../../libiberty/regex.c"
if (val >= 0)
{
return startpos;
}
if (val == -2)
{
return -2;
}
advance:
if (!range)
break;
else if (range > 0)
{
range--;
startpos++;
}
else
{
range++;
startpos--;
}
}
return -1;
}
# 5421 "../../libiberty/regex.c"
static boolean byte_group_match_null_string_p (unsigned char **p,
unsigned char *end,
byte_register_info_type *reg_info);
static boolean byte_alt_match_null_string_p (unsigned char *p,
unsigned char *end,
byte_register_info_type *reg_info);
static boolean byte_common_op_match_null_string_p (unsigned char **p,
unsigned char *end,
byte_register_info_type *reg_info);
static int byte_bcmp_translate (const char *s1, const char *s2,
int len, char *translate);
# 5542 "../../libiberty/regex.c"
static int
byte_re_match_2_internal (struct re_pattern_buffer *bufp,
const char *string1, int size1,
const char *string2, int size2,
int pos,
struct re_registers *regs, int stop)
{
int mcnt;
unsigned char *p1;
# 5561 "../../libiberty/regex.c"
const char *end1, *end2;
const char *end_match_1, *end_match_2;
const char *d, *dend;
unsigned char *p = bufp->buffer;
register unsigned char *pend = p + bufp->used;
unsigned char *just_past_start_mem = 0;
char * translate = bufp->translate;
# 5596 "../../libiberty/regex.c"
byte_fail_stack_type fail_stack;
# 5612 "../../libiberty/regex.c"
size_t num_regs = bufp->re_nsub + 1;
active_reg_t lowest_active_reg = ((1 << 8) + 1);
active_reg_t highest_active_reg = (1 << 8);
# 5626 "../../libiberty/regex.c"
const char **regstart, **regend;
# 5635 "../../libiberty/regex.c"
const char **old_regstart, **old_regend;
# 5645 "../../libiberty/regex.c"
byte_register_info_type *reg_info;
unsigned best_regs_set = 0;
const char **best_regstart, **best_regend;
# 5665 "../../libiberty/regex.c"
const char *match_end = ((void *)0);
int set_regs_matched_done = 0;
const char **reg_dummy;
byte_register_info_type *reg_info_dummy;
;
do { fail_stack.stack = (byte_fail_stack_elt_t *) __builtin_alloca(5 * sizeof (byte_fail_stack_elt_t)); if (fail_stack.stack == ((void *)0)) return -2; fail_stack.size = 5; fail_stack.avail = 0; } while (0);
if (bufp->re_nsub)
{
regstart = ((const char * *) __builtin_alloca((num_regs) * sizeof (const char *)));
regend = ((const char * *) __builtin_alloca((num_regs) * sizeof (const char *)));
old_regstart = ((const char * *) __builtin_alloca((num_regs) * sizeof (const char *)));
old_regend = ((const char * *) __builtin_alloca((num_regs) * sizeof (const char *)));
best_regstart = ((const char * *) __builtin_alloca((num_regs) * sizeof (const char *)));
best_regend = ((const char * *) __builtin_alloca((num_regs) * sizeof (const char *)));
reg_info = ((byte_register_info_type *) __builtin_alloca((num_regs) * sizeof (byte_register_info_type)));
reg_dummy = ((const char * *) __builtin_alloca((num_regs) * sizeof (const char *)));
reg_info_dummy = ((byte_register_info_type *) __builtin_alloca((num_regs) * sizeof (byte_register_info_type)));
if (!(regstart && regend && old_regstart && old_regend && reg_info
&& best_regstart && best_regend && reg_dummy && reg_info_dummy))
{
do { ; if (regstart) ((void)0); regstart = ((void *)0); if (regend) ((void)0); regend = ((void *)0); if (old_regstart) ((void)0); old_regstart = ((void *)0); if (old_regend) ((void)0); old_regend = ((void *)0); if (best_regstart) ((void)0); best_regstart = ((void *)0); if (best_regend) ((void)0); best_regend = ((void *)0); if (reg_info) ((void)0); reg_info = ((void *)0); if (reg_dummy) ((void)0); reg_dummy = ((void *)0); if (reg_info_dummy) ((void)0); reg_info_dummy = ((void *)0); } while (0);
return -2;
}
}
else
{
regstart = regend = old_regstart = old_regend = best_regstart
= best_regend = reg_dummy = ((void *)0);
reg_info = reg_info_dummy = (byte_register_info_type *) ((void *)0);
}
if (pos < 0 || pos > size1 + size2)
{
do { ; if (regstart) ((void)0); regstart = ((void *)0); if (regend) ((void)0); regend = ((void *)0); if (old_regstart) ((void)0); old_regstart = ((void *)0); if (old_regend) ((void)0); old_regend = ((void *)0); if (best_regstart) ((void)0); best_regstart = ((void *)0); if (best_regend) ((void)0); best_regend = ((void *)0); if (reg_info) ((void)0); reg_info = ((void *)0); if (reg_dummy) ((void)0); reg_dummy = ((void *)0); if (reg_info_dummy) ((void)0); reg_info_dummy = ((void *)0); } while (0);
return -1;
}
# 5785 "../../libiberty/regex.c"
for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
{
regstart[mcnt] = regend[mcnt]
= old_regstart[mcnt] = old_regend[mcnt] = (&byte_reg_unset_dummy);
((reg_info[mcnt]).bits.match_null_string_p) = 3;
((reg_info[mcnt]).bits.is_active) = 0;
((reg_info[mcnt]).bits.matched_something) = 0;
((reg_info[mcnt]).bits.ever_matched_something) = 0;
}
if (size2 == 0 && string1 != ((void *)0))
{
string2 = string1;
size2 = size1;
string1 = 0;
size1 = 0;
}
end1 = string1 + size1;
end2 = string2 + size2;
# 5836 "../../libiberty/regex.c"
if (stop <= size1)
{
end_match_1 = string1 + stop;
end_match_2 = string2;
}
else
{
end_match_1 = end1;
end_match_2 = string2 + stop - size1;
}
# 5874 "../../libiberty/regex.c"
if (size1 > 0 && pos <= size1)
{
d = string1 + pos;
dend = end_match_1;
}
else
{
d = string2 + pos - size1;
dend = end_match_2;
}
;
;
;
;
;
for (;;)
{
;
if (p == pend)
{
;
if (d != end_match_2)
{
boolean same_str_p = ((size1 && string1 <= (match_end) && (match_end) <= string1 + size1)
== (dend == end_match_1));
boolean best_match_p;
if (same_str_p)
best_match_p = d > match_end;
else
best_match_p = !(dend == end_match_1);
;
if (!(fail_stack.avail == 0))
{
if (!best_regs_set || best_match_p)
{
best_regs_set = 1;
match_end = d;
;
for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
{
best_regstart[mcnt] = regstart[mcnt];
best_regend[mcnt] = regend[mcnt];
}
}
goto fail;
}
else if (best_regs_set && !best_match_p)
{
restore_best_regs:
;
d = match_end;
dend = ((d >= string1 && d <= end1)
? end_match_1 : end_match_2);
for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
{
regstart[mcnt] = best_regstart[mcnt];
regend[mcnt] = best_regend[mcnt];
}
}
}
succeed_label:
;
if (regs && !bufp->no_sub)
{
if (bufp->regs_allocated == 0)
{
regs->num_regs = ((30) > (num_regs + 1) ? (30) : (num_regs + 1));
regs->start = ((regoff_t *) malloc ((regs->num_regs) * sizeof (regoff_t)));
regs->end = ((regoff_t *) malloc ((regs->num_regs) * sizeof (regoff_t)));
if (regs->start == ((void *)0) || regs->end == ((void *)0))
{
do { ; if (regstart) ((void)0); regstart = ((void *)0); if (regend) ((void)0); regend = ((void *)0); if (old_regstart) ((void)0); old_regstart = ((void *)0); if (old_regend) ((void)0); old_regend = ((void *)0); if (best_regstart) ((void)0); best_regstart = ((void *)0); if (best_regend) ((void)0); best_regend = ((void *)0); if (reg_info) ((void)0); reg_info = ((void *)0); if (reg_dummy) ((void)0); reg_dummy = ((void *)0); if (reg_info_dummy) ((void)0); reg_info_dummy = ((void *)0); } while (0);
return -2;
}
bufp->regs_allocated = 1;
}
else if (bufp->regs_allocated == 1)
{
if (regs->num_regs < num_regs + 1)
{
regs->num_regs = num_regs + 1;
((regs->start) = (regoff_t *) realloc (regs->start, (regs->num_regs) * sizeof (regoff_t)));
((regs->end) = (regoff_t *) realloc (regs->end, (regs->num_regs) * sizeof (regoff_t)));
if (regs->start == ((void *)0) || regs->end == ((void *)0))
{
do { ; if (regstart) ((void)0); regstart = ((void *)0); if (regend) ((void)0); regend = ((void *)0); if (old_regstart) ((void)0); old_regstart = ((void *)0); if (old_regend) ((void)0); old_regend = ((void *)0); if (best_regstart) ((void)0); best_regstart = ((void *)0); if (best_regend) ((void)0); best_regend = ((void *)0); if (reg_info) ((void)0); reg_info = ((void *)0); if (reg_dummy) ((void)0); reg_dummy = ((void *)0); if (reg_info_dummy) ((void)0); reg_info_dummy = ((void *)0); } while (0);
return -2;
}
}
}
else
{
;
}
if (regs->num_regs > 0)
{
regs->start[0] = pos;
# 6029 "../../libiberty/regex.c"
regs->end[0] = ((dend == end_match_1)
? ((regoff_t) (d - string1))
: ((regoff_t) (d - string2 + size1)));
}
for (mcnt = 1; (unsigned) mcnt < ((num_regs) < (regs->num_regs) ? (num_regs) : (regs->num_regs));
mcnt++)
{
if (((regstart[mcnt]) == (&byte_reg_unset_dummy)) || ((regend[mcnt]) == (&byte_reg_unset_dummy)))
regs->start[mcnt] = regs->end[mcnt] = -1;
else
{
regs->start[mcnt]
= (regoff_t) ((size1 && string1 <= (regstart[mcnt]) && (regstart[mcnt]) <= string1 + size1) ? ((regoff_t) ((regstart[mcnt]) - string1)) : ((regoff_t) ((regstart[mcnt]) - string2 + size1)));
regs->end[mcnt]
= (regoff_t) ((size1 && string1 <= (regend[mcnt]) && (regend[mcnt]) <= string1 + size1) ? ((regoff_t) ((regend[mcnt]) - string1)) : ((regoff_t) ((regend[mcnt]) - string2 + size1)));
}
}
for (mcnt = num_regs; (unsigned) mcnt < regs->num_regs; mcnt++)
regs->start[mcnt] = regs->end[mcnt] = -1;
}
;
;
# 6073 "../../libiberty/regex.c"
mcnt = d - pos - ((dend == end_match_1)
? string1
: string2 - size1);
;
do { ; if (regstart) ((void)0); regstart = ((void *)0); if (regend) ((void)0); regend = ((void *)0); if (old_regstart) ((void)0); old_regstart = ((void *)0); if (old_regend) ((void)0); old_regend = ((void *)0); if (best_regstart) ((void)0); best_regstart = ((void *)0); if (best_regend) ((void)0); best_regend = ((void *)0); if (reg_info) ((void)0); reg_info = ((void *)0); if (reg_dummy) ((void)0); reg_dummy = ((void *)0); if (reg_info_dummy) ((void)0); reg_info_dummy = ((void *)0); } while (0);
return mcnt;
}
switch (((re_opcode_t) *p++))
{
case no_op:
;
break;
case succeed:
;
goto succeed_label;
case exactn:
mcnt = *p++;
;
if (translate)
{
do
{
while (d == dend) { if (dend == end_match_2) goto fail; d = string2; dend = end_match_2; };
# 6127 "../../libiberty/regex.c"
if ((unsigned char) translate[(unsigned char) *d++]
!= (unsigned char) *p++)
goto fail;
}
while (--mcnt);
}
else
{
do
{
while (d == dend) { if (dend == end_match_2) goto fail; d = string2; dend = end_match_2; };
if (*d++ != (char) *p++) goto fail;
}
while (--mcnt);
}
do { if (!set_regs_matched_done) { active_reg_t r; set_regs_matched_done = 1; for (r = lowest_active_reg; r <= highest_active_reg; r++) { ((reg_info[r]).bits.matched_something) = ((reg_info[r]).bits.ever_matched_something) = 1; } } } while (0);
break;
case anychar:
;
while (d == dend) { if (dend == end_match_2) goto fail; d = string2; dend = end_match_2; };
if ((!(bufp->syntax & ((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1)) && (translate ? (char) translate[(unsigned char) (*d)] : (char) (*d)) == '\n')
|| (bufp->syntax & (((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) && (translate ? (char) translate[(unsigned char) (*d)] : (char) (*d)) == '\000'))
goto fail;
do { if (!set_regs_matched_done) { active_reg_t r; set_regs_matched_done = 1; for (r = lowest_active_reg; r <= highest_active_reg; r++) { ((reg_info[r]).bits.matched_something) = ((reg_info[r]).bits.ever_matched_something) = 1; } } } while (0);
;
d++;
break;
case charset:
case charset_not:
{
register unsigned char c;
# 6177 "../../libiberty/regex.c"
boolean negate = (re_opcode_t) *(p - 1) == charset_not;
;
while (d == dend) { if (dend == end_match_2) goto fail; d = string2; dend = end_match_2; };
c = (translate ? (char) translate[(unsigned char) (*d)] : (char) (*d));
# 6553 "../../libiberty/regex.c"
if (c < (unsigned) (*p * 8)
&& p[1 + c / 8] & (1 << (c % 8)))
negate = !negate;
p += 1 + *p;
if (!negate) goto fail;
do { if (!set_regs_matched_done) { active_reg_t r; set_regs_matched_done = 1; for (r = lowest_active_reg; r <= highest_active_reg; r++) { ((reg_info[r]).bits.matched_something) = ((reg_info[r]).bits.ever_matched_something) = 1; } } } while (0);
d++;
break;
}
case start_memory:
;
p1 = p;
if (((reg_info[*p]).bits.match_null_string_p) == 3)
((reg_info[*p]).bits.match_null_string_p)
= byte_group_match_null_string_p (&p1, pend, reg_info);
old_regstart[*p] = ((reg_info[*p]).bits.match_null_string_p)
? ((regstart[*p]) == (&byte_reg_unset_dummy)) ? d : regstart[*p]
: regstart[*p];
;
regstart[*p] = d;
;
((reg_info[*p]).bits.is_active) = 1;
((reg_info[*p]).bits.matched_something) = 0;
set_regs_matched_done = 0;
highest_active_reg = *p;
if (lowest_active_reg == ((1 << 8) + 1))
lowest_active_reg = *p;
p += 2;
just_past_start_mem = p;
break;
case stop_memory:
;
old_regend[*p] = ((reg_info[*p]).bits.match_null_string_p)
? ((regend[*p]) == (&byte_reg_unset_dummy)) ? d : regend[*p]
: regend[*p];
;
regend[*p] = d;
;
((reg_info[*p]).bits.is_active) = 0;
set_regs_matched_done = 0;
if (lowest_active_reg == highest_active_reg)
{
lowest_active_reg = ((1 << 8) + 1);
highest_active_reg = (1 << 8);
}
else
{
unsigned char r = *p - 1;
while (r > 0 && !((reg_info[r]).bits.is_active))
r--;
# 6669 "../../libiberty/regex.c"
if (r == 0)
{
lowest_active_reg = ((1 << 8) + 1);
highest_active_reg = (1 << 8);
}
else
highest_active_reg = r;
}
if ((!((reg_info[*p]).bits.matched_something)
|| just_past_start_mem == p - 1)
&& (p + 2) < pend)
{
boolean is_a_jump_n = 0;
p1 = p + 2;
mcnt = 0;
switch ((re_opcode_t) *p1++)
{
case jump_n:
is_a_jump_n = 1;
case pop_failure_jump:
case maybe_pop_jump:
case jump:
case dummy_failure_jump:
do { do { (mcnt) = *(p1) & 0377; (mcnt) += ((signed char) (*((p1) + 1))) << 8; } while (0); (p1) += 2; } while (0);
if (is_a_jump_n)
p1 += 2;
break;
default:
;
}
p1 += mcnt;
if (mcnt < 0 && (re_opcode_t) *p1 == on_failure_jump
&& (re_opcode_t) p1[1+2] == start_memory
&& p1[2+2] == *p)
{
# 6728 "../../libiberty/regex.c"
if (((reg_info[*p]).bits.ever_matched_something))
{
unsigned r;
((reg_info[*p]).bits.ever_matched_something) = 0;
for (r = *p; r < (unsigned) *p + (unsigned) *(p + 1);
r++)
{
regstart[r] = old_regstart[r];
if (old_regend[r] >= regstart[r])
regend[r] = old_regend[r];
}
}
p1++;
do { do { (mcnt) = *(p1) & 0377; (mcnt) += ((signed char) (*((p1) + 1))) << 8; } while (0); (p1) += 2; } while (0);
do { char *destination; active_reg_t this_reg; ; ; ; ; ; ; ; while (((fail_stack).size - (fail_stack).avail) < (((0 ? 0 : highest_active_reg - lowest_active_reg + 1) * 3) + 4)) { if (!((fail_stack).size > (unsigned) (xre_max_failures * (5 * 3 + 4)) ? 0 : ((fail_stack).stack = (byte_fail_stack_elt_t *) (destination = (char *) __builtin_alloca(((fail_stack).size << 1) * sizeof (byte_fail_stack_elt_t)), memcpy (destination, (fail_stack).stack, (fail_stack).size * sizeof (byte_fail_stack_elt_t))), (fail_stack).stack == ((void *)0) ? 0 : ((fail_stack).size <<= 1, 1)))) return -2; ; ; } ; if (1) for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; this_reg++) { ; ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (regstart[this_reg]); ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (regend[this_reg]); ; ; ; ; ; ; fail_stack.stack[fail_stack.avail++] = (reg_info[this_reg].word); } ; fail_stack.stack[fail_stack.avail++].integer = (lowest_active_reg); ; fail_stack.stack[fail_stack.avail++].integer = (highest_active_reg); ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (p1 + mcnt); ; ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (d); ; ; } while (0);
goto fail;
}
}
p += 2;
break;
case duplicate:
{
register const char *d2, *dend2;
int regno = *p++;
;
if (((regstart[regno]) == (&byte_reg_unset_dummy)) || ((regend[regno]) == (&byte_reg_unset_dummy)))
goto fail;
d2 = regstart[regno];
dend2 = (((size1 && string1 <= (regstart[regno]) && (regstart[regno]) <= string1 + size1)
== (size1 && string1 <= (regend[regno]) && (regend[regno]) <= string1 + size1))
? regend[regno] : end_match_1);
for (;;)
{
while (d2 == dend2)
{
if (dend2 == end_match_2) break;
if (dend2 == regend[regno]) break;
d2 = string2;
dend2 = regend[regno];
}
if (d2 == dend2) break;
while (d == dend) { if (dend == end_match_2) goto fail; d = string2; dend = end_match_2; };
mcnt = dend - d;
if (mcnt > dend2 - d2)
mcnt = dend2 - d2;
if (translate
? byte_bcmp_translate (d, d2, mcnt, translate)
: memcmp (d, d2, mcnt*sizeof(unsigned char)))
goto fail;
d += mcnt, d2 += mcnt;
do { if (!set_regs_matched_done) { active_reg_t r; set_regs_matched_done = 1; for (r = lowest_active_reg; r <= highest_active_reg; r++) { ((reg_info[r]).bits.matched_something) = ((reg_info[r]).bits.ever_matched_something) = 1; } } } while (0);
}
}
break;
case begline:
;
if (((d) == (size1 ? string1 : string2) || !size2))
{
if (!bufp->not_bol) break;
}
else if (d[-1] == '\n' && bufp->newline_anchor)
{
break;
}
goto fail;
case endline:
;
if (((d) == end2))
{
if (!bufp->not_eol) break;
}
else if ((d == end1 ? *string2 : *d) == '\n'
&& bufp->newline_anchor)
{
break;
}
goto fail;
case begbuf:
;
if (((d) == (size1 ? string1 : string2) || !size2))
break;
goto fail;
case endbuf:
;
if (((d) == end2))
break;
goto fail;
# 6891 "../../libiberty/regex.c"
case on_failure_keep_string_jump:
;
do { do { (mcnt) = *(p) & 0377; (mcnt) += ((signed char) (*((p) + 1))) << 8; } while (0); (p) += 2; } while (0);
;
do { char *destination; active_reg_t this_reg; ; ; ; ; ; ; ; while (((fail_stack).size - (fail_stack).avail) < (((0 ? 0 : highest_active_reg - lowest_active_reg + 1) * 3) + 4)) { if (!((fail_stack).size > (unsigned) (xre_max_failures * (5 * 3 + 4)) ? 0 : ((fail_stack).stack = (byte_fail_stack_elt_t *) (destination = (char *) __builtin_alloca(((fail_stack).size << 1) * sizeof (byte_fail_stack_elt_t)), memcpy (destination, (fail_stack).stack, (fail_stack).size * sizeof (byte_fail_stack_elt_t))), (fail_stack).stack == ((void *)0) ? 0 : ((fail_stack).size <<= 1, 1)))) return -2; ; ; } ; if (1) for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; this_reg++) { ; ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (regstart[this_reg]); ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (regend[this_reg]); ; ; ; ; ; ; fail_stack.stack[fail_stack.avail++] = (reg_info[this_reg].word); } ; fail_stack.stack[fail_stack.avail++].integer = (lowest_active_reg); ; fail_stack.stack[fail_stack.avail++].integer = (highest_active_reg); ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (p + mcnt); ; ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (((void *)0)); ; ; } while (0);
break;
# 6917 "../../libiberty/regex.c"
case on_failure_jump:
on_failure:
;
do { do { (mcnt) = *(p) & 0377; (mcnt) += ((signed char) (*((p) + 1))) << 8; } while (0); (p) += 2; } while (0);
;
# 6937 "../../libiberty/regex.c"
p1 = p;
while (p1 < pend && (re_opcode_t) *p1 == no_op)
p1++;
if (p1 < pend && (re_opcode_t) *p1 == start_memory)
{
highest_active_reg = *(p1 + 1) + *(p1 + 2);
if (lowest_active_reg == ((1 << 8) + 1))
lowest_active_reg = *(p1 + 1);
}
;
do { char *destination; active_reg_t this_reg; ; ; ; ; ; ; ; while (((fail_stack).size - (fail_stack).avail) < (((0 ? 0 : highest_active_reg - lowest_active_reg + 1) * 3) + 4)) { if (!((fail_stack).size > (unsigned) (xre_max_failures * (5 * 3 + 4)) ? 0 : ((fail_stack).stack = (byte_fail_stack_elt_t *) (destination = (char *) __builtin_alloca(((fail_stack).size << 1) * sizeof (byte_fail_stack_elt_t)), memcpy (destination, (fail_stack).stack, (fail_stack).size * sizeof (byte_fail_stack_elt_t))), (fail_stack).stack == ((void *)0) ? 0 : ((fail_stack).size <<= 1, 1)))) return -2; ; ; } ; if (1) for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; this_reg++) { ; ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (regstart[this_reg]); ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (regend[this_reg]); ; ; ; ; ; ; fail_stack.stack[fail_stack.avail++] = (reg_info[this_reg].word); } ; fail_stack.stack[fail_stack.avail++].integer = (lowest_active_reg); ; fail_stack.stack[fail_stack.avail++].integer = (highest_active_reg); ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (p + mcnt); ; ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (d); ; ; } while (0);
break;
case maybe_pop_jump:
do { do { (mcnt) = *(p) & 0377; (mcnt) += ((signed char) (*((p) + 1))) << 8; } while (0); (p) += 2; } while (0);
;
{
register unsigned char *p2 = p;
# 6987 "../../libiberty/regex.c"
while (1)
{
if (p2 + 2 < pend
&& ((re_opcode_t) *p2 == stop_memory
|| (re_opcode_t) *p2 == start_memory))
p2 += 3;
else if (p2 + 2 + 2 * 2 < pend
&& (re_opcode_t) *p2 == dummy_failure_jump)
p2 += 2 + 2 * 2;
else
break;
}
p1 = p + mcnt;
if (p2 == pend)
{
p[-(1+2)] = (unsigned char)
pop_failure_jump;
;
}
else if ((re_opcode_t) *p2 == exactn
|| (bufp->newline_anchor && (re_opcode_t) *p2 == endline))
{
register unsigned char c
= *p2 == (unsigned char) endline ? '\n' : p2[2];
if (((re_opcode_t) p1[1+2] == exactn
) && p1[3+2] != c)
{
p[-(1+2)] = (unsigned char)
pop_failure_jump;
;
}
else if ((re_opcode_t) p1[3] == charset
|| (re_opcode_t) p1[3] == charset_not)
{
int negate = (re_opcode_t) p1[3] == charset_not;
if (c < (unsigned) (p1[4] * 8)
&& p1[5 + c / 8] & (1 << (c % 8)))
negate = !negate;
if (!negate)
{
p[-3] = (unsigned char) pop_failure_jump;
;
}
}
}
else if ((re_opcode_t) *p2 == charset)
{
if ((re_opcode_t) p1[3] == exactn
&& ! ((int) p2[1] * 8 > (int) p1[5]
&& (p2[2 + p1[5] / 8]
& (1 << (p1[5] % 8)))))
{
p[-3] = (unsigned char) pop_failure_jump;
;
}
else if ((re_opcode_t) p1[3] == charset_not)
{
int idx;
for (idx = 0; idx < (int) p2[1]; idx++)
if (! (p2[2 + idx] == 0
|| (idx < (int) p1[4]
&& ((p2[2 + idx] & ~ p1[5 + idx]) == 0))))
break;
if (idx == p2[1])
{
p[-3] = (unsigned char) pop_failure_jump;
;
}
}
else if ((re_opcode_t) p1[3] == charset)
{
int idx;
for (idx = 0;
idx < (int) p2[1] && idx < (int) p1[4];
idx++)
if ((p2[2 + idx] & p1[5 + idx]) != 0)
break;
if (idx == p2[1] || idx == p1[4])
{
p[-3] = (unsigned char) pop_failure_jump;
;
}
}
}
}
p -= 2;
if ((re_opcode_t) p[-1] != pop_failure_jump)
{
p[-1] = (unsigned char) jump;
;
goto unconditional_jump;
}
# 7132 "../../libiberty/regex.c"
case pop_failure_jump:
{
active_reg_t dummy_low_reg, dummy_high_reg;
unsigned char *pdummy = ((void *)0);
const char *sdummy = ((void *)0);
;
{ active_reg_t this_reg; const unsigned char *string_temp; ; ; ; ; ; ; ; string_temp = fail_stack.stack[--fail_stack.avail].pointer; if (string_temp != ((void *)0)) sdummy = (const char *) string_temp; ; ; ; pdummy = (unsigned char *) fail_stack.stack[--fail_stack.avail].pointer; ; ; dummy_high_reg = (active_reg_t) fail_stack.stack[--fail_stack.avail].integer; ; dummy_low_reg = (active_reg_t) fail_stack.stack[--fail_stack.avail].integer; ; if (1) for (this_reg = dummy_high_reg; this_reg >= dummy_low_reg; this_reg--) { ; reg_info_dummy[this_reg].word = fail_stack.stack[--fail_stack.avail]; ; reg_dummy[this_reg] = (const char *) fail_stack.stack[--fail_stack.avail].pointer; ; reg_dummy[this_reg] = (const char *) fail_stack.stack[--fail_stack.avail].pointer; ; } else { for (this_reg = highest_active_reg; this_reg > dummy_high_reg; this_reg--) { reg_info_dummy[this_reg].word.integer = 0; reg_dummy[this_reg] = 0; reg_dummy[this_reg] = 0; } highest_active_reg = dummy_high_reg; } set_regs_matched_done = 0; ; };
}
unconditional_jump:
;
case jump:
do { do { (mcnt) = *(p) & 0377; (mcnt) += ((signed char) (*((p) + 1))) << 8; } while (0); (p) += 2; } while (0);
;
p += mcnt;
;
break;
case jump_past_alt:
;
goto unconditional_jump;
case dummy_failure_jump:
;
do { char *destination; active_reg_t this_reg; ; ; ; ; ; ; ; while (((fail_stack).size - (fail_stack).avail) < (((0 ? 0 : highest_active_reg - lowest_active_reg + 1) * 3) + 4)) { if (!((fail_stack).size > (unsigned) (xre_max_failures * (5 * 3 + 4)) ? 0 : ((fail_stack).stack = (byte_fail_stack_elt_t *) (destination = (char *) __builtin_alloca(((fail_stack).size << 1) * sizeof (byte_fail_stack_elt_t)), memcpy (destination, (fail_stack).stack, (fail_stack).size * sizeof (byte_fail_stack_elt_t))), (fail_stack).stack == ((void *)0) ? 0 : ((fail_stack).size <<= 1, 1)))) return -2; ; ; } ; if (1) for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; this_reg++) { ; ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (regstart[this_reg]); ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (regend[this_reg]); ; ; ; ; ; ; fail_stack.stack[fail_stack.avail++] = (reg_info[this_reg].word); } ; fail_stack.stack[fail_stack.avail++].integer = (lowest_active_reg); ; fail_stack.stack[fail_stack.avail++].integer = (highest_active_reg); ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (((void *)0)); ; ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (((void *)0)); ; ; } while (0);
goto unconditional_jump;
case push_dummy_failure:
;
do { char *destination; active_reg_t this_reg; ; ; ; ; ; ; ; while (((fail_stack).size - (fail_stack).avail) < (((0 ? 0 : highest_active_reg - lowest_active_reg + 1) * 3) + 4)) { if (!((fail_stack).size > (unsigned) (xre_max_failures * (5 * 3 + 4)) ? 0 : ((fail_stack).stack = (byte_fail_stack_elt_t *) (destination = (char *) __builtin_alloca(((fail_stack).size << 1) * sizeof (byte_fail_stack_elt_t)), memcpy (destination, (fail_stack).stack, (fail_stack).size * sizeof (byte_fail_stack_elt_t))), (fail_stack).stack == ((void *)0) ? 0 : ((fail_stack).size <<= 1, 1)))) return -2; ; ; } ; if (1) for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; this_reg++) { ; ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (regstart[this_reg]); ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (regend[this_reg]); ; ; ; ; ; ; fail_stack.stack[fail_stack.avail++] = (reg_info[this_reg].word); } ; fail_stack.stack[fail_stack.avail++].integer = (lowest_active_reg); ; fail_stack.stack[fail_stack.avail++].integer = (highest_active_reg); ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (((void *)0)); ; ; ; fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (((void *)0)); ; ; } while (0);
break;
case succeed_n:
do { (mcnt) = *(p + 2) & 0377; (mcnt) += ((signed char) (*((p + 2) + 1))) << 8; } while (0);
;
;
if (mcnt > 0)
{
mcnt--;
p += 2;
do { do { (p)[0] = (mcnt) & 0377; (p)[1] = (mcnt) >> 8; } while (0); (p) += 2; } while (0);
;
}
else if (mcnt == 0)
{
;
p[2] = (unsigned char) no_op;
p[3] = (unsigned char) no_op;
goto on_failure;
}
break;
case jump_n:
do { (mcnt) = *(p + 2) & 0377; (mcnt) += ((signed char) (*((p + 2) + 1))) << 8; } while (0);
;
if (mcnt)
{
mcnt--;
do { (p + 2)[0] = (mcnt) & 0377; (p + 2)[1] = (mcnt) >> 8; } while (0);
;
goto unconditional_jump;
}
else
p += 2 * 2;
break;
case set_number_at:
{
;
do { do { (mcnt) = *(p) & 0377; (mcnt) += ((signed char) (*((p) + 1))) << 8; } while (0); (p) += 2; } while (0);
p1 = p + mcnt;
do { do { (mcnt) = *(p) & 0377; (mcnt) += ((signed char) (*((p) + 1))) << 8; } while (0); (p) += 2; } while (0);
;
do { (p1)[0] = (mcnt) & 0377; (p1)[1] = (mcnt) >> 8; } while (0);
break;
}
# 7302 "../../libiberty/regex.c"
case wordbound:
{
boolean prevchar, thischar;
;
if (((d) == (size1 ? string1 : string2) || !size2) || ((d) == end2))
break;
prevchar = (re_syntax_table[(unsigned char) ((d - 1) == end1 ? *string2 : (d - 1) == string2 - 1 ? *(end1 - 1) : *(d - 1))] == 1);
thischar = (re_syntax_table[(unsigned char) ((d) == end1 ? *string2 : (d) == string2 - 1 ? *(end1 - 1) : *(d))] == 1);
if (prevchar != thischar)
break;
goto fail;
}
case notwordbound:
{
boolean prevchar, thischar;
;
if (((d) == (size1 ? string1 : string2) || !size2) || ((d) == end2))
goto fail;
prevchar = (re_syntax_table[(unsigned char) ((d - 1) == end1 ? *string2 : (d - 1) == string2 - 1 ? *(end1 - 1) : *(d - 1))] == 1);
thischar = (re_syntax_table[(unsigned char) ((d) == end1 ? *string2 : (d) == string2 - 1 ? *(end1 - 1) : *(d))] == 1);
if (prevchar != thischar)
goto fail;
break;
}
case wordbeg:
;
if (!((d) == end2) && (re_syntax_table[(unsigned char) ((d) == end1 ? *string2 : (d) == string2 - 1 ? *(end1 - 1) : *(d))] == 1)
&& (((d) == (size1 ? string1 : string2) || !size2) || !(re_syntax_table[(unsigned char) ((d - 1) == end1 ? *string2 : (d - 1) == string2 - 1 ? *(end1 - 1) : *(d - 1))] == 1)))
break;
goto fail;
case wordend:
;
if (!((d) == (size1 ? string1 : string2) || !size2) && (re_syntax_table[(unsigned char) ((d - 1) == end1 ? *string2 : (d - 1) == string2 - 1 ? *(end1 - 1) : *(d - 1))] == 1)
&& (((d) == end2) || !(re_syntax_table[(unsigned char) ((d) == end1 ? *string2 : (d) == string2 - 1 ? *(end1 - 1) : *(d))] == 1)))
break;
goto fail;
# 7401 "../../libiberty/regex.c"
case wordchar:
;
while (d == dend) { if (dend == end_match_2) goto fail; d = string2; dend = end_match_2; };
if (!(re_syntax_table[(unsigned char) ((d) == end1 ? *string2 : (d) == string2 - 1 ? *(end1 - 1) : *(d))] == 1))
goto fail;
do { if (!set_regs_matched_done) { active_reg_t r; set_regs_matched_done = 1; for (r = lowest_active_reg; r <= highest_active_reg; r++) { ((reg_info[r]).bits.matched_something) = ((reg_info[r]).bits.ever_matched_something) = 1; } } } while (0);
d++;
break;
case notwordchar:
;
while (d == dend) { if (dend == end_match_2) goto fail; d = string2; dend = end_match_2; };
if ((re_syntax_table[(unsigned char) ((d) == end1 ? *string2 : (d) == string2 - 1 ? *(end1 - 1) : *(d))] == 1))
goto fail;
do { if (!set_regs_matched_done) { active_reg_t r; set_regs_matched_done = 1; for (r = lowest_active_reg; r <= highest_active_reg; r++) { ((reg_info[r]).bits.matched_something) = ((reg_info[r]).bits.ever_matched_something) = 1; } } } while (0);
d++;
break;
default:
abort ();
}
continue;
fail:
if (!(fail_stack.avail == 0))
{
;
{ active_reg_t this_reg; const unsigned char *string_temp; ; ; ; ; ; ; ; string_temp = fail_stack.stack[--fail_stack.avail].pointer; if (string_temp != ((void *)0)) d = (const char *) string_temp; ; ; ; p = (unsigned char *) fail_stack.stack[--fail_stack.avail].pointer; ; ; highest_active_reg = (active_reg_t) fail_stack.stack[--fail_stack.avail].integer; ; lowest_active_reg = (active_reg_t) fail_stack.stack[--fail_stack.avail].integer; ; if (1) for (this_reg = highest_active_reg; this_reg >= lowest_active_reg; this_reg--) { ; reg_info[this_reg].word = fail_stack.stack[--fail_stack.avail]; ; regend[this_reg] = (const char *) fail_stack.stack[--fail_stack.avail].pointer; ; regstart[this_reg] = (const char *) fail_stack.stack[--fail_stack.avail].pointer; ; } else { for (this_reg = highest_active_reg; this_reg > highest_active_reg; this_reg--) { reg_info[this_reg].word.integer = 0; regend[this_reg] = 0; regstart[this_reg] = 0; } highest_active_reg = highest_active_reg; } set_regs_matched_done = 0; ; };
if (!p)
goto fail;
;
if (p < pend)
{
boolean is_a_jump_n = 0;
switch ((re_opcode_t) *p)
{
case jump_n:
is_a_jump_n = 1;
case maybe_pop_jump:
case pop_failure_jump:
case jump:
p1 = p + 1;
do { do { (mcnt) = *(p1) & 0377; (mcnt) += ((signed char) (*((p1) + 1))) << 8; } while (0); (p1) += 2; } while (0);
p1 += mcnt;
if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n)
|| (!is_a_jump_n
&& (re_opcode_t) *p1 == on_failure_jump))
goto fail;
break;
default:
;
}
}
if (d >= string1 && d <= end1)
dend = end_match_1;
}
else
break;
}
if (best_regs_set)
goto restore_best_regs;
do { ; if (regstart) ((void)0); regstart = ((void *)0); if (regend) ((void)0); regend = ((void *)0); if (old_regstart) ((void)0); old_regstart = ((void *)0); if (old_regend) ((void)0); old_regend = ((void *)0); if (best_regstart) ((void)0); best_regstart = ((void *)0); if (best_regend) ((void)0); best_regend = ((void *)0); if (reg_info) ((void)0); reg_info = ((void *)0); if (reg_dummy) ((void)0); reg_dummy = ((void *)0); if (reg_info_dummy) ((void)0); reg_info_dummy = ((void *)0); } while (0);
return -1;
}
# 7496 "../../libiberty/regex.c"
static boolean
byte_group_match_null_string_p (unsigned char **p, unsigned char *end,
byte_register_info_type *reg_info)
{
int mcnt;
unsigned char *p1 = *p + 2;
while (p1 < end)
{
switch ((re_opcode_t) *p1)
{
case on_failure_jump:
p1++;
do { do { (mcnt) = *(p1) & 0377; (mcnt) += ((signed char) (*((p1) + 1))) << 8; } while (0); (p1) += 2; } while (0);
if (mcnt >= 0)
{
# 7540 "../../libiberty/regex.c"
while ((re_opcode_t) p1[mcnt-(1+2)] ==
jump_past_alt)
{
if (!byte_alt_match_null_string_p (p1, p1 + mcnt -
(1 + 2),
reg_info))
return 0;
p1 += mcnt;
if ((re_opcode_t) *p1 != on_failure_jump)
break;
p1++;
do { do { (mcnt) = *(p1) & 0377; (mcnt) += ((signed char) (*((p1) + 1))) << 8; } while (0); (p1) += 2; } while (0);
if ((re_opcode_t) p1[mcnt-(1+2)] !=
jump_past_alt)
{
p1 -= 1 + 2;
break;
}
}
do { (mcnt) = *(p1 - 2) & 0377; (mcnt) += ((signed char) (*((p1 - 2) + 1))) << 8; } while (0);
if (!byte_alt_match_null_string_p (p1, p1 + mcnt, reg_info))
return 0;
p1 += mcnt;
}
break;
case stop_memory:
;
*p = p1 + 2;
return 1;
default:
if (!byte_common_op_match_null_string_p (&p1, end, reg_info))
return 0;
}
}
return 0;
}
static boolean
byte_alt_match_null_string_p (unsigned char *p, unsigned char *end,
byte_register_info_type *reg_info)
{
int mcnt;
unsigned char *p1 = p;
while (p1 < end)
{
switch ((re_opcode_t) *p1)
{
case on_failure_jump:
p1++;
do { do { (mcnt) = *(p1) & 0377; (mcnt) += ((signed char) (*((p1) + 1))) << 8; } while (0); (p1) += 2; } while (0);
p1 += mcnt;
break;
default:
if (!byte_common_op_match_null_string_p (&p1, end, reg_info))
return 0;
}
}
return 1;
}
static boolean
byte_common_op_match_null_string_p (unsigned char **p, unsigned char *end,
byte_register_info_type *reg_info)
{
int mcnt;
boolean ret;
int reg_no;
unsigned char *p1 = *p;
switch ((re_opcode_t) *p1++)
{
case no_op:
case begline:
case endline:
case begbuf:
case endbuf:
case wordbeg:
case wordend:
case wordbound:
case notwordbound:
break;
case start_memory:
reg_no = *p1;
;
ret = byte_group_match_null_string_p (&p1, end, reg_info);
if (((reg_info[reg_no]).bits.match_null_string_p) == 3)
((reg_info[reg_no]).bits.match_null_string_p) = ret;
if (!ret)
return 0;
break;
case jump:
do { do { (mcnt) = *(p1) & 0377; (mcnt) += ((signed char) (*((p1) + 1))) << 8; } while (0); (p1) += 2; } while (0);
if (mcnt >= 0)
p1 += mcnt;
else
return 0;
break;
case succeed_n:
p1 += 2;
do { do { (mcnt) = *(p1) & 0377; (mcnt) += ((signed char) (*((p1) + 1))) << 8; } while (0); (p1) += 2; } while (0);
if (mcnt == 0)
{
p1 -= 2 * 2;
do { do { (mcnt) = *(p1) & 0377; (mcnt) += ((signed char) (*((p1) + 1))) << 8; } while (0); (p1) += 2; } while (0);
p1 += mcnt;
}
else
return 0;
break;
case duplicate:
if (!((reg_info[*p1]).bits.match_null_string_p))
return 0;
break;
case set_number_at:
p1 += 2 * 2;
default:
return 0;
}
*p = p1;
return 1;
}
static int
byte_bcmp_translate (const char *s1, const char *s2, register int len,
char * translate)
{
register const unsigned char *p1 = (const unsigned char *) s1;
register const unsigned char *p2 = (const unsigned char *) s2;
while (len)
{
if (translate[*p1++] != translate[*p2++]) return 1;
len--;
}
return 0;
}
# 639 "../../libiberty/regex.c" 2
# 1313 "../../libiberty/regex.c"
reg_syntax_t xre_syntax_options;
# 1323 "../../libiberty/regex.c"
reg_syntax_t
xre_set_syntax (reg_syntax_t syntax)
{
reg_syntax_t ret = xre_syntax_options;
xre_syntax_options = syntax;
return ret;
}
# 1346 "../../libiberty/regex.c"
static const char *re_error_msgid[] =
{
"Success",
"No match",
"Invalid regular expression",
"Invalid collation character",
"Invalid character class name",
"Trailing backslash",
"Invalid back reference",
"Unmatched [ or [^",
"Unmatched ( or \\(",
"Unmatched \\{",
"Invalid content of \\{\\}",
"Invalid range end",
"Memory exhausted",
"Invalid preceding regular expression",
"Premature end of regular expression",
"Regular expression too big",
"Unmatched ) or \\)"
};
# 4326 "../../libiberty/regex.c"
static boolean
group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum)
{
int this_element;
for (this_element = compile_stack.avail - 1;
this_element >= 0;
this_element--)
if (compile_stack.stack[this_element].regnum == regnum)
return 1;
return 0;
}
# 4859 "../../libiberty/regex.c"
int
xre_compile_fastmap (struct re_pattern_buffer *bufp)
{
return byte_re_compile_fastmap(bufp);
}
# 4887 "../../libiberty/regex.c"
void
xre_set_registers (struct re_pattern_buffer *bufp,
struct re_registers *regs, unsigned num_regs,
regoff_t *starts, regoff_t *ends)
{
if (num_regs)
{
bufp->regs_allocated = 1;
regs->num_regs = num_regs;
regs->start = starts;
regs->end = ends;
}
else
{
bufp->regs_allocated = 0;
regs->num_regs = 0;
regs->start = regs->end = (regoff_t *) 0;
}
}
# 4915 "../../libiberty/regex.c"
int
xre_search (struct re_pattern_buffer *bufp, const char *string, int size,
int startpos, int range, struct re_registers *regs)
{
return xre_search_2 (bufp, ((void *)0), 0, string, size, startpos, range,
regs, size);
}
# 4948 "../../libiberty/regex.c"
int
xre_search_2 (struct re_pattern_buffer *bufp, const char *string1, int size1,
const char *string2, int size2, int startpos, int range,
struct re_registers *regs, int stop)
{
return byte_re_search_2 (bufp, string1, size1, string2, size2, startpos,
range, regs, stop);
}
# 5392 "../../libiberty/regex.c"
int
xre_match (struct re_pattern_buffer *bufp, const char *string,
int size, int pos, struct re_registers *regs)
{
int result;
result = byte_re_match_2_internal (bufp, ((void *)0), 0, string, size,
pos, regs, size);
return result;
}
# 5447 "../../libiberty/regex.c"
int
xre_match_2 (struct re_pattern_buffer *bufp, const char *string1, int size1,
const char *string2, int size2, int pos,
struct re_registers *regs, int stop)
{
int result;
result = byte_re_match_2_internal (bufp, string1, size1, string2, size2,
pos, regs, stop);
return result;
}
# 7764 "../../libiberty/regex.c"
const char *
xre_compile_pattern (const char *pattern, size_t length,
struct re_pattern_buffer *bufp)
{
reg_errcode_t ret;
bufp->regs_allocated = 0;
bufp->no_sub = 0;
bufp->newline_anchor = 1;
ret = byte_regex_compile (pattern, length, xre_syntax_options, bufp);
if (!ret)
return ((void *)0);
return (re_error_msgid[(int) ret]);
}
# 7803 "../../libiberty/regex.c"
static struct re_pattern_buffer re_comp_buf;
char *
xre_comp (const char *s)
{
reg_errcode_t ret;
if (!s)
{
if (!re_comp_buf.buffer)
return (char *) ("No previous regular expression");
return 0;
}
if (!re_comp_buf.buffer)
{
re_comp_buf.buffer = (unsigned char *) malloc (200);
if (re_comp_buf.buffer == ((void *)0))
return (char *) (re_error_msgid[(int) REG_ESPACE]);
re_comp_buf.allocated = 200;
re_comp_buf.fastmap = (char *) malloc (1 << 8);
if (re_comp_buf.fastmap == ((void *)0))
return (char *) (re_error_msgid[(int) REG_ESPACE]);
}
re_comp_buf.newline_anchor = 1;
ret = byte_regex_compile (s, strlen (s), xre_syntax_options, &re_comp_buf);
if (!ret)
return ((void *)0);
return (char *) (re_error_msgid[(int) ret]);
}
int
xre_exec (const char *s)
{
const int len = strlen (s);
return
0 <= xre_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0);
}
# 7908 "../../libiberty/regex.c"
int
xregcomp (regex_t *preg, const char *pattern, int cflags)
{
reg_errcode_t ret;
reg_syntax_t syntax
= (cflags & 1) ?
((((((unsigned long int) 1) << 1) << 1) | ((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) | (((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) | (((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) | ((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)) | (((((unsigned long int) 1) << 1) << 1) << 1) | ((((((unsigned long int) 1) << 1) << 1) << 1) << 1) | ((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) | (((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) | (((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) | (((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) | (((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)) : ((((((unsigned long int) 1) << 1) << 1) | ((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) | (((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) | (((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) | ((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)) | (((unsigned long int) 1) << 1));
preg->buffer = 0;
preg->allocated = 0;
preg->used = 0;
preg->fastmap = (char *) malloc (1 << 8);
if (cflags & (1 << 1))
{
int i;
preg->translate
= (char *) malloc (256
* sizeof (*(char *)0));
if (preg->translate == ((void *)0))
return (int) REG_ESPACE;
for (i = 0; i < 256; i++)
preg->translate[i] = (1 && isupper (i)) ? __tolower(i) : i;
}
else
preg->translate = ((void *)0);
if (cflags & ((1 << 1) << 1))
{
syntax &= ~((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1);
syntax |= ((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1);
preg->newline_anchor = 1;
}
else
preg->newline_anchor = 0;
preg->no_sub = !!(cflags & (((1 << 1) << 1) << 1));
# 7961 "../../libiberty/regex.c"
ret = byte_regex_compile (pattern, strlen (pattern), syntax, preg);
if (ret == REG_ERPAREN) ret = REG_EPAREN;
if (ret == REG_NOERROR && preg->fastmap)
{
if (xre_compile_fastmap (preg) == -2)
{
free (preg->fastmap);
preg->fastmap = ((void *)0);
}
}
return (int) ret;
}
# 8001 "../../libiberty/regex.c"
int
xregexec (const regex_t *preg, const char *string, size_t nmatch,
regmatch_t pmatch[], int eflags)
{
int ret;
struct re_registers regs;
regex_t private_preg;
int len = strlen (string);
boolean want_reg_info = !preg->no_sub && nmatch > 0;
private_preg = *preg;
private_preg.not_bol = !!(eflags & 1);
private_preg.not_eol = !!(eflags & (1 << 1));
private_preg.regs_allocated = 2;
if (want_reg_info)
{
regs.num_regs = nmatch;
regs.start = ((regoff_t *) malloc ((nmatch * 2) * sizeof (regoff_t)));
if (regs.start == ((void *)0))
return (int) REG_NOMATCH;
regs.end = regs.start + nmatch;
}
ret = xre_search (&private_preg, string, len,
0, len,
want_reg_info ? ®s : (struct re_registers *) 0);
if (want_reg_info)
{
if (ret >= 0)
{
unsigned r;
for (r = 0; r < nmatch; r++)
{
pmatch[r].rm_so = regs.start[r];
pmatch[r].rm_eo = regs.end[r];
}
}
free (regs.start);
}
return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH;
}
# 8064 "../../libiberty/regex.c"
size_t
xregerror (int errcode, const regex_t *preg __attribute__ ((__unused__)),
char *errbuf, size_t errbuf_size)
{
const char *msg;
size_t msg_size;
if (errcode < 0
|| errcode >= (int) (sizeof (re_error_msgid)
/ sizeof (re_error_msgid[0])))
abort ();
msg = (re_error_msgid[errcode]);
msg_size = strlen (msg) + 1;
if (errbuf_size != 0)
{
if (msg_size > errbuf_size)
{
memcpy (errbuf, msg, errbuf_size - 1);
errbuf[errbuf_size - 1] = 0;
}
else
memcpy (errbuf, msg, msg_size);
}
return msg_size;
}
void
xregfree (regex_t *preg)
{
if (preg->buffer != ((void *)0))
free (preg->buffer);
preg->buffer = ((void *)0);
preg->allocated = 0;
preg->used = 0;
if (preg->fastmap != ((void *)0))
free (preg->fastmap);
preg->fastmap = ((void *)0);
preg->fastmap_accurate = 0;
if (preg->translate != ((void *)0))
free (preg->translate);
preg->translate = ((void *)0);
}
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: Memory leak in ifcvt.c
2008-06-29 0:10 ` Daniel Berlin
@ 2008-06-30 12:47 ` Kenneth Zadeck
2008-06-30 16:13 ` Richard Guenther
0 siblings, 1 reply; 8+ messages in thread
From: Kenneth Zadeck @ 2008-06-30 12:47 UTC (permalink / raw)
To: Daniel Berlin; +Cc: gcc-patches
[-- Attachment #1: Type: text/plain, Size: 2844 bytes --]
These two patches fix 4 storage leaks. Three of them are related to
df. The other I just fixed because dannyb tortured me. They are all
fairly obvious problems once you see the valgrind memory report.
I must say that valgrind --leak-check=full is somewhat frustrating to
use. I do not know what the "full" parameter is supposed to mean.
When you fix a storage leak and retest, valgrind seems to just find more
storage leaks that were unrelated to the ones that it reports. I just
kept fixing ones in parts that I knew about until there were no more
that were obviously mine. This DOES NOT mean that there are not any
more that are mine, it simply means that there are no more that are mine
in the first few that it is willing to report.
Ok for commit?
Kenny
2008-06-30 Kenneth Zadeck <zadeck@naturalbridge.com>
* df-scan.c (df_scan_free_internal): Free data structures not
allocated in storage pools.
* dse.c (dse_step6): Free offset_map_p and offset_map_n
unconditionally.
2008-06-30 Kenneth Zadeck <zadeck@naturalbridge.com>
* ifcvt.c (cond_move_process_if_block): Free vectors on false
return.
Daniel Berlin wrote:
> The way i saw it was with the attached file running valgrind
> --leak-check=full ./cc1 -O2 regex.i
> (It also shows df leaks memory, i sent the trace to stevenb)
>
> I only noticed it while i was debugging something else.
>
> On Sat, Jun 28, 2008 at 7:40 PM, Kenneth Zadeck
> <zadeck@naturalbridge.com> wrote:
>
>> Daniel Berlin wrote:
>>
>>> Kenny, I think you were the one who touched this file last, i could be
>>> wrong.
>>>
>>> Anyway, cond_move_process_if_block leaks allocated vectors (about
>>> 5-10k memory per function compiled).
>>>
>>> WHat happens is this:
>>>
>>> check_cond_move_block pushes things onto a heap allocated vector with
>>> vec_safe_push.
>>>
>>> Sometimes, it decides it can't do a conditional move after pushing
>>> things onto the vector, and returns false.
>>>
>>> Which causes cond_move_process_if to return FALSE here:
>>>
>>> /* Make sure the blocks are suitable. */
>>> if (!check_cond_move_block (then_bb, then_vals, then_regs, cond)
>>> || (else_bb && !check_cond_move_block (else_bb, else_vals,
>>> else_regs, cond)))
>>> return FALSE;
>>>
>>> However, the *only* place that then_regs and else_regs are freed is at
>>> the bottom of cond_move_process_if right before it returns TRUE.
>>>
>>> So when it returns false, it leaks the reg vectors.
>>>
>>> Simple fix is to free them before we return false (note that this also
>>> means you have to split up the conditional above, since the
>>> conditional will leak then_regs if it returns false because of the
>>> second part.
>>>
>>> --Dan
>>>
>>>
>> i will fix this, thanks.
>>
>> is there a particular test case or platform?
>>
>> kenny
>>
>>
[-- Attachment #2: leak1.diff --]
[-- Type: text/x-patch, Size: 4051 bytes --]
Index: df-scan.c
===================================================================
--- df-scan.c (revision 137230)
+++ df-scan.c (working copy)
@@ -174,11 +174,55 @@ struct df_scan_problem_data
typedef struct df_scan_bb_info *df_scan_bb_info_t;
+
+/* Internal function to shut down the scanning problem. */
static void
df_scan_free_internal (void)
{
struct df_scan_problem_data *problem_data
= (struct df_scan_problem_data *) df_scan->problem_data;
+ unsigned int i;
+ basic_block bb;
+
+ /* The vectors that hold the refs are not pool allocated because
+ they come in many sizes. This makes them impossible to delete
+ all at once. */
+ for (i = 0; i < DF_INSN_SIZE(); i++)
+ {
+ struct df_insn_info *insn_info = DF_INSN_UID_GET(i);
+ /* Skip the insns that have no insn_info or have been
+ deleted. */
+ if (insn_info)
+ {
+ struct df_ref **r = insn_info->defs;
+ struct df_mw_hardreg **m = insn_info->mw_hardregs;
+ if (r && *r)
+ free (r);
+ r = insn_info->uses;
+ if (r && *r)
+ free (r);
+ r = insn_info->eq_uses;
+ if (r && *r)
+ free (r);
+ if (m && *m)
+ free (m);
+ }
+ }
+
+ FOR_ALL_BB (bb)
+ {
+ unsigned int bb_index = bb->index;
+ struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb_index);
+ if (bb_info)
+ {
+ struct df_ref **r = bb_info->artificial_defs;
+ if (r && *r)
+ free (r);
+ r = bb_info->artificial_uses;
+ if (r && *r)
+ free (r);
+ }
+ }
free (df->def_info.refs);
free (df->def_info.begin);
@@ -2084,7 +2128,7 @@ df_notes_rescan (rtx insn)
insn_info->mw_hardregs =
xrealloc (insn_info->mw_hardregs,
(count + 1 + collection_rec.next_mw)
- * sizeof (struct df_ref*));
+ * sizeof (struct df_mw_hardreg *));
}
memcpy (&insn_info->mw_hardregs[count], collection_rec.mw_vec,
(collection_rec.next_mw + 1) * sizeof (struct df_mw_hardreg *));
Index: dse.c
===================================================================
--- dse.c (revision 137230)
+++ dse.c (working copy)
@@ -3156,43 +3156,30 @@ dse_step6 (bool global_done)
group_info_t group;
basic_block bb;
- if (global_done)
- {
- for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
- {
- free (group->offset_map_n);
- free (group->offset_map_p);
- BITMAP_FREE (group->store1_n);
- BITMAP_FREE (group->store1_p);
- BITMAP_FREE (group->store2_n);
- BITMAP_FREE (group->store2_p);
- BITMAP_FREE (group->group_kill);
- }
-
- FOR_ALL_BB (bb)
- {
- bb_info_t bb_info = bb_table[bb->index];
- BITMAP_FREE (bb_info->gen);
- if (bb_info->kill)
- BITMAP_FREE (bb_info->kill);
- if (bb_info->in)
- BITMAP_FREE (bb_info->in);
- if (bb_info->out)
- BITMAP_FREE (bb_info->out);
- }
- }
- else
+ for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
{
- for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
- {
- BITMAP_FREE (group->store1_n);
- BITMAP_FREE (group->store1_p);
- BITMAP_FREE (group->store2_n);
- BITMAP_FREE (group->store2_p);
- BITMAP_FREE (group->group_kill);
- }
+ free (group->offset_map_n);
+ free (group->offset_map_p);
+ BITMAP_FREE (group->store1_n);
+ BITMAP_FREE (group->store1_p);
+ BITMAP_FREE (group->store2_n);
+ BITMAP_FREE (group->store2_p);
+ BITMAP_FREE (group->group_kill);
}
+ if (global_done)
+ FOR_ALL_BB (bb)
+ {
+ bb_info_t bb_info = bb_table[bb->index];
+ BITMAP_FREE (bb_info->gen);
+ if (bb_info->kill)
+ BITMAP_FREE (bb_info->kill);
+ if (bb_info->in)
+ BITMAP_FREE (bb_info->in);
+ if (bb_info->out)
+ BITMAP_FREE (bb_info->out);
+ }
+
if (clear_alias_sets)
{
BITMAP_FREE (clear_alias_sets);
@@ -3217,7 +3204,6 @@ dse_step6 (bool global_done)
}
-
/* -------------------------------------------------------------------------
DSE
------------------------------------------------------------------------- */
[-- Attachment #3: ifleak1.diff --]
[-- Type: text/x-patch, Size: 2116 bytes --]
Index: ifcvt.c
===================================================================
--- ifcvt.c (revision 137230)
+++ ifcvt.c (working copy)
@@ -2614,7 +2614,11 @@ cond_move_process_if_block (struct noce_
/* Make sure the blocks are suitable. */
if (!check_cond_move_block (then_bb, then_vals, then_regs, cond)
|| (else_bb && !check_cond_move_block (else_bb, else_vals, else_regs, cond)))
- return FALSE;
+ {
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
+ return FALSE;
+ }
/* Make sure the blocks can be used together. If the same register
is set in both blocks, and is not set to a constant in both
@@ -2635,7 +2639,11 @@ cond_move_process_if_block (struct noce_
if (!CONSTANT_P (then_vals[reg])
&& !CONSTANT_P (else_vals[reg])
&& !rtx_equal_p (then_vals[reg], else_vals[reg]))
- return FALSE;
+ {
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
+ return FALSE;
+ }
}
}
@@ -2649,7 +2657,11 @@ cond_move_process_if_block (struct noce_
branches, since if we convert we are going to always execute
them. */
if (c > MAX_CONDITIONAL_EXECUTE)
- return FALSE;
+ {
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
+ return FALSE;
+ }
/* Try to emit the conditional moves. First do the then block,
then do anything left in the else blocks. */
@@ -2661,11 +2673,17 @@ cond_move_process_if_block (struct noce_
then_vals, else_vals, true)))
{
end_sequence ();
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
return FALSE;
}
seq = end_ifcvt_sequence (if_info);
if (!seq)
- return FALSE;
+ {
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
+ return FALSE;
+ }
loc_insn = first_active_insn (then_bb);
if (!loc_insn)
@@ -2698,7 +2716,6 @@ cond_move_process_if_block (struct noce_
VEC_free (int, heap, then_regs);
VEC_free (int, heap, else_regs);
-
return TRUE;
}
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: Memory leak in ifcvt.c
2008-06-30 12:47 ` Kenneth Zadeck
@ 2008-06-30 16:13 ` Richard Guenther
2008-06-30 20:21 ` Kenneth Zadeck
0 siblings, 1 reply; 8+ messages in thread
From: Richard Guenther @ 2008-06-30 16:13 UTC (permalink / raw)
To: Kenneth Zadeck; +Cc: Daniel Berlin, gcc-patches
On Mon, Jun 30, 2008 at 2:29 PM, Kenneth Zadeck
<zadeck@naturalbridge.com> wrote:
> These two patches fix 4 storage leaks. Three of them are related to df.
> The other I just fixed because dannyb tortured me. They are all fairly
> obvious problems once you see the valgrind memory report.
>
> I must say that valgrind --leak-check=full is somewhat frustrating to use.
> I do not know what the "full" parameter is supposed to mean. When you fix a
> storage leak and retest, valgrind seems to just find more storage leaks that
> were unrelated to the ones that it reports. I just kept fixing ones in
> parts that I knew about until there were no more that were obviously mine.
> This DOES NOT mean that there are not any more that are mine, it simply
> means that there are no more that are mine in the first few that it is
> willing to report.
> Ok for commit?
>
> Kenny
>
>
> 2008-06-30 Kenneth Zadeck <zadeck@naturalbridge.com>
>
> * df-scan.c (df_scan_free_internal): Free data structures not
> allocated in storage pools.
> * dse.c (dse_step6): Free offset_map_p and offset_map_n
> unconditionally.
This is ok if you add a helper-function with comments for the
idiom
+ if (r && *r)
+ free (r);
otherwise that's pretty confusing to me ;)
> 2008-06-30 Kenneth Zadeck <zadeck@naturalbridge.com>
>
> * ifcvt.c (cond_move_process_if_block): Free vectors on false
> return.
This is ok.
Thanks,
Richard.
> Daniel Berlin wrote:
>>
>> The way i saw it was with the attached file running valgrind
>> --leak-check=full ./cc1 -O2 regex.i
>> (It also shows df leaks memory, i sent the trace to stevenb)
>>
>> I only noticed it while i was debugging something else.
>>
>> On Sat, Jun 28, 2008 at 7:40 PM, Kenneth Zadeck
>> <zadeck@naturalbridge.com> wrote:
>>
>>>
>>> Daniel Berlin wrote:
>>>
>>>>
>>>> Kenny, I think you were the one who touched this file last, i could be
>>>> wrong.
>>>>
>>>> Anyway, cond_move_process_if_block leaks allocated vectors (about
>>>> 5-10k memory per function compiled).
>>>>
>>>> WHat happens is this:
>>>>
>>>> check_cond_move_block pushes things onto a heap allocated vector with
>>>> vec_safe_push.
>>>>
>>>> Sometimes, it decides it can't do a conditional move after pushing
>>>> things onto the vector, and returns false.
>>>>
>>>> Which causes cond_move_process_if to return FALSE here:
>>>>
>>>> /* Make sure the blocks are suitable. */
>>>> if (!check_cond_move_block (then_bb, then_vals, then_regs, cond)
>>>> || (else_bb && !check_cond_move_block (else_bb, else_vals,
>>>> else_regs, cond)))
>>>> return FALSE;
>>>>
>>>> However, the *only* place that then_regs and else_regs are freed is at
>>>> the bottom of cond_move_process_if right before it returns TRUE.
>>>>
>>>> So when it returns false, it leaks the reg vectors.
>>>>
>>>> Simple fix is to free them before we return false (note that this also
>>>> means you have to split up the conditional above, since the
>>>> conditional will leak then_regs if it returns false because of the
>>>> second part.
>>>>
>>>> --Dan
>>>>
>>>>
>>>
>>> i will fix this, thanks.
>>>
>>> is there a particular test case or platform?
>>>
>>> kenny
>>>
>>>
>
>
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: Memory leak in ifcvt.c
2008-06-30 16:13 ` Richard Guenther
@ 2008-06-30 20:21 ` Kenneth Zadeck
2008-07-01 9:49 ` Richard Guenther
0 siblings, 1 reply; 8+ messages in thread
From: Kenneth Zadeck @ 2008-06-30 20:21 UTC (permalink / raw)
To: Richard Guenther; +Cc: Daniel Berlin, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 4083 bytes --]
Updated as richard has requested.
2008-06-30 Kenneth Zadeck <zadeck@naturalbridge.com>
* df-scan.c (df_scan_free_ref_vec, df_scan_free_mws_vec): New
macros.
(df_scan_free_internal): Free data structures not
allocated in storage pools.
(df_mw_hardreg_chain_delete_eq_uses): Use df_scan_free_mws_vec.
(df_refs_add_to_chains): Use df_scan_free_ref_vec and
df_scan_free_mws_vec.
* dse.c (dse_step6): Free offset_map_p and offset_map_n
unconditionally.
2008-06-30 Kenneth Zadeck <zadeck@naturalbridge.com>
* ifcvt.c (cond_move_process_if_block): Free vectors on false
return.
Committed as revisions 137284 and 137285.
Kenny
Richard Guenther wrote:
> On Mon, Jun 30, 2008 at 2:29 PM, Kenneth Zadeck
> <zadeck@naturalbridge.com> wrote:
>
>> These two patches fix 4 storage leaks. Three of them are related to df.
>> The other I just fixed because dannyb tortured me. They are all fairly
>> obvious problems once you see the valgrind memory report.
>>
>> I must say that valgrind --leak-check=full is somewhat frustrating to use.
>> I do not know what the "full" parameter is supposed to mean. When you fix a
>> storage leak and retest, valgrind seems to just find more storage leaks that
>> were unrelated to the ones that it reports. I just kept fixing ones in
>> parts that I knew about until there were no more that were obviously mine.
>> This DOES NOT mean that there are not any more that are mine, it simply
>> means that there are no more that are mine in the first few that it is
>> willing to report.
>> Ok for commit?
>>
>> Kenny
>>
>>
>> 2008-06-30 Kenneth Zadeck <zadeck@naturalbridge.com>
>>
>> * df-scan.c (df_scan_free_internal): Free data structures not
>> allocated in storage pools.
>> * dse.c (dse_step6): Free offset_map_p and offset_map_n
>> unconditionally.
>>
>
> This is ok if you add a helper-function with comments for the
> idiom
>
> + if (r && *r)
> + free (r);
>
> otherwise that's pretty confusing to me ;)
>
>
>> 2008-06-30 Kenneth Zadeck <zadeck@naturalbridge.com>
>>
>> * ifcvt.c (cond_move_process_if_block): Free vectors on false
>> return.
>>
>
> This is ok.
>
> Thanks,
> Richard.
>
>
>> Daniel Berlin wrote:
>>
>>> The way i saw it was with the attached file running valgrind
>>> --leak-check=full ./cc1 -O2 regex.i
>>> (It also shows df leaks memory, i sent the trace to stevenb)
>>>
>>> I only noticed it while i was debugging something else.
>>>
>>> On Sat, Jun 28, 2008 at 7:40 PM, Kenneth Zadeck
>>> <zadeck@naturalbridge.com> wrote:
>>>
>>>
>>>> Daniel Berlin wrote:
>>>>
>>>>
>>>>> Kenny, I think you were the one who touched this file last, i could be
>>>>> wrong.
>>>>>
>>>>> Anyway, cond_move_process_if_block leaks allocated vectors (about
>>>>> 5-10k memory per function compiled).
>>>>>
>>>>> WHat happens is this:
>>>>>
>>>>> check_cond_move_block pushes things onto a heap allocated vector with
>>>>> vec_safe_push.
>>>>>
>>>>> Sometimes, it decides it can't do a conditional move after pushing
>>>>> things onto the vector, and returns false.
>>>>>
>>>>> Which causes cond_move_process_if to return FALSE here:
>>>>>
>>>>> /* Make sure the blocks are suitable. */
>>>>> if (!check_cond_move_block (then_bb, then_vals, then_regs, cond)
>>>>> || (else_bb && !check_cond_move_block (else_bb, else_vals,
>>>>> else_regs, cond)))
>>>>> return FALSE;
>>>>>
>>>>> However, the *only* place that then_regs and else_regs are freed is at
>>>>> the bottom of cond_move_process_if right before it returns TRUE.
>>>>>
>>>>> So when it returns false, it leaks the reg vectors.
>>>>>
>>>>> Simple fix is to free them before we return false (note that this also
>>>>> means you have to split up the conditional above, since the
>>>>> conditional will leak then_regs if it returns false because of the
>>>>> second part.
>>>>>
>>>>> --Dan
>>>>>
>>>>>
>>>>>
>>>> i will fix this, thanks.
>>>>
>>>> is there a particular test case or platform?
>>>>
>>>> kenny
>>>>
>>>>
>>>>
>>
[-- Attachment #2: leak1.diff --]
[-- Type: text/x-patch, Size: 6534 bytes --]
Index: df-scan.c
===================================================================
--- df-scan.c (revision 137283)
+++ df-scan.c (working copy)
@@ -60,6 +60,21 @@ along with GCC; see the file COPYING3.
#define EPILOGUE_USES(REGNO) 0
#endif
+/* The following two macros free the vecs that hold either the refs or
+ the mw refs. They are a little tricky because the vec has 0
+ elements is special and is not to be freed. */
+#define df_scan_free_ref_vec(V) \
+ do { \
+ if (V && *V) \
+ free (V); \
+ } while (0)
+
+#define df_scan_free_mws_vec(V) \
+ do { \
+ if (V && *V) \
+ free (V); \
+ } while (0)
+
/* The bitmap_obstack is used to hold some static variables that
should not be reset after each function is compiled. */
@@ -174,11 +189,43 @@ struct df_scan_problem_data
typedef struct df_scan_bb_info *df_scan_bb_info_t;
+
+/* Internal function to shut down the scanning problem. */
static void
df_scan_free_internal (void)
{
struct df_scan_problem_data *problem_data
= (struct df_scan_problem_data *) df_scan->problem_data;
+ unsigned int i;
+ basic_block bb;
+
+ /* The vectors that hold the refs are not pool allocated because
+ they come in many sizes. This makes them impossible to delete
+ all at once. */
+ for (i = 0; i < DF_INSN_SIZE(); i++)
+ {
+ struct df_insn_info *insn_info = DF_INSN_UID_GET(i);
+ /* Skip the insns that have no insn_info or have been
+ deleted. */
+ if (insn_info)
+ {
+ df_scan_free_ref_vec (insn_info->defs);
+ df_scan_free_ref_vec (insn_info->uses);
+ df_scan_free_ref_vec (insn_info->eq_uses);
+ df_scan_free_mws_vec (insn_info->mw_hardregs);
+ }
+ }
+
+ FOR_ALL_BB (bb)
+ {
+ unsigned int bb_index = bb->index;
+ struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb_index);
+ if (bb_info)
+ {
+ df_scan_free_ref_vec (bb_info->artificial_defs);
+ df_scan_free_ref_vec (bb_info->artificial_uses);
+ }
+ }
free (df->def_info.refs);
free (df->def_info.begin);
@@ -1977,7 +2024,7 @@ df_mw_hardreg_chain_delete_eq_uses (stru
if (count == 0)
{
- free (insn_info->mw_hardregs);
+ df_scan_free_mws_vec (insn_info->mw_hardregs);
insn_info->mw_hardregs = df_null_mw_rec;
return 0;
}
@@ -2515,8 +2562,7 @@ df_refs_add_to_chains (struct df_collect
chain specially. */
if (collection_rec->def_vec)
{
- if (insn_rec->defs && *insn_rec->defs)
- free (insn_rec->defs);
+ df_scan_free_ref_vec (insn_rec->defs);
insn_rec->defs
= df_install_refs (bb, collection_rec->def_vec,
collection_rec->next_def,
@@ -2525,8 +2571,7 @@ df_refs_add_to_chains (struct df_collect
}
if (collection_rec->use_vec)
{
- if (insn_rec->uses && *insn_rec->uses)
- free (insn_rec->uses);
+ df_scan_free_ref_vec (insn_rec->uses);
insn_rec->uses
= df_install_refs (bb, collection_rec->use_vec,
collection_rec->next_use,
@@ -2535,8 +2580,7 @@ df_refs_add_to_chains (struct df_collect
}
if (collection_rec->eq_use_vec)
{
- if (insn_rec->eq_uses && *insn_rec->eq_uses)
- free (insn_rec->eq_uses);
+ df_scan_free_ref_vec (insn_rec->eq_uses);
insn_rec->eq_uses
= df_install_refs (bb, collection_rec->eq_use_vec,
collection_rec->next_eq_use,
@@ -2545,8 +2589,7 @@ df_refs_add_to_chains (struct df_collect
}
if (collection_rec->mw_vec)
{
- if (insn_rec->mw_hardregs && *insn_rec->mw_hardregs)
- free (insn_rec->mw_hardregs);
+ df_scan_free_mws_vec (insn_rec->mw_hardregs);
insn_rec->mw_hardregs
= df_install_mws (collection_rec->mw_vec,
collection_rec->next_mw);
@@ -2556,15 +2599,13 @@ df_refs_add_to_chains (struct df_collect
{
struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb->index);
- if (bb_info->artificial_defs && *bb_info->artificial_defs)
- free (bb_info->artificial_defs);
+ df_scan_free_ref_vec (bb_info->artificial_defs);
bb_info->artificial_defs
= df_install_refs (bb, collection_rec->def_vec,
collection_rec->next_def,
df->def_regs,
&df->def_info, false);
- if (bb_info->artificial_uses && *bb_info->artificial_uses)
- free (bb_info->artificial_uses);
+ df_scan_free_ref_vec (bb_info->artificial_uses);
bb_info->artificial_uses
= df_install_refs (bb, collection_rec->use_vec,
collection_rec->next_use,
Index: dse.c
===================================================================
--- dse.c (revision 137283)
+++ dse.c (working copy)
@@ -3156,43 +3156,30 @@ dse_step6 (bool global_done)
group_info_t group;
basic_block bb;
- if (global_done)
- {
- for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
- {
- free (group->offset_map_n);
- free (group->offset_map_p);
- BITMAP_FREE (group->store1_n);
- BITMAP_FREE (group->store1_p);
- BITMAP_FREE (group->store2_n);
- BITMAP_FREE (group->store2_p);
- BITMAP_FREE (group->group_kill);
- }
-
- FOR_ALL_BB (bb)
- {
- bb_info_t bb_info = bb_table[bb->index];
- BITMAP_FREE (bb_info->gen);
- if (bb_info->kill)
- BITMAP_FREE (bb_info->kill);
- if (bb_info->in)
- BITMAP_FREE (bb_info->in);
- if (bb_info->out)
- BITMAP_FREE (bb_info->out);
- }
- }
- else
+ for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
{
- for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
- {
- BITMAP_FREE (group->store1_n);
- BITMAP_FREE (group->store1_p);
- BITMAP_FREE (group->store2_n);
- BITMAP_FREE (group->store2_p);
- BITMAP_FREE (group->group_kill);
- }
+ free (group->offset_map_n);
+ free (group->offset_map_p);
+ BITMAP_FREE (group->store1_n);
+ BITMAP_FREE (group->store1_p);
+ BITMAP_FREE (group->store2_n);
+ BITMAP_FREE (group->store2_p);
+ BITMAP_FREE (group->group_kill);
}
+ if (global_done)
+ FOR_ALL_BB (bb)
+ {
+ bb_info_t bb_info = bb_table[bb->index];
+ BITMAP_FREE (bb_info->gen);
+ if (bb_info->kill)
+ BITMAP_FREE (bb_info->kill);
+ if (bb_info->in)
+ BITMAP_FREE (bb_info->in);
+ if (bb_info->out)
+ BITMAP_FREE (bb_info->out);
+ }
+
if (clear_alias_sets)
{
BITMAP_FREE (clear_alias_sets);
@@ -3217,7 +3204,6 @@ dse_step6 (bool global_done)
}
-
/* -------------------------------------------------------------------------
DSE
------------------------------------------------------------------------- */
[-- Attachment #3: ifleak2.diff --]
[-- Type: text/x-patch, Size: 2116 bytes --]
Index: ifcvt.c
===================================================================
--- ifcvt.c (revision 137272)
+++ ifcvt.c (working copy)
@@ -2614,7 +2614,11 @@ cond_move_process_if_block (struct noce_
/* Make sure the blocks are suitable. */
if (!check_cond_move_block (then_bb, then_vals, then_regs, cond)
|| (else_bb && !check_cond_move_block (else_bb, else_vals, else_regs, cond)))
- return FALSE;
+ {
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
+ return FALSE;
+ }
/* Make sure the blocks can be used together. If the same register
is set in both blocks, and is not set to a constant in both
@@ -2635,7 +2639,11 @@ cond_move_process_if_block (struct noce_
if (!CONSTANT_P (then_vals[reg])
&& !CONSTANT_P (else_vals[reg])
&& !rtx_equal_p (then_vals[reg], else_vals[reg]))
- return FALSE;
+ {
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
+ return FALSE;
+ }
}
}
@@ -2649,7 +2657,11 @@ cond_move_process_if_block (struct noce_
branches, since if we convert we are going to always execute
them. */
if (c > MAX_CONDITIONAL_EXECUTE)
- return FALSE;
+ {
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
+ return FALSE;
+ }
/* Try to emit the conditional moves. First do the then block,
then do anything left in the else blocks. */
@@ -2661,11 +2673,17 @@ cond_move_process_if_block (struct noce_
then_vals, else_vals, true)))
{
end_sequence ();
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
return FALSE;
}
seq = end_ifcvt_sequence (if_info);
if (!seq)
- return FALSE;
+ {
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
+ return FALSE;
+ }
loc_insn = first_active_insn (then_bb);
if (!loc_insn)
@@ -2698,7 +2716,6 @@ cond_move_process_if_block (struct noce_
VEC_free (int, heap, then_regs);
VEC_free (int, heap, else_regs);
-
return TRUE;
}
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: Memory leak in ifcvt.c
2008-06-30 20:21 ` Kenneth Zadeck
@ 2008-07-01 9:49 ` Richard Guenther
2008-07-01 15:32 ` [4.3 branch] " Kenneth Zadeck
0 siblings, 1 reply; 8+ messages in thread
From: Richard Guenther @ 2008-07-01 9:49 UTC (permalink / raw)
To: Kenneth Zadeck; +Cc: Daniel Berlin, gcc-patches
On Mon, Jun 30, 2008 at 9:33 PM, Kenneth Zadeck
<zadeck@naturalbridge.com> wrote:
> Updated as richard has requested.
>
> 2008-06-30 Kenneth Zadeck <zadeck@naturalbridge.com>
>
> * df-scan.c (df_scan_free_ref_vec, df_scan_free_mws_vec): New
> macros.
> (df_scan_free_internal): Free data structures not
> allocated in storage pools.
> (df_mw_hardreg_chain_delete_eq_uses): Use df_scan_free_mws_vec.
> (df_refs_add_to_chains): Use df_scan_free_ref_vec and
> df_scan_free_mws_vec.
> * dse.c (dse_step6): Free offset_map_p and offset_map_n
> unconditionally.
>
> 2008-06-30 Kenneth Zadeck <zadeck@naturalbridge.com>
>
> * ifcvt.c (cond_move_process_if_block): Free vectors on false
> return.
>
> Committed as revisions 137284 and 137285.
Thanks. This seems to have a very positive effect on some testcases,
can you back-port these fixes to the 4.3 branch if applicable?
Thanks,
Richard.
^ permalink raw reply [flat|nested] 8+ messages in thread
* [4.3 branch] Re: Memory leak in ifcvt.c
2008-07-01 9:49 ` Richard Guenther
@ 2008-07-01 15:32 ` Kenneth Zadeck
0 siblings, 0 replies; 8+ messages in thread
From: Kenneth Zadeck @ 2008-07-01 15:32 UTC (permalink / raw)
To: Richard Guenther; +Cc: Daniel Berlin, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 1636 bytes --]
Richard Guenther wrote:
> On Mon, Jun 30, 2008 at 9:33 PM, Kenneth Zadeck
> <zadeck@naturalbridge.com> wrote:
>
>> Updated as richard has requested.
>>
>> 2008-06-30 Kenneth Zadeck <zadeck@naturalbridge.com>
>>
>> * df-scan.c (df_scan_free_ref_vec, df_scan_free_mws_vec): New
>> macros.
>> (df_scan_free_internal): Free data structures not
>> allocated in storage pools.
>> (df_mw_hardreg_chain_delete_eq_uses): Use df_scan_free_mws_vec.
>> (df_refs_add_to_chains): Use df_scan_free_ref_vec and
>> df_scan_free_mws_vec.
>> * dse.c (dse_step6): Free offset_map_p and offset_map_n
>> unconditionally.
>>
>> 2008-06-30 Kenneth Zadeck <zadeck@naturalbridge.com>
>>
>> * ifcvt.c (cond_move_process_if_block): Free vectors on false
>> return.
>>
>> Committed as revisions 137284 and 137285.
>>
>
> Thanks. This seems to have a very positive effect on some testcases,
> can you back-port these fixes to the 4.3 branch if applicable?
>
> Thanks,
> Richard.
>
committed as revision 137319 to 4.3 branch after bootstrapping.
kenny
2008-07-01 Kenneth Zadeck <zadeck@naturalbridge.com>
PR rtl-optimization/34744
* df-scan.c (df_scan_free_ref_vec, df_scan_free_mws_vec): New
macros.
(df_scan_free_internal): Free data structures not
allocated in storage pools.
(df_mw_hardreg_chain_delete_eq_uses): Use df_scan_free_mws_vec.
(df_refs_add_to_chains): Use df_scan_free_ref_vec and
df_scan_free_mws_vec.
* dse.c (dse_step6): Free offset_map_p and offset_map_n
unconditionally.
* ifcvt.c (cond_move_process_if_block): Free vectors on false
return.
[-- Attachment #2: leak.diff --]
[-- Type: text/x-patch, Size: 8686 bytes --]
Index: gcc/df-scan.c
===================================================================
--- gcc/df-scan.c (revision 137316)
+++ gcc/df-scan.c (working copy)
@@ -60,6 +60,21 @@ along with GCC; see the file COPYING3.
#define EPILOGUE_USES(REGNO) 0
#endif
+/* The following two macros free the vecs that hold either the refs or
+ the mw refs. They are a little tricky because the vec has 0
+ elements is special and is not to be freed. */
+#define df_scan_free_ref_vec(V) \
+ do { \
+ if (V && *V) \
+ free (V); \
+ } while (0)
+
+#define df_scan_free_mws_vec(V) \
+ do { \
+ if (V && *V) \
+ free (V); \
+ } while (0)
+
/* The bitmap_obstack is used to hold some static variables that
should not be reset after each function is compiled. */
@@ -170,11 +185,43 @@ struct df_scan_problem_data
typedef struct df_scan_bb_info *df_scan_bb_info_t;
+
+/* Internal function to shut down the scanning problem. */
static void
df_scan_free_internal (void)
{
struct df_scan_problem_data *problem_data
= (struct df_scan_problem_data *) df_scan->problem_data;
+ unsigned int i;
+ basic_block bb;
+
+ /* The vectors that hold the refs are not pool allocated because
+ they come in many sizes. This makes them impossible to delete
+ all at once. */
+ for (i = 0; i < DF_INSN_SIZE(); i++)
+ {
+ struct df_insn_info *insn_info = DF_INSN_UID_GET(i);
+ /* Skip the insns that have no insn_info or have been
+ deleted. */
+ if (insn_info)
+ {
+ df_scan_free_ref_vec (insn_info->defs);
+ df_scan_free_ref_vec (insn_info->uses);
+ df_scan_free_ref_vec (insn_info->eq_uses);
+ df_scan_free_mws_vec (insn_info->mw_hardregs);
+ }
+ }
+
+ FOR_ALL_BB (bb)
+ {
+ unsigned int bb_index = bb->index;
+ struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb_index);
+ if (bb_info)
+ {
+ df_scan_free_ref_vec (bb_info->artificial_defs);
+ df_scan_free_ref_vec (bb_info->artificial_uses);
+ }
+ }
free (df->def_info.refs);
free (df->def_info.begin);
@@ -1981,7 +2028,7 @@ df_mw_hardreg_chain_delete_eq_uses (stru
if (count == 0)
{
- free (insn_info->mw_hardregs);
+ df_scan_free_mws_vec (insn_info->mw_hardregs);
insn_info->mw_hardregs = df_null_mw_rec;
return 0;
}
@@ -2498,8 +2545,7 @@ df_refs_add_to_chains (struct df_collect
chain specially. */
if (collection_rec->def_vec)
{
- if (insn_rec->defs && *insn_rec->defs)
- free (insn_rec->defs);
+ df_scan_free_ref_vec (insn_rec->defs);
insn_rec->defs
= df_install_refs (bb, collection_rec->def_vec,
collection_rec->next_def,
@@ -2508,8 +2554,7 @@ df_refs_add_to_chains (struct df_collect
}
if (collection_rec->use_vec)
{
- if (insn_rec->uses && *insn_rec->uses)
- free (insn_rec->uses);
+ df_scan_free_ref_vec (insn_rec->uses);
insn_rec->uses
= df_install_refs (bb, collection_rec->use_vec,
collection_rec->next_use,
@@ -2518,8 +2563,7 @@ df_refs_add_to_chains (struct df_collect
}
if (collection_rec->eq_use_vec)
{
- if (insn_rec->eq_uses && *insn_rec->eq_uses)
- free (insn_rec->eq_uses);
+ df_scan_free_ref_vec (insn_rec->eq_uses);
insn_rec->eq_uses
= df_install_refs (bb, collection_rec->eq_use_vec,
collection_rec->next_eq_use,
@@ -2528,8 +2572,7 @@ df_refs_add_to_chains (struct df_collect
}
if (collection_rec->mw_vec)
{
- if (insn_rec->mw_hardregs && *insn_rec->mw_hardregs)
- free (insn_rec->mw_hardregs);
+ df_scan_free_mws_vec (insn_rec->mw_hardregs);
insn_rec->mw_hardregs
= df_install_mws (collection_rec->mw_vec,
collection_rec->next_mw);
@@ -2539,15 +2582,13 @@ df_refs_add_to_chains (struct df_collect
{
struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb->index);
- if (bb_info->artificial_defs && *bb_info->artificial_defs)
- free (bb_info->artificial_defs);
+ df_scan_free_ref_vec (bb_info->artificial_defs);
bb_info->artificial_defs
= df_install_refs (bb, collection_rec->def_vec,
collection_rec->next_def,
df->def_regs,
&df->def_info, false);
- if (bb_info->artificial_uses && *bb_info->artificial_uses)
- free (bb_info->artificial_uses);
+ df_scan_free_ref_vec (bb_info->artificial_uses);
bb_info->artificial_uses
= df_install_refs (bb, collection_rec->use_vec,
collection_rec->next_use,
Index: gcc/ifcvt.c
===================================================================
--- gcc/ifcvt.c (revision 137316)
+++ gcc/ifcvt.c (working copy)
@@ -2606,7 +2606,11 @@ cond_move_process_if_block (struct noce_
/* Make sure the blocks are suitable. */
if (!check_cond_move_block (then_bb, then_vals, then_regs, cond)
|| (else_bb && !check_cond_move_block (else_bb, else_vals, else_regs, cond)))
- return FALSE;
+ {
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
+ return FALSE;
+ }
/* Make sure the blocks can be used together. If the same register
is set in both blocks, and is not set to a constant in both
@@ -2627,7 +2631,11 @@ cond_move_process_if_block (struct noce_
if (!CONSTANT_P (then_vals[reg])
&& !CONSTANT_P (else_vals[reg])
&& !rtx_equal_p (then_vals[reg], else_vals[reg]))
- return FALSE;
+ {
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
+ return FALSE;
+ }
}
}
@@ -2641,7 +2649,11 @@ cond_move_process_if_block (struct noce_
branches, since if we convert we are going to always execute
them. */
if (c > MAX_CONDITIONAL_EXECUTE)
- return FALSE;
+ {
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
+ return FALSE;
+ }
/* Try to emit the conditional moves. First do the then block,
then do anything left in the else blocks. */
@@ -2653,11 +2665,17 @@ cond_move_process_if_block (struct noce_
then_vals, else_vals, true)))
{
end_sequence ();
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
return FALSE;
}
seq = end_ifcvt_sequence (if_info);
if (!seq)
- return FALSE;
+ {
+ VEC_free (int, heap, then_regs);
+ VEC_free (int, heap, else_regs);
+ return FALSE;
+ }
loc_insn = first_active_insn (then_bb);
if (!loc_insn)
@@ -2690,7 +2708,6 @@ cond_move_process_if_block (struct noce_
VEC_free (int, heap, then_regs);
VEC_free (int, heap, else_regs);
-
return TRUE;
}
Index: gcc/dse.c
===================================================================
--- gcc/dse.c (revision 137316)
+++ gcc/dse.c (working copy)
@@ -3163,43 +3163,30 @@ dse_step6 (bool global_done)
group_info_t group;
basic_block bb;
- if (global_done)
- {
- for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
- {
- free (group->offset_map_n);
- free (group->offset_map_p);
- BITMAP_FREE (group->store1_n);
- BITMAP_FREE (group->store1_p);
- BITMAP_FREE (group->store2_n);
- BITMAP_FREE (group->store2_p);
- BITMAP_FREE (group->group_kill);
- }
-
- FOR_ALL_BB (bb)
- {
- bb_info_t bb_info = bb_table[bb->index];
- BITMAP_FREE (bb_info->gen);
- if (bb_info->kill)
- BITMAP_FREE (bb_info->kill);
- if (bb_info->in)
- BITMAP_FREE (bb_info->in);
- if (bb_info->out)
- BITMAP_FREE (bb_info->out);
- }
- }
- else
+ for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
{
- for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
- {
- BITMAP_FREE (group->store1_n);
- BITMAP_FREE (group->store1_p);
- BITMAP_FREE (group->store2_n);
- BITMAP_FREE (group->store2_p);
- BITMAP_FREE (group->group_kill);
- }
+ free (group->offset_map_n);
+ free (group->offset_map_p);
+ BITMAP_FREE (group->store1_n);
+ BITMAP_FREE (group->store1_p);
+ BITMAP_FREE (group->store2_n);
+ BITMAP_FREE (group->store2_p);
+ BITMAP_FREE (group->group_kill);
}
+ if (global_done)
+ FOR_ALL_BB (bb)
+ {
+ bb_info_t bb_info = bb_table[bb->index];
+ BITMAP_FREE (bb_info->gen);
+ if (bb_info->kill)
+ BITMAP_FREE (bb_info->kill);
+ if (bb_info->in)
+ BITMAP_FREE (bb_info->in);
+ if (bb_info->out)
+ BITMAP_FREE (bb_info->out);
+ }
+
if (clear_alias_sets)
{
BITMAP_FREE (clear_alias_sets);
@@ -3224,7 +3211,6 @@ dse_step6 (bool global_done)
}
-
/* -------------------------------------------------------------------------
DSE
------------------------------------------------------------------------- */
^ permalink raw reply [flat|nested] 8+ messages in thread
end of thread, other threads:[~2008-07-01 14:08 UTC | newest]
Thread overview: 8+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2008-06-28 22:16 Memory leak in ifcvt.c Daniel Berlin
2008-06-28 23:52 ` Kenneth Zadeck
2008-06-29 0:10 ` Daniel Berlin
2008-06-30 12:47 ` Kenneth Zadeck
2008-06-30 16:13 ` Richard Guenther
2008-06-30 20:21 ` Kenneth Zadeck
2008-07-01 9:49 ` Richard Guenther
2008-07-01 15:32 ` [4.3 branch] " Kenneth Zadeck
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).