Attachment 934142 Details for Bug 1136939 – method-to-ir.i

method-to-ir.i

method-to-ir.i (text/plain), 1.90 MB, created by Michal Toman on 2014-09-03 15:57:19 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Michal Toman

Created: 2014-09-03 15:57:19 UTC

Size: 1.90 MB

patch

obsolete

># 1 "method-to-ir.c"
># 1 "/home/mtoman/rpmbuild/BUILD/mono-2.10.8/mono/mini//"
># 1 "<built-in>"
># 1 "<command-line>"
># 1 "/usr/include/stdc-predef.h" 1 3 4
># 1 "<command-line>" 2
># 1 "method-to-ir.c"
># 13 "method-to-ir.c"
># 1 "../../config.h" 1
># 14 "method-to-ir.c" 2
># 1 "/usr/include/signal.h" 1 3 4
># 28 "/usr/include/signal.h" 3 4
># 1 "/usr/include/features.h" 1 3 4
># 365 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 393 "/usr/include/sys/cdefs.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 394 "/usr/include/sys/cdefs.h" 2 3 4
># 366 "/usr/include/features.h" 2 3 4
># 389 "/usr/include/features.h" 3 4
># 1 "/usr/include/gnu/stubs.h" 1 3 4
>
>
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 6 "/usr/include/gnu/stubs.h" 2 3 4
>
>
>
>
>
># 1 "/usr/include/gnu/stubs-64.h" 1 3 4
># 12 "/usr/include/gnu/stubs.h" 2 3 4
># 390 "/usr/include/features.h" 2 3 4
># 29 "/usr/include/signal.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 22 "/usr/include/bits/sigset.h" 3 4
>typedef int __sig_atomic_t;
>
>
>
>
>typedef struct
>  {
>    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
>  } __sigset_t;
># 102 "/usr/include/bits/sigset.h" 3 4
>extern int __sigismember (const __sigset_t *, int);
>extern int __sigaddset (__sigset_t *, int);
>extern int __sigdelset (__sigset_t *, int);
># 116 "/usr/include/bits/sigset.h" 3 4
>extern __inline int __sigismember (const __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return (__set->__val[__word] & __mask) ? 1 : 0; }
>extern __inline int __sigaddset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] |= __mask), 0); }
>extern __inline int __sigdelset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] &= ~__mask), 0); }
># 33 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>
>typedef __sig_atomic_t sig_atomic_t;
>
>
>
>
>
>
>
>
>typedef __sigset_t sigset_t;
>
>
>
>
>
>
># 1 "/usr/include/bits/types.h" 1 3 4
># 27 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 28 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned char __u_char;
>typedef unsigned short int __u_short;
>typedef unsigned int __u_int;
>typedef unsigned long int __u_long;
>
>
>typedef signed char __int8_t;
>typedef unsigned char __uint8_t;
>typedef signed short int __int16_t;
>typedef unsigned short int __uint16_t;
>typedef signed int __int32_t;
>typedef unsigned int __uint32_t;
>
>typedef signed long int __int64_t;
>typedef unsigned long int __uint64_t;
>
>
>
>
>
>
>
>typedef long int __quad_t;
>typedef unsigned long int __u_quad_t;
># 121 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 122 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned long int __dev_t;
>typedef unsigned int __uid_t;
>typedef unsigned int __gid_t;
>typedef unsigned long int __ino_t;
>typedef unsigned long int __ino64_t;
>typedef unsigned int __mode_t;
>typedef unsigned long int __nlink_t;
>typedef long int __off_t;
>typedef long int __off64_t;
>typedef int __pid_t;
>typedef struct { int __val[2]; } __fsid_t;
>typedef long int __clock_t;
>typedef unsigned long int __rlim_t;
>typedef unsigned long int __rlim64_t;
>typedef unsigned int __id_t;
>typedef long int __time_t;
>typedef unsigned int __useconds_t;
>typedef long int __suseconds_t;
>
>typedef int __daddr_t;
>typedef int __key_t;
>
>
>typedef int __clockid_t;
>
>
>typedef void * __timer_t;
>
>
>typedef long int __blksize_t;
>
>
>
>
>typedef long int __blkcnt_t;
>typedef long int __blkcnt64_t;
>
>
>typedef unsigned long int __fsblkcnt_t;
>typedef unsigned long int __fsblkcnt64_t;
>
>
>typedef unsigned long int __fsfilcnt_t;
>typedef unsigned long int __fsfilcnt64_t;
>
>
>typedef long int __fsword_t;
>
>typedef long int __ssize_t;
>
>
>typedef long int __syscall_slong_t;
>
>typedef unsigned long int __syscall_ulong_t;
>
>
>
>typedef __off64_t __loff_t;
>typedef __quad_t *__qaddr_t;
>typedef char *__caddr_t;
>
>
>typedef long int __intptr_t;
>
>
>typedef unsigned int __socklen_t;
># 57 "/usr/include/signal.h" 2 3 4
># 1 "/usr/include/bits/signum.h" 1 3 4
># 58 "/usr/include/signal.h" 2 3 4
>
>
>
>typedef __pid_t pid_t;
>
>
>
>
>
>typedef __uid_t uid_t;
>
>
>
>
>
>
>
># 1 "/usr/include/time.h" 1 3 4
># 120 "/usr/include/time.h" 3 4
>struct timespec
>  {
>    __time_t tv_sec;
>    __syscall_slong_t tv_nsec;
>  };
># 76 "/usr/include/signal.h" 2 3 4
>
>
>
>
># 1 "/usr/include/bits/siginfo.h" 1 3 4
># 24 "/usr/include/bits/siginfo.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/siginfo.h" 2 3 4
>
>
>
>
>
>
>
>typedef union sigval
>  {
>    int sival_int;
>    void *sival_ptr;
>  } sigval_t;
># 50 "/usr/include/bits/siginfo.h" 3 4
>typedef struct
>  {
>    int si_signo;
>    int si_errno;
>
>    int si_code;
>
>    union
>      {
> int _pad[((128 / sizeof (int)) - 4)];
>
>
> struct
>   {
>     __pid_t si_pid;
>     __uid_t si_uid;
>   } _kill;
>
>
> struct
>   {
>     int si_tid;
>     int si_overrun;
>     sigval_t si_sigval;
>   } _timer;
>
>
> struct
>   {
>     __pid_t si_pid;
>     __uid_t si_uid;
>     sigval_t si_sigval;
>   } _rt;
>
>
> struct
>   {
>     __pid_t si_pid;
>     __uid_t si_uid;
>     int si_status;
>     __clock_t si_utime;
>     __clock_t si_stime;
>   } _sigchld;
>
>
> struct
>   {
>     void *si_addr;
>     short si_addr_lsb;
>   } _sigfault;
>
>
> struct
>   {
>     long int si_band;
>     int si_fd;
>   } _sigpoll;
>
>
> struct
>   {
>     void *_call_addr;
>     int _syscall;
>     unsigned int _arch;
>   } _sigsys;
>      } _sifields;
>  } siginfo_t;
># 141 "/usr/include/bits/siginfo.h" 3 4
>enum
>{
>  SI_ASYNCNL = -60,
>
>  SI_TKILL = -6,
>
>  SI_SIGIO,
>
>  SI_ASYNCIO,
>
>  SI_MESGQ,
>
>  SI_TIMER,
>
>  SI_QUEUE,
>
>  SI_USER,
>
>  SI_KERNEL = 0x80
>
>};
>
>
>
>
>enum
>{
>  ILL_ILLOPC = 1,
>
>  ILL_ILLOPN,
>
>  ILL_ILLADR,
>
>  ILL_ILLTRP,
>
>  ILL_PRVOPC,
>
>  ILL_PRVREG,
>
>  ILL_COPROC,
>
>  ILL_BADSTK
>
>};
>
>
>enum
>{
>  FPE_INTDIV = 1,
>
>  FPE_INTOVF,
>
>  FPE_FLTDIV,
>
>  FPE_FLTOVF,
>
>  FPE_FLTUND,
>
>  FPE_FLTRES,
>
>  FPE_FLTINV,
>
>  FPE_FLTSUB
>
>};
>
>
>enum
>{
>  SEGV_MAPERR = 1,
>
>  SEGV_ACCERR
>
>};
>
>
>enum
>{
>  BUS_ADRALN = 1,
>
>  BUS_ADRERR,
>
>  BUS_OBJERR,
>
>  BUS_MCEERR_AR,
>
>  BUS_MCEERR_AO
>
>};
>
>
>
>
>enum
>{
>  TRAP_BRKPT = 1,
>
>  TRAP_TRACE
>
>};
>
>
>
>
>enum
>{
>  CLD_EXITED = 1,
>
>  CLD_KILLED,
>
>  CLD_DUMPED,
>
>  CLD_TRAPPED,
>
>  CLD_STOPPED,
>
>  CLD_CONTINUED
>
>};
>
>
>enum
>{
>  POLL_IN = 1,
>
>  POLL_OUT,
>
>  POLL_MSG,
>
>  POLL_ERR,
>
>  POLL_PRI,
>
>  POLL_HUP
>
>};
># 297 "/usr/include/bits/siginfo.h" 3 4
>typedef union pthread_attr_t pthread_attr_t;
>
>
>
>typedef struct sigevent
>  {
>    sigval_t sigev_value;
>    int sigev_signo;
>    int sigev_notify;
>
>    union
>      {
> int _pad[((64 / sizeof (int)) - 4)];
>
>
>
> __pid_t _tid;
>
> struct
>   {
>     void (*_function) (sigval_t);
>     pthread_attr_t *_attribute;
>   } _sigev_thread;
>      } _sigev_un;
>  } sigevent_t;
>
>
>
>
>
>
>enum
>{
>  SIGEV_SIGNAL = 0,
>
>  SIGEV_NONE,
>
>  SIGEV_THREAD,
>
>
>  SIGEV_THREAD_ID = 4
>
>};
># 81 "/usr/include/signal.h" 2 3 4
>
>
>
>
>typedef void (*__sighandler_t) (int);
>
>
>
>
>extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern __sighandler_t signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
># 114 "/usr/include/signal.h" 3 4
>
>
>
>
>
>extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int kill (__pid_t __pid, int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int killpg (__pid_t __pgrp, int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int raise (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
>extern int gsignal (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void psignal (int __sig, const char *__s);
>
>
>
>
>extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
># 167 "/usr/include/signal.h" 3 4
>extern int __sigpause (int __sig_or_mask, int __is_sig);
>
>
>
>extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
># 189 "/usr/include/signal.h" 3 4
>extern int sigblock (int __mask) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>
>
>extern int sigsetmask (int __mask) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>
>
>extern int siggetmask (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
># 204 "/usr/include/signal.h" 3 4
>typedef __sighandler_t sighandler_t;
>
>
>
>
>typedef __sighandler_t sig_t;
>
>
>
>
>
>extern int sigemptyset (sigset_t *__set) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigfillset (sigset_t *__set) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigaddset (sigset_t *__set, int __signo) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigdelset (sigset_t *__set, int __signo) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigismember (const sigset_t *__set, int __signo)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int sigisemptyset (const sigset_t *__set) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigandset (sigset_t *__set, const sigset_t *__left,
>        const sigset_t *__right) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>extern int sigorset (sigset_t *__set, const sigset_t *__left,
>       const sigset_t *__right) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
># 1 "/usr/include/bits/sigaction.h" 1 3 4
># 23 "/usr/include/bits/sigaction.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 24 "/usr/include/bits/sigaction.h" 2 3 4
>
>
>
>struct sigaction
>  {
>
>
>    union
>      {
>
> __sighandler_t sa_handler;
>
> void (*sa_sigaction) (int, siginfo_t *, void *);
>      }
>    __sigaction_handler;
>
>
>
>
>
>
>
>    int __glibc_reserved0;
>    int sa_flags;
>
>
>    void (*sa_restorer) (void);
>
>
>    __sigset_t sa_mask;
>  };
># 246 "/usr/include/signal.h" 2 3 4
>
>
>extern int sigprocmask (int __how, const sigset_t *__restrict __set,
>   sigset_t *__restrict __oset) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigaction (int __sig, const struct sigaction *__restrict __act,
>        struct sigaction *__restrict __oact) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sigpending (sigset_t *__set) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
>     __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int sigwaitinfo (const sigset_t *__restrict __set,
>   siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sigtimedwait (const sigset_t *__restrict __set,
>    siginfo_t *__restrict __info,
>    const struct timespec *__restrict __timeout)
>     __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
>     __attribute__ ((__nothrow__ , __leaf__));
># 303 "/usr/include/signal.h" 3 4
>extern const char *const _sys_siglist[65];
>extern const char *const sys_siglist[65];
>
>
>struct sigvec
>  {
>    __sighandler_t sv_handler;
>    int sv_mask;
>
>    int sv_flags;
>
>  };
># 327 "/usr/include/signal.h" 3 4
>extern int sigvec (int __sig, const struct sigvec *__vec,
>     struct sigvec *__ovec) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 1 "/usr/include/bits/sigcontext.h" 1 3 4
># 27 "/usr/include/bits/sigcontext.h" 3 4
># 1 "/usr/include/asm/sigcontext.h" 1 3 4
># 36 "/usr/include/asm/sigcontext.h" 3 4
>typedef struct
>{
>        unsigned long mask;
>        unsigned long addr;
>} __attribute__ ((aligned(8))) _psw_t;
>
>typedef struct
>{
> _psw_t psw;
> unsigned long gprs[16];
> unsigned int acrs[16];
>} _s390_regs_common;
>
>typedef struct
>{
> unsigned int fpc;
> unsigned int pad;
> double fprs[16];
>} _s390_fp_regs;
>
>typedef struct
>{
> _s390_regs_common regs;
> _s390_fp_regs fpregs;
>} _sigregs;
>
>struct sigcontext
>{
> unsigned long oldmask[(64 / 64)];
> _sigregs *sregs;
>};
># 28 "/usr/include/bits/sigcontext.h" 2 3 4
>
>
>
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 32 "/usr/include/bits/sigcontext.h" 2 3 4
># 333 "/usr/include/signal.h" 2 3 4
>
>
>extern int sigreturn (struct sigcontext *__scp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 212 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 3 4
>typedef long unsigned int size_t;
># 343 "/usr/include/signal.h" 2 3 4
>
>
>
>
>extern int siginterrupt (int __sig, int __interrupt) __attribute__ ((__nothrow__ , __leaf__));
>
># 1 "/usr/include/bits/sigstack.h" 1 3 4
># 25 "/usr/include/bits/sigstack.h" 3 4
>struct sigstack
>  {
>    void *ss_sp;
>    int ss_onstack;
>  };
>
>
>
>enum
>{
>  SS_ONSTACK = 1,
>
>  SS_DISABLE
>
>};
># 49 "/usr/include/bits/sigstack.h" 3 4
>typedef struct sigaltstack
>  {
>    void *ss_sp;
>    int ss_flags;
>    size_t ss_size;
>  } stack_t;
># 350 "/usr/include/signal.h" 2 3 4
>
>
># 1 "/usr/include/sys/ucontext.h" 1 3 4
># 22 "/usr/include/sys/ucontext.h" 3 4
>struct ucontext;
>typedef struct ucontext ucontext_t;
>
># 1 "/usr/include/signal.h" 1 3 4
># 26 "/usr/include/sys/ucontext.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/sigcontext.h" 1 3 4
># 30 "/usr/include/sys/ucontext.h" 2 3 4
>
>
>typedef struct
>{
>  unsigned long mask;
>  unsigned long addr;
>} __attribute__ ((__aligned__(8))) __psw_t;
>
>
>typedef unsigned long greg_t;
># 52 "/usr/include/sys/ucontext.h" 3 4
>typedef greg_t gregset_t[27] __attribute__ ((__aligned__(8)));
>
>typedef union
>  {
>    double d;
>    float f;
>  } fpreg_t;
>
>
>typedef struct
>  {
>    unsigned int fpc;
>    fpreg_t fprs[16];
>  } fpregset_t;
>
>
>typedef struct
>  {
>    __psw_t psw;
>    unsigned long gregs[16];
>    unsigned int aregs[16];
>    fpregset_t fpregs;
>  } mcontext_t;
>
>
>struct ucontext
>  {
>    unsigned long int uc_flags;
>    struct ucontext *uc_link;
>    stack_t uc_stack;
>    mcontext_t uc_mcontext;
>    __sigset_t uc_sigmask;
>  };
># 353 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>
>
>
>extern int sigaltstack (const struct sigaltstack *__restrict __ss,
>   struct sigaltstack *__restrict __oss) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern int sighold (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sigrelse (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sigignore (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __sighandler_t sigset (int __sig, __sighandler_t __disp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
># 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
># 21 "/usr/include/bits/pthreadtypes.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 22 "/usr/include/bits/pthreadtypes.h" 2 3 4
># 48 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef unsigned long int pthread_t;
>
>
>union pthread_attr_t
>{
>  char __size[56];
>  long int __align;
>};
>
>
>
>
>
>
>
>typedef struct __pthread_internal_list
>{
>  struct __pthread_internal_list *__prev;
>  struct __pthread_internal_list *__next;
>} __pthread_list_t;
># 78 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef union
>{
>  struct __pthread_mutex_s
>  {
>    int __lock;
>    unsigned int __count;
>    int __owner;
>
>    unsigned int __nusers;
>
>
>
>    int __kind;
>
>
>
>
>
>
>
>    int __spins;
>
>
>
>    __pthread_list_t __list;
># 126 "/usr/include/bits/pthreadtypes.h" 3 4
>  } __data;
>  char __size[40];
>  long int __align;
>} pthread_mutex_t;
>
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_mutexattr_t;
>
>
>
>
>typedef union
>{
>  struct
>  {
>    int __lock;
>    unsigned int __futex;
>    __extension__ unsigned long long int __total_seq;
>    __extension__ unsigned long long int __wakeup_seq;
>    __extension__ unsigned long long int __woken_seq;
>    void *__mutex;
>    unsigned int __nwaiters;
>    unsigned int __broadcast_seq;
>  } __data;
>  char __size[48];
>  __extension__ long long int __align;
>} pthread_cond_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_condattr_t;
>
>
>
>typedef unsigned int pthread_key_t;
>
>
>
>typedef int pthread_once_t;
>
>
>
>
>
>typedef union
>{
>
>  struct
>  {
>    int __lock;
>    unsigned int __nr_readers;
>    unsigned int __readers_wakeup;
>    unsigned int __writer_wakeup;
>    unsigned int __nr_readers_queued;
>    unsigned int __nr_writers_queued;
>    int __writer;
>    int __shared;
>    unsigned long int __pad1;
>    unsigned long int __pad2;
>
>
>    unsigned int __flags;
>  } __data;
># 213 "/usr/include/bits/pthreadtypes.h" 3 4
>  char __size[56];
>  long int __align;
>} pthread_rwlock_t;
>
>
>
>typedef union
>{
>  char __size[8];
>  long int __align;
>} pthread_rwlockattr_t;
>
>
>
>
>
>typedef volatile int pthread_spinlock_t;
>
>
>
>
>typedef union
>{
>  char __size[32];
>  long int __align;
>} pthread_barrier_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_barrierattr_t;
># 388 "/usr/include/signal.h" 2 3 4
># 1 "/usr/include/bits/sigthread.h" 1 3 4
># 30 "/usr/include/bits/sigthread.h" 3 4
>extern int pthread_sigmask (int __how,
>       const __sigset_t *__restrict __newmask,
>       __sigset_t *__restrict __oldmask)__attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int pthread_kill (pthread_t __threadid, int __signo) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int pthread_sigqueue (pthread_t __threadid, int __signo,
>        const union sigval __value) __attribute__ ((__nothrow__ , __leaf__));
># 389 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>extern int __libc_current_sigrtmin (void) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int __libc_current_sigrtmax (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
># 15 "method-to-ir.c" 2
>
>
># 1 "/usr/include/unistd.h" 1 3 4
># 27 "/usr/include/unistd.h" 3 4
>
># 202 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/posix_opt.h" 1 3 4
># 203 "/usr/include/unistd.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/environments.h" 1 3 4
># 22 "/usr/include/bits/environments.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 23 "/usr/include/bits/environments.h" 2 3 4
># 207 "/usr/include/unistd.h" 2 3 4
># 220 "/usr/include/unistd.h" 3 4
>typedef __ssize_t ssize_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 227 "/usr/include/unistd.h" 2 3 4
>
>
>
>
>
>typedef __gid_t gid_t;
># 243 "/usr/include/unistd.h" 3 4
>typedef __off_t off_t;
>
>
>
>
>
>
>typedef __off64_t off64_t;
>
>
>
>
>typedef __useconds_t useconds_t;
># 267 "/usr/include/unistd.h" 3 4
>typedef __intptr_t intptr_t;
>
>
>
>
>
>
>typedef __socklen_t socklen_t;
># 287 "/usr/include/unistd.h" 3 4
>extern int access (const char *__name, int __type) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int euidaccess (const char *__name, int __type)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int eaccess (const char *__name, int __type)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int faccessat (int __fd, const char *__file, int __type, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
># 334 "/usr/include/unistd.h" 3 4
>extern __off_t lseek (int __fd, __off_t __offset, int __whence) __attribute__ ((__nothrow__ , __leaf__));
># 345 "/usr/include/unistd.h" 3 4
>extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int close (int __fd);
>
>
>
>
>
>
>extern ssize_t read (int __fd, void *__buf, size_t __nbytes) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern ssize_t write (int __fd, const void *__buf, size_t __n) __attribute__ ((__warn_unused_result__));
># 376 "/usr/include/unistd.h" 3 4
>extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
>        __off_t __offset) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
>         __off_t __offset) __attribute__ ((__warn_unused_result__));
># 404 "/usr/include/unistd.h" 3 4
>extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
>   __off64_t __offset) __attribute__ ((__warn_unused_result__));
>
>
>extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
>    __off64_t __offset) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern int pipe (int __pipedes[2]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int pipe2 (int __pipedes[2], int __flags) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 432 "/usr/include/unistd.h" 3 4
>extern unsigned int alarm (unsigned int __seconds) __attribute__ ((__nothrow__ , __leaf__));
># 444 "/usr/include/unistd.h" 3 4
>extern unsigned int sleep (unsigned int __seconds);
>
>
>
>
>
>
>
>extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int usleep (__useconds_t __useconds);
># 469 "/usr/include/unistd.h" 3 4
>extern int pause (void);
>
>
>
>extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int fchown (int __fd, __uid_t __owner, __gid_t __group) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int fchownat (int __fd, const char *__file, __uid_t __owner,
>       __gid_t __group, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int chdir (const char *__path) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int fchdir (int __fd) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 511 "/usr/include/unistd.h" 3 4
>extern char *getcwd (char *__buf, size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *get_current_dir_name (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern char *getwd (char *__buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int dup (int __fd) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>extern int dup2 (int __fd, int __fd2) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int dup3 (int __fd, int __fd2, int __flags) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern char **__environ;
>
>extern char **environ;
>
>
>
>
>
>extern int execve (const char *__path, char *const __argv[],
>     char *const __envp[]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern int execv (const char *__path, char *const __argv[])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execle (const char *__path, const char *__arg, ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execl (const char *__path, const char *__arg, ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execvp (const char *__file, char *const __argv[])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int execlp (const char *__file, const char *__arg, ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int execvpe (const char *__file, char *const __argv[],
>      char *const __envp[])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int nice (int __inc) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void _exit (int __status) __attribute__ ((__noreturn__));
>
>
>
>
>
># 1 "/usr/include/bits/confname.h" 1 3 4
># 24 "/usr/include/bits/confname.h" 3 4
>enum
>  {
>    _PC_LINK_MAX,
>
>    _PC_MAX_CANON,
>
>    _PC_MAX_INPUT,
>
>    _PC_NAME_MAX,
>
>    _PC_PATH_MAX,
>
>    _PC_PIPE_BUF,
>
>    _PC_CHOWN_RESTRICTED,
>
>    _PC_NO_TRUNC,
>
>    _PC_VDISABLE,
>
>    _PC_SYNC_IO,
>
>    _PC_ASYNC_IO,
>
>    _PC_PRIO_IO,
>
>    _PC_SOCK_MAXBUF,
>
>    _PC_FILESIZEBITS,
>
>    _PC_REC_INCR_XFER_SIZE,
>
>    _PC_REC_MAX_XFER_SIZE,
>
>    _PC_REC_MIN_XFER_SIZE,
>
>    _PC_REC_XFER_ALIGN,
>
>    _PC_ALLOC_SIZE_MIN,
>
>    _PC_SYMLINK_MAX,
>
>    _PC_2_SYMLINKS
>
>  };
>
>
>enum
>  {
>    _SC_ARG_MAX,
>
>    _SC_CHILD_MAX,
>
>    _SC_CLK_TCK,
>
>    _SC_NGROUPS_MAX,
>
>    _SC_OPEN_MAX,
>
>    _SC_STREAM_MAX,
>
>    _SC_TZNAME_MAX,
>
>    _SC_JOB_CONTROL,
>
>    _SC_SAVED_IDS,
>
>    _SC_REALTIME_SIGNALS,
>
>    _SC_PRIORITY_SCHEDULING,
>
>    _SC_TIMERS,
>
>    _SC_ASYNCHRONOUS_IO,
>
>    _SC_PRIORITIZED_IO,
>
>    _SC_SYNCHRONIZED_IO,
>
>    _SC_FSYNC,
>
>    _SC_MAPPED_FILES,
>
>    _SC_MEMLOCK,
>
>    _SC_MEMLOCK_RANGE,
>
>    _SC_MEMORY_PROTECTION,
>
>    _SC_MESSAGE_PASSING,
>
>    _SC_SEMAPHORES,
>
>    _SC_SHARED_MEMORY_OBJECTS,
>
>    _SC_AIO_LISTIO_MAX,
>
>    _SC_AIO_MAX,
>
>    _SC_AIO_PRIO_DELTA_MAX,
>
>    _SC_DELAYTIMER_MAX,
>
>    _SC_MQ_OPEN_MAX,
>
>    _SC_MQ_PRIO_MAX,
>
>    _SC_VERSION,
>
>    _SC_PAGESIZE,
>
>
>    _SC_RTSIG_MAX,
>
>    _SC_SEM_NSEMS_MAX,
>
>    _SC_SEM_VALUE_MAX,
>
>    _SC_SIGQUEUE_MAX,
>
>    _SC_TIMER_MAX,
>
>
>
>
>    _SC_BC_BASE_MAX,
>
>    _SC_BC_DIM_MAX,
>
>    _SC_BC_SCALE_MAX,
>
>    _SC_BC_STRING_MAX,
>
>    _SC_COLL_WEIGHTS_MAX,
>
>    _SC_EQUIV_CLASS_MAX,
>
>    _SC_EXPR_NEST_MAX,
>
>    _SC_LINE_MAX,
>
>    _SC_RE_DUP_MAX,
>
>    _SC_CHARCLASS_NAME_MAX,
>
>
>    _SC_2_VERSION,
>
>    _SC_2_C_BIND,
>
>    _SC_2_C_DEV,
>
>    _SC_2_FORT_DEV,
>
>    _SC_2_FORT_RUN,
>
>    _SC_2_SW_DEV,
>
>    _SC_2_LOCALEDEF,
>
>
>    _SC_PII,
>
>    _SC_PII_XTI,
>
>    _SC_PII_SOCKET,
>
>    _SC_PII_INTERNET,
>
>    _SC_PII_OSI,
>
>    _SC_POLL,
>
>    _SC_SELECT,
>
>    _SC_UIO_MAXIOV,
>
>    _SC_IOV_MAX = _SC_UIO_MAXIOV,
>
>    _SC_PII_INTERNET_STREAM,
>
>    _SC_PII_INTERNET_DGRAM,
>
>    _SC_PII_OSI_COTS,
>
>    _SC_PII_OSI_CLTS,
>
>    _SC_PII_OSI_M,
>
>    _SC_T_IOV_MAX,
>
>
>
>    _SC_THREADS,
>
>    _SC_THREAD_SAFE_FUNCTIONS,
>
>    _SC_GETGR_R_SIZE_MAX,
>
>    _SC_GETPW_R_SIZE_MAX,
>
>    _SC_LOGIN_NAME_MAX,
>
>    _SC_TTY_NAME_MAX,
>
>    _SC_THREAD_DESTRUCTOR_ITERATIONS,
>
>    _SC_THREAD_KEYS_MAX,
>
>    _SC_THREAD_STACK_MIN,
>
>    _SC_THREAD_THREADS_MAX,
>
>    _SC_THREAD_ATTR_STACKADDR,
>
>    _SC_THREAD_ATTR_STACKSIZE,
>
>    _SC_THREAD_PRIORITY_SCHEDULING,
>
>    _SC_THREAD_PRIO_INHERIT,
>
>    _SC_THREAD_PRIO_PROTECT,
>
>    _SC_THREAD_PROCESS_SHARED,
>
>
>    _SC_NPROCESSORS_CONF,
>
>    _SC_NPROCESSORS_ONLN,
>
>    _SC_PHYS_PAGES,
>
>    _SC_AVPHYS_PAGES,
>
>    _SC_ATEXIT_MAX,
>
>    _SC_PASS_MAX,
>
>
>    _SC_XOPEN_VERSION,
>
>    _SC_XOPEN_XCU_VERSION,
>
>    _SC_XOPEN_UNIX,
>
>    _SC_XOPEN_CRYPT,
>
>    _SC_XOPEN_ENH_I18N,
>
>    _SC_XOPEN_SHM,
>
>
>    _SC_2_CHAR_TERM,
>
>    _SC_2_C_VERSION,
>
>    _SC_2_UPE,
>
>
>    _SC_XOPEN_XPG2,
>
>    _SC_XOPEN_XPG3,
>
>    _SC_XOPEN_XPG4,
>
>
>    _SC_CHAR_BIT,
>
>    _SC_CHAR_MAX,
>
>    _SC_CHAR_MIN,
>
>    _SC_INT_MAX,
>
>    _SC_INT_MIN,
>
>    _SC_LONG_BIT,
>
>    _SC_WORD_BIT,
>
>    _SC_MB_LEN_MAX,
>
>    _SC_NZERO,
>
>    _SC_SSIZE_MAX,
>
>    _SC_SCHAR_MAX,
>
>    _SC_SCHAR_MIN,
>
>    _SC_SHRT_MAX,
>
>    _SC_SHRT_MIN,
>
>    _SC_UCHAR_MAX,
>
>    _SC_UINT_MAX,
>
>    _SC_ULONG_MAX,
>
>    _SC_USHRT_MAX,
>
>
>    _SC_NL_ARGMAX,
>
>    _SC_NL_LANGMAX,
>
>    _SC_NL_MSGMAX,
>
>    _SC_NL_NMAX,
>
>    _SC_NL_SETMAX,
>
>    _SC_NL_TEXTMAX,
>
>
>    _SC_XBS5_ILP32_OFF32,
>
>    _SC_XBS5_ILP32_OFFBIG,
>
>    _SC_XBS5_LP64_OFF64,
>
>    _SC_XBS5_LPBIG_OFFBIG,
>
>
>    _SC_XOPEN_LEGACY,
>
>    _SC_XOPEN_REALTIME,
>
>    _SC_XOPEN_REALTIME_THREADS,
>
>
>    _SC_ADVISORY_INFO,
>
>    _SC_BARRIERS,
>
>    _SC_BASE,
>
>    _SC_C_LANG_SUPPORT,
>
>    _SC_C_LANG_SUPPORT_R,
>
>    _SC_CLOCK_SELECTION,
>
>    _SC_CPUTIME,
>
>    _SC_THREAD_CPUTIME,
>
>    _SC_DEVICE_IO,
>
>    _SC_DEVICE_SPECIFIC,
>
>    _SC_DEVICE_SPECIFIC_R,
>
>    _SC_FD_MGMT,
>
>    _SC_FIFO,
>
>    _SC_PIPE,
>
>    _SC_FILE_ATTRIBUTES,
>
>    _SC_FILE_LOCKING,
>
>    _SC_FILE_SYSTEM,
>
>    _SC_MONOTONIC_CLOCK,
>
>    _SC_MULTI_PROCESS,
>
>    _SC_SINGLE_PROCESS,
>
>    _SC_NETWORKING,
>
>    _SC_READER_WRITER_LOCKS,
>
>    _SC_SPIN_LOCKS,
>
>    _SC_REGEXP,
>
>    _SC_REGEX_VERSION,
>
>    _SC_SHELL,
>
>    _SC_SIGNALS,
>
>    _SC_SPAWN,
>
>    _SC_SPORADIC_SERVER,
>
>    _SC_THREAD_SPORADIC_SERVER,
>
>    _SC_SYSTEM_DATABASE,
>
>    _SC_SYSTEM_DATABASE_R,
>
>    _SC_TIMEOUTS,
>
>    _SC_TYPED_MEMORY_OBJECTS,
>
>    _SC_USER_GROUPS,
>
>    _SC_USER_GROUPS_R,
>
>    _SC_2_PBS,
>
>    _SC_2_PBS_ACCOUNTING,
>
>    _SC_2_PBS_LOCATE,
>
>    _SC_2_PBS_MESSAGE,
>
>    _SC_2_PBS_TRACK,
>
>    _SC_SYMLOOP_MAX,
>
>    _SC_STREAMS,
>
>    _SC_2_PBS_CHECKPOINT,
>
>
>    _SC_V6_ILP32_OFF32,
>
>    _SC_V6_ILP32_OFFBIG,
>
>    _SC_V6_LP64_OFF64,
>
>    _SC_V6_LPBIG_OFFBIG,
>
>
>    _SC_HOST_NAME_MAX,
>
>    _SC_TRACE,
>
>    _SC_TRACE_EVENT_FILTER,
>
>    _SC_TRACE_INHERIT,
>
>    _SC_TRACE_LOG,
>
>
>    _SC_LEVEL1_ICACHE_SIZE,
>
>    _SC_LEVEL1_ICACHE_ASSOC,
>
>    _SC_LEVEL1_ICACHE_LINESIZE,
>
>    _SC_LEVEL1_DCACHE_SIZE,
>
>    _SC_LEVEL1_DCACHE_ASSOC,
>
>    _SC_LEVEL1_DCACHE_LINESIZE,
>
>    _SC_LEVEL2_CACHE_SIZE,
>
>    _SC_LEVEL2_CACHE_ASSOC,
>
>    _SC_LEVEL2_CACHE_LINESIZE,
>
>    _SC_LEVEL3_CACHE_SIZE,
>
>    _SC_LEVEL3_CACHE_ASSOC,
>
>    _SC_LEVEL3_CACHE_LINESIZE,
>
>    _SC_LEVEL4_CACHE_SIZE,
>
>    _SC_LEVEL4_CACHE_ASSOC,
>
>    _SC_LEVEL4_CACHE_LINESIZE,
>
>
>
>    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
>
>    _SC_RAW_SOCKETS,
>
>
>    _SC_V7_ILP32_OFF32,
>
>    _SC_V7_ILP32_OFFBIG,
>
>    _SC_V7_LP64_OFF64,
>
>    _SC_V7_LPBIG_OFFBIG,
>
>
>    _SC_SS_REPL_MAX,
>
>
>    _SC_TRACE_EVENT_NAME_MAX,
>
>    _SC_TRACE_NAME_MAX,
>
>    _SC_TRACE_SYS_MAX,
>
>    _SC_TRACE_USER_EVENT_MAX,
>
>
>    _SC_XOPEN_STREAMS,
>
>
>    _SC_THREAD_ROBUST_PRIO_INHERIT,
>
>    _SC_THREAD_ROBUST_PRIO_PROTECT
>
>  };
>
>
>enum
>  {
>    _CS_PATH,
>
>
>    _CS_V6_WIDTH_RESTRICTED_ENVS,
>
>
>
>    _CS_GNU_LIBC_VERSION,
>
>    _CS_GNU_LIBPTHREAD_VERSION,
>
>
>    _CS_V5_WIDTH_RESTRICTED_ENVS,
>
>
>
>    _CS_V7_WIDTH_RESTRICTED_ENVS,
>
>
>
>    _CS_LFS_CFLAGS = 1000,
>
>    _CS_LFS_LDFLAGS,
>
>    _CS_LFS_LIBS,
>
>    _CS_LFS_LINTFLAGS,
>
>    _CS_LFS64_CFLAGS,
>
>    _CS_LFS64_LDFLAGS,
>
>    _CS_LFS64_LIBS,
>
>    _CS_LFS64_LINTFLAGS,
>
>
>    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
>
>    _CS_XBS5_ILP32_OFF32_LDFLAGS,
>
>    _CS_XBS5_ILP32_OFF32_LIBS,
>
>    _CS_XBS5_ILP32_OFF32_LINTFLAGS,
>
>    _CS_XBS5_ILP32_OFFBIG_CFLAGS,
>
>    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
>
>    _CS_XBS5_ILP32_OFFBIG_LIBS,
>
>    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
>
>    _CS_XBS5_LP64_OFF64_CFLAGS,
>
>    _CS_XBS5_LP64_OFF64_LDFLAGS,
>
>    _CS_XBS5_LP64_OFF64_LIBS,
>
>    _CS_XBS5_LP64_OFF64_LINTFLAGS,
>
>    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
>
>    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
>
>    _CS_XBS5_LPBIG_OFFBIG_LIBS,
>
>    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
>
>
>    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFF32_LIBS,
>
>    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
>
>    _CS_POSIX_V6_LP64_OFF64_CFLAGS,
>
>    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
>
>    _CS_POSIX_V6_LP64_OFF64_LIBS,
>
>    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
>
>
>    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFF32_LIBS,
>
>    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,
>
>    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
>
>    _CS_POSIX_V7_LP64_OFF64_CFLAGS,
>
>    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,
>
>    _CS_POSIX_V7_LP64_OFF64_LIBS,
>
>    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
>
>    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
>
>    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
>
>
>    _CS_V6_ENV,
>
>    _CS_V7_ENV
>
>  };
># 610 "/usr/include/unistd.h" 2 3 4
>
>
>extern long int pathconf (const char *__path, int __name)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int fpathconf (int __fd, int __name) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long int sysconf (int __name) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern size_t confstr (int __name, char *__buf, size_t __len) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __pid_t getpid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __pid_t getppid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __pid_t getpgrp (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __pid_t __getpgid (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
>
>extern __pid_t getpgid (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int setpgid (__pid_t __pid, __pid_t __pgid) __attribute__ ((__nothrow__ , __leaf__));
># 660 "/usr/include/unistd.h" 3 4
>extern int setpgrp (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern __pid_t setsid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern __pid_t getsid (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern __uid_t getuid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __uid_t geteuid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __gid_t getgid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __gid_t getegid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int getgroups (int __size, __gid_t __list[]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int group_member (__gid_t __gid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int setuid (__uid_t __uid) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int setreuid (__uid_t __ruid, __uid_t __euid) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int seteuid (__uid_t __uid) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int setgid (__gid_t __gid) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int setregid (__gid_t __rgid, __gid_t __egid) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int setegid (__gid_t __gid) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern __pid_t fork (void) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern __pid_t vfork (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *ttyname (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int isatty (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int ttyslot (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int link (const char *__from, const char *__to)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int linkat (int __fromfd, const char *__from, int __tofd,
>     const char *__to, int __flags)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int symlink (const char *__from, const char *__to)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern ssize_t readlink (const char *__restrict __path,
>    char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int symlinkat (const char *__from, int __tofd,
>        const char *__to) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));
>
>
>extern ssize_t readlinkat (int __fd, const char *__restrict __path,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int unlink (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int unlinkat (int __fd, const char *__name, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>extern int rmdir (const char *__path) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern __pid_t tcgetpgrp (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern char *getlogin (void);
>
>
>
>
>
>
>
>extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int setlogin (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 871 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/getopt.h" 1 3 4
># 57 "/usr/include/getopt.h" 3 4
>extern char *optarg;
># 71 "/usr/include/getopt.h" 3 4
>extern int optind;
>
>
>
>
>extern int opterr;
>
>
>
>extern int optopt;
># 150 "/usr/include/getopt.h" 3 4
>extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
>       __attribute__ ((__nothrow__ , __leaf__));
># 872 "/usr/include/unistd.h" 2 3 4
>
>
>
>
>
>
>
>extern int gethostname (char *__name, size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sethostname (const char *__name, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int sethostid (long int __id) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int getdomainname (char *__name, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>extern int setdomainname (const char *__name, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int vhangup (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int revoke (const char *__file) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern int profil (unsigned short int *__sample_buffer, size_t __size,
>     size_t __offset, unsigned int __scale)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int acct (const char *__name) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern char *getusershell (void) __attribute__ ((__nothrow__ , __leaf__));
>extern void endusershell (void) __attribute__ ((__nothrow__ , __leaf__));
>extern void setusershell (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int daemon (int __nochdir, int __noclose) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int chroot (const char *__path) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int fsync (int __fd);
>
>
>
>
>
>extern int syncfs (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long int gethostid (void);
>
>
>extern void sync (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int getpagesize (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern int getdtablesize (void) __attribute__ ((__nothrow__ , __leaf__));
># 993 "/usr/include/unistd.h" 3 4
>extern int truncate (const char *__file, __off_t __length)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 1005 "/usr/include/unistd.h" 3 4
>extern int truncate64 (const char *__file, __off64_t __length)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 1016 "/usr/include/unistd.h" 3 4
>extern int ftruncate (int __fd, __off_t __length) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 1026 "/usr/include/unistd.h" 3 4
>extern int ftruncate64 (int __fd, __off64_t __length) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 1037 "/usr/include/unistd.h" 3 4
>extern int brk (void *__addr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern void *sbrk (intptr_t __delta) __attribute__ ((__nothrow__ , __leaf__));
># 1058 "/usr/include/unistd.h" 3 4
>extern long int syscall (long int __sysno, ...) __attribute__ ((__nothrow__ , __leaf__));
># 1081 "/usr/include/unistd.h" 3 4
>extern int lockf (int __fd, int __cmd, __off_t __len) __attribute__ ((__warn_unused_result__));
># 1091 "/usr/include/unistd.h" 3 4
>extern int lockf64 (int __fd, int __cmd, __off64_t __len) __attribute__ ((__warn_unused_result__));
># 1112 "/usr/include/unistd.h" 3 4
>extern int fdatasync (int __fildes);
>
>
>
>
>
>
>
>extern char *crypt (const char *__key, const char *__salt)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern void encrypt (char *__glibc_block, int __edflag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void swab (const void *__restrict __from, void *__restrict __to,
>    ssize_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
># 1148 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/unistd.h" 1 3 4
># 23 "/usr/include/bits/unistd.h" 3 4
>extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes,
>      size_t __buflen) __attribute__ ((__warn_unused_result__));
>extern ssize_t __read_alias (int __fd, void *__buf, size_t __nbytes) __asm__ ("" "read")
>                               __attribute__ ((__warn_unused_result__));
>extern ssize_t __read_chk_warn (int __fd, void *__buf, size_t __nbytes, size_t __buflen) __asm__ ("" "__read_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("read called with bigger length than size of " "the destination buffer")))
>                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
>read (int __fd, void *__buf, size_t __nbytes)
>{
>  if (__builtin_object_size (__buf, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__nbytes))
> return __read_chk (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
>
>      if (__nbytes > __builtin_object_size (__buf, 0))
> return __read_chk_warn (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
>    }
>  return __read_alias (__fd, __buf, __nbytes);
>}
>
>
>extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes,
>       __off_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
>extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes,
>         __off64_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
>extern ssize_t __pread_alias (int __fd, void *__buf, size_t __nbytes, __off_t __offset) __asm__ ("" "pread")
>
>                                 __attribute__ ((__warn_unused_result__));
>extern ssize_t __pread64_alias (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")
>
>                                     __attribute__ ((__warn_unused_result__));
>extern ssize_t __pread_chk_warn (int __fd, void *__buf, size_t __nbytes, __off_t __offset, size_t __bufsize) __asm__ ("" "__pread_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread called with bigger length than size of " "the destination buffer")))
>                                  ;
>extern ssize_t __pread64_chk_warn (int __fd, void *__buf, size_t __nbytes, __off64_t __offset, size_t __bufsize) __asm__ ("" "__pread64_chk")
>
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread64 called with bigger length than size of " "the destination buffer")))
>                                  ;
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
>pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset)
>{
>  if (__builtin_object_size (__buf, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__nbytes))
> return __pread_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));
>
>      if ( __nbytes > __builtin_object_size (__buf, 0))
> return __pread_chk_warn (__fd, __buf, __nbytes, __offset,
>     __builtin_object_size (__buf, 0));
>    }
>  return __pread_alias (__fd, __buf, __nbytes, __offset);
>}
># 104 "/usr/include/bits/unistd.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
>pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
>{
>  if (__builtin_object_size (__buf, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__nbytes))
> return __pread64_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));
>
>      if ( __nbytes > __builtin_object_size (__buf, 0))
> return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
>       __builtin_object_size (__buf, 0));
>    }
>
>  return __pread64_alias (__fd, __buf, __nbytes, __offset);
>}
>
>
>
>
>extern ssize_t __readlink_chk (const char *__restrict __path,
>          char *__restrict __buf, size_t __len,
>          size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>extern ssize_t __readlink_alias (const char *__restrict __path, char *__restrict __buf, size_t __len) __asm__ ("" "readlink") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>extern ssize_t __readlink_chk_warn (const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) __asm__ ("" "__readlink_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlink called with bigger length " "than size of destination buffer")))
>                                         ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) ssize_t
>__attribute__ ((__nothrow__ , __leaf__)) readlink (const char *__restrict __path, char *__restrict __buf, size_t __len)
>
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __readlink_chk (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>
>      if ( __len > __builtin_object_size (__buf, 2 > 1))
> return __readlink_chk_warn (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __readlink_alias (__path, __buf, __len);
>}
>
>
>
>extern ssize_t __readlinkat_chk (int __fd, const char *__restrict __path,
>     char *__restrict __buf, size_t __len,
>     size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
>extern ssize_t __readlinkat_alias (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len) __asm__ ("" "readlinkat") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
>extern ssize_t __readlinkat_chk_warn (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) __asm__ ("" "__readlinkat_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlinkat called with bigger " "length than size of destination " "buffer")))
>
>                ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) ssize_t
>__attribute__ ((__nothrow__ , __leaf__)) readlinkat (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len)
>
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __readlinkat_chk (__fd, __path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>
>      if (__len > __builtin_object_size (__buf, 2 > 1))
> return __readlinkat_chk_warn (__fd, __path, __buf, __len,
>          __builtin_object_size (__buf, 2 > 1));
>    }
>  return __readlinkat_alias (__fd, __path, __buf, __len);
>}
>
>
>extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern char *__getcwd_alias (char *__buf, size_t __size) __asm__ ("" "getcwd") __attribute__ ((__nothrow__ , __leaf__))
>                                              __attribute__ ((__warn_unused_result__));
>extern char *__getcwd_chk_warn (char *__buf, size_t __size, size_t __buflen) __asm__ ("" "__getcwd_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getcwd caller with bigger length than size of " "destination buffer")))
>                              ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) getcwd (char *__buf, size_t __size)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__size))
> return __getcwd_chk (__buf, __size, __builtin_object_size (__buf, 2 > 1));
>
>      if (__size > __builtin_object_size (__buf, 2 > 1))
> return __getcwd_chk_warn (__buf, __size, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __getcwd_alias (__buf, __size);
>}
>
>
>extern char *__getwd_chk (char *__buf, size_t buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>extern char *__getwd_warn (char *__buf) __asm__ ("" "getwd") __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use getcwd instead, as getwd " "doesn't specify buffer size")))
>                                         ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) getwd (char *__buf)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    return __getwd_chk (__buf, __builtin_object_size (__buf, 2 > 1));
>  return __getwd_warn (__buf);
>}
>
>
>extern size_t __confstr_chk (int __name, char *__buf, size_t __len,
>        size_t __buflen) __attribute__ ((__nothrow__ , __leaf__));
>extern size_t __confstr_alias (int __name, char *__buf, size_t __len) __asm__ ("" "confstr") __attribute__ ((__nothrow__ , __leaf__))
>                             ;
>extern size_t __confstr_chk_warn (int __name, char *__buf, size_t __len, size_t __buflen) __asm__ ("" "__confstr_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__((__warning__ ("confstr called with bigger length than size of destination " "buffer")))
>            ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__nothrow__ , __leaf__)) confstr (int __name, char *__buf, size_t __len)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __confstr_chk (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>
>      if (__builtin_object_size (__buf, 2 > 1) < __len)
> return __confstr_chk_warn (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __confstr_alias (__name, __buf, __len);
>}
>
>
>extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern int __getgroups_alias (int __size, __gid_t __list[]) __asm__ ("" "getgroups") __attribute__ ((__nothrow__ , __leaf__))
>                 __attribute__ ((__warn_unused_result__));
>extern int __getgroups_chk_warn (int __size, __gid_t __list[], size_t __listlen) __asm__ ("" "__getgroups_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getgroups called with bigger group count than what " "can fit into destination buffer")))
>                                           ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) getgroups (int __size, __gid_t __list[])
>{
>  if (__builtin_object_size (__list, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__size) || __size < 0)
> return __getgroups_chk (__size, __list, __builtin_object_size (__list, 2 > 1));
>
>      if (__size * sizeof (__gid_t) > __builtin_object_size (__list, 2 > 1))
> return __getgroups_chk_warn (__size, __list, __builtin_object_size (__list, 2 > 1));
>    }
>  return __getgroups_alias (__size, __list);
>}
>
>
>extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen,
>       size_t __nreal) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>extern int __ttyname_r_alias (int __fd, char *__buf, size_t __buflen) __asm__ ("" "ttyname_r") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (2)));
>extern int __ttyname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__ttyname_r_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ttyname_r called with bigger buflen than " "size of destination buffer")))
>                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) ttyname_r (int __fd, char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __ttyname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __ttyname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __ttyname_r_alias (__fd, __buf, __buflen);
>}
>
>
>
>extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal)
>     __attribute__ ((__nonnull__ (1)));
>extern int __getlogin_r_alias (char *__buf, size_t __buflen) __asm__ ("" "getlogin_r")
>                     __attribute__ ((__nonnull__ (1)));
>extern int __getlogin_r_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getlogin_r_chk")
>
>
>     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("getlogin_r called with bigger buflen than " "size of destination buffer")))
>                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>getlogin_r (char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __getlogin_r_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __getlogin_r_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __getlogin_r_alias (__buf, __buflen);
>}
>
>
>
>
>extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>extern int __gethostname_alias (char *__buf, size_t __buflen) __asm__ ("" "gethostname") __attribute__ ((__nothrow__ , __leaf__))
>                   __attribute__ ((__nonnull__ (1)));
>extern int __gethostname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__gethostname_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("gethostname called with bigger buflen than " "size of destination buffer")))
>                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) gethostname (char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __gethostname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __gethostname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __gethostname_alias (__buf, __buflen);
>}
>
>
>
>
>extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>extern int __getdomainname_alias (char *__buf, size_t __buflen) __asm__ ("" "getdomainname") __attribute__ ((__nothrow__ , __leaf__))
>
>                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>extern int __getdomainname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getdomainname_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getdomainname called with bigger " "buflen than size of destination " "buffer")))
>
>                    ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) getdomainname (char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __getdomainname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __getdomainname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __getdomainname_alias (__buf, __buflen);
>}
># 1149 "/usr/include/unistd.h" 2 3 4
>
>
>
># 18 "method-to-ir.c" 2
>
>
># 1 "/usr/include/math.h" 1 3 4
># 28 "/usr/include/math.h" 3 4
>
>
>
>
># 1 "/usr/include/bits/huge_val.h" 1 3 4
># 33 "/usr/include/math.h" 2 3 4
>
># 1 "/usr/include/bits/huge_valf.h" 1 3 4
># 35 "/usr/include/math.h" 2 3 4
># 1 "/usr/include/bits/huge_vall.h" 1 3 4
># 36 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/inf.h" 1 3 4
># 39 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/nan.h" 1 3 4
># 42 "/usr/include/math.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/mathdef.h" 1 3 4
># 27 "/usr/include/bits/mathdef.h" 3 4
>typedef double float_t;
>
>typedef double double_t;
># 46 "/usr/include/math.h" 2 3 4
># 69 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 52 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern double acos (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __acos (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double asin (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __asin (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double atan (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __atan (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double atan2 (double __y, double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __atan2 (double __y, double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double cos (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __cos (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double sin (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __sin (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double tan (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __tan (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern double cosh (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __cosh (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double sinh (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __sinh (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double tanh (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __tanh (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void sincos (double __x, double *__sinx, double *__cosx) __attribute__ ((__nothrow__ , __leaf__)); extern void __sincos (double __x, double *__sinx, double *__cosx) __attribute__ ((__nothrow__ , __leaf__))
>                                                           ;
>
>
>
>
>
>extern double acosh (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __acosh (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double asinh (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __asinh (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double atanh (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __atanh (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern double exp (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __exp (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double frexp (double __x, int *__exponent) __attribute__ ((__nothrow__ , __leaf__)); extern double __frexp (double __x, int *__exponent) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double ldexp (double __x, int __exponent) __attribute__ ((__nothrow__ , __leaf__)); extern double __ldexp (double __x, int __exponent) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double log (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __log (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double log10 (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __log10 (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double modf (double __x, double *__iptr) __attribute__ ((__nothrow__ , __leaf__)); extern double __modf (double __x, double *__iptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern double exp10 (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __exp10 (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double pow10 (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __pow10 (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern double expm1 (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __expm1 (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double log1p (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __log1p (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double logb (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __logb (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern double exp2 (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __exp2 (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double log2 (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __log2 (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern double pow (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)); extern double __pow (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double sqrt (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __sqrt (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern double hypot (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)); extern double __hypot (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern double cbrt (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __cbrt (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern double ceil (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __ceil (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern double fabs (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __fabs (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern double floor (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __floor (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern double fmod (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)); extern double __fmod (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int __isinf (double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int __finite (double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int isinf (double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int finite (double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern double drem (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)); extern double __drem (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern double significand (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __significand (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern double copysign (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>
>extern double nan (const char *__tagb) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __nan (const char *__tagb) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnan (double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int isnan (double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern double j0 (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __j0 (double) __attribute__ ((__nothrow__ , __leaf__));
>extern double j1 (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __j1 (double) __attribute__ ((__nothrow__ , __leaf__));
>extern double jn (int, double) __attribute__ ((__nothrow__ , __leaf__)); extern double __jn (int, double) __attribute__ ((__nothrow__ , __leaf__));
>extern double y0 (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __y0 (double) __attribute__ ((__nothrow__ , __leaf__));
>extern double y1 (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __y1 (double) __attribute__ ((__nothrow__ , __leaf__));
>extern double yn (int, double) __attribute__ ((__nothrow__ , __leaf__)); extern double __yn (int, double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern double erf (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __erf (double) __attribute__ ((__nothrow__ , __leaf__));
>extern double erfc (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __erfc (double) __attribute__ ((__nothrow__ , __leaf__));
>extern double lgamma (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __lgamma (double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern double tgamma (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __tgamma (double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern double gamma (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __gamma (double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern double lgamma_r (double, int *__signgamp) __attribute__ ((__nothrow__ , __leaf__)); extern double __lgamma_r (double, int *__signgamp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern double rint (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __rint (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double nextafter (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>extern double nexttoward (double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern double remainder (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)); extern double __remainder (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern double scalbn (double __x, int __n) __attribute__ ((__nothrow__ , __leaf__)); extern double __scalbn (double __x, int __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int ilogb (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern int __ilogb (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern double scalbln (double __x, long int __n) __attribute__ ((__nothrow__ , __leaf__)); extern double __scalbln (double __x, long int __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern double nearbyint (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __nearbyint (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern double round (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __round (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern double trunc (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __trunc (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern double remquo (double __x, double __y, int *__quo) __attribute__ ((__nothrow__ , __leaf__)); extern double __remquo (double __x, double __y, int *__quo) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long int lrint (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long int __lrint (double __x) __attribute__ ((__nothrow__ , __leaf__));
>__extension__
>extern long long int llrint (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long long int __llrint (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long int lround (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long int __lround (double __x) __attribute__ ((__nothrow__ , __leaf__));
>__extension__
>extern long long int llround (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long long int __llround (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern double fdim (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)); extern double __fdim (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double fmax (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __fmax (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern double fmin (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int __fpclassify (double __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>extern int __signbit (double __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>
>extern double fma (double __x, double __y, double __z) __attribute__ ((__nothrow__ , __leaf__)); extern double __fma (double __x, double __y, double __z) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int __issignaling (double __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>
>
>extern double scalb (double __x, double __n) __attribute__ ((__nothrow__ , __leaf__)); extern double __scalb (double __x, double __n) __attribute__ ((__nothrow__ , __leaf__));
># 70 "/usr/include/math.h" 2 3 4
># 88 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 52 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern float acosf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __acosf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float asinf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __asinf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float atanf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __atanf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float atan2f (float __y, float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __atan2f (float __y, float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float cosf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __cosf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float sinf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __sinf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float tanf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __tanf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern float coshf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __coshf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float sinhf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __sinhf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float tanhf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __tanhf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void sincosf (float __x, float *__sinx, float *__cosx) __attribute__ ((__nothrow__ , __leaf__)); extern void __sincosf (float __x, float *__sinx, float *__cosx) __attribute__ ((__nothrow__ , __leaf__))
>                                                           ;
>
>
>
>
>
>extern float acoshf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __acoshf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float asinhf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __asinhf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float atanhf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __atanhf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern float expf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __expf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float frexpf (float __x, int *__exponent) __attribute__ ((__nothrow__ , __leaf__)); extern float __frexpf (float __x, int *__exponent) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float ldexpf (float __x, int __exponent) __attribute__ ((__nothrow__ , __leaf__)); extern float __ldexpf (float __x, int __exponent) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float logf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __logf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float log10f (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __log10f (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float modff (float __x, float *__iptr) __attribute__ ((__nothrow__ , __leaf__)); extern float __modff (float __x, float *__iptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern float exp10f (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __exp10f (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float pow10f (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __pow10f (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern float expm1f (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __expm1f (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float log1pf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __log1pf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float logbf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __logbf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern float exp2f (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __exp2f (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float log2f (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __log2f (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern float powf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)); extern float __powf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float sqrtf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __sqrtf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern float hypotf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)); extern float __hypotf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern float cbrtf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __cbrtf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern float ceilf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __ceilf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern float fabsf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __fabsf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern float floorf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __floorf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern float fmodf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)); extern float __fmodf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int __isinff (float __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int __finitef (float __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int isinff (float __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int finitef (float __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern float dremf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)); extern float __dremf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern float significandf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __significandf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern float copysignf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>
>extern float nanf (const char *__tagb) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __nanf (const char *__tagb) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanf (float __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int isnanf (float __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern float j0f (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __j0f (float) __attribute__ ((__nothrow__ , __leaf__));
>extern float j1f (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __j1f (float) __attribute__ ((__nothrow__ , __leaf__));
>extern float jnf (int, float) __attribute__ ((__nothrow__ , __leaf__)); extern float __jnf (int, float) __attribute__ ((__nothrow__ , __leaf__));
>extern float y0f (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __y0f (float) __attribute__ ((__nothrow__ , __leaf__));
>extern float y1f (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __y1f (float) __attribute__ ((__nothrow__ , __leaf__));
>extern float ynf (int, float) __attribute__ ((__nothrow__ , __leaf__)); extern float __ynf (int, float) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern float erff (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __erff (float) __attribute__ ((__nothrow__ , __leaf__));
>extern float erfcf (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __erfcf (float) __attribute__ ((__nothrow__ , __leaf__));
>extern float lgammaf (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __lgammaf (float) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern float tgammaf (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __tgammaf (float) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern float gammaf (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __gammaf (float) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern float lgammaf_r (float, int *__signgamp) __attribute__ ((__nothrow__ , __leaf__)); extern float __lgammaf_r (float, int *__signgamp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern float rintf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __rintf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float nextafterf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>extern float nexttowardf (float __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern float remainderf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)); extern float __remainderf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern float scalbnf (float __x, int __n) __attribute__ ((__nothrow__ , __leaf__)); extern float __scalbnf (float __x, int __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int ilogbf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern int __ilogbf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern float scalblnf (float __x, long int __n) __attribute__ ((__nothrow__ , __leaf__)); extern float __scalblnf (float __x, long int __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern float nearbyintf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __nearbyintf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern float roundf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __roundf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern float truncf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __truncf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern float remquof (float __x, float __y, int *__quo) __attribute__ ((__nothrow__ , __leaf__)); extern float __remquof (float __x, float __y, int *__quo) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long int lrintf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern long int __lrintf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>__extension__
>extern long long int llrintf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern long long int __llrintf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long int lroundf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern long int __lroundf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>__extension__
>extern long long int llroundf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern long long int __llroundf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern float fdimf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)); extern float __fdimf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float fmaxf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern float fminf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int __fpclassifyf (float __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>extern int __signbitf (float __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>
>extern float fmaf (float __x, float __y, float __z) __attribute__ ((__nothrow__ , __leaf__)); extern float __fmaf (float __x, float __y, float __z) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int __issignalingf (float __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>
>
>extern float scalbf (float __x, float __n) __attribute__ ((__nothrow__ , __leaf__)); extern float __scalbf (float __x, float __n) __attribute__ ((__nothrow__ , __leaf__));
># 89 "/usr/include/math.h" 2 3 4
># 132 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 52 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern long double acosl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __acosl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double asinl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __asinl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double atanl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __atanl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double atan2l (long double __y, long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __atan2l (long double __y, long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double cosl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __cosl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double sinl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __sinl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double tanl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __tanl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern long double coshl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __coshl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double sinhl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __sinhl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double tanhl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __tanhl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void sincosl (long double __x, long double *__sinx, long double *__cosx) __attribute__ ((__nothrow__ , __leaf__)); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) __attribute__ ((__nothrow__ , __leaf__))
>                                                           ;
>
>
>
>
>
>extern long double acoshl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __acoshl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double asinhl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __asinhl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double atanhl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __atanhl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern long double expl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __expl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double frexpl (long double __x, int *__exponent) __attribute__ ((__nothrow__ , __leaf__)); extern long double __frexpl (long double __x, int *__exponent) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double ldexpl (long double __x, int __exponent) __attribute__ ((__nothrow__ , __leaf__)); extern long double __ldexpl (long double __x, int __exponent) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double logl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __logl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double log10l (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __log10l (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double modfl (long double __x, long double *__iptr) __attribute__ ((__nothrow__ , __leaf__)); extern long double __modfl (long double __x, long double *__iptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern long double exp10l (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __exp10l (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double pow10l (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __pow10l (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern long double expm1l (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __expm1l (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double log1pl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __log1pl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double logbl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __logbl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long double exp2l (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __exp2l (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double log2l (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __log2l (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern long double powl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)); extern long double __powl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double sqrtl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __sqrtl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern long double hypotl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)); extern long double __hypotl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long double cbrtl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __cbrtl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern long double ceill (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __ceill (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern long double fabsl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __fabsl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern long double floorl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __floorl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern long double fmodl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)); extern long double __fmodl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int __isinfl (long double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int __finitel (long double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int isinfl (long double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int finitel (long double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern long double dreml (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)); extern long double __dreml (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long double significandl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __significandl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern long double copysignl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>
>extern long double nanl (const char *__tagb) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanl (long double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int isnanl (long double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern long double j0l (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __j0l (long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double j1l (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __j1l (long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double jnl (int, long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __jnl (int, long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double y0l (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __y0l (long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double y1l (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __y1l (long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double ynl (int, long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __ynl (int, long double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long double erfl (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __erfl (long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double erfcl (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __erfcl (long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double lgammal (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __lgammal (long double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long double tgammal (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __tgammal (long double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern long double gammal (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __gammal (long double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long double lgammal_r (long double, int *__signgamp) __attribute__ ((__nothrow__ , __leaf__)); extern long double __lgammal_r (long double, int *__signgamp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern long double rintl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __rintl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double nextafterl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>extern long double nexttowardl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern long double remainderl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)); extern long double __remainderl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long double scalbnl (long double __x, int __n) __attribute__ ((__nothrow__ , __leaf__)); extern long double __scalbnl (long double __x, int __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int ilogbl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern int __ilogbl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern long double scalblnl (long double __x, long int __n) __attribute__ ((__nothrow__ , __leaf__)); extern long double __scalblnl (long double __x, long int __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long double nearbyintl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __nearbyintl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long double roundl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __roundl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern long double truncl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __truncl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern long double remquol (long double __x, long double __y, int *__quo) __attribute__ ((__nothrow__ , __leaf__)); extern long double __remquol (long double __x, long double __y, int *__quo) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long int lrintl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long int __lrintl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>__extension__
>extern long long int llrintl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long long int __llrintl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long int lroundl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long int __lroundl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>__extension__
>extern long long int llroundl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long long int __llroundl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long double fdiml (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)); extern long double __fdiml (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double fmaxl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern long double fminl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int __fpclassifyl (long double __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>extern int __signbitl (long double __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>
>extern long double fmal (long double __x, long double __y, long double __z) __attribute__ ((__nothrow__ , __leaf__)); extern long double __fmal (long double __x, long double __y, long double __z) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int __issignalingl (long double __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>
>
>extern long double scalbl (long double __x, long double __n) __attribute__ ((__nothrow__ , __leaf__)); extern long double __scalbl (long double __x, long double __n) __attribute__ ((__nothrow__ , __leaf__));
># 133 "/usr/include/math.h" 2 3 4
># 148 "/usr/include/math.h" 3 4
>extern int signgam;
># 189 "/usr/include/math.h" 3 4
>enum
>  {
>    FP_NAN =
>
>      0,
>    FP_INFINITE =
>
>      1,
>    FP_ZERO =
>
>      2,
>    FP_SUBNORMAL =
>
>      3,
>    FP_NORMAL =
>
>      4
>  };
># 301 "/usr/include/math.h" 3 4
>typedef enum
>{
>  _IEEE_ = -1,
>  _SVID_,
>  _XOPEN_,
>  _POSIX_,
>  _ISOC_
>} _LIB_VERSION_TYPE;
>
>
>
>
>extern _LIB_VERSION_TYPE _LIB_VERSION;
># 326 "/usr/include/math.h" 3 4
>struct exception
>
>  {
>    int type;
>    char *name;
>    double arg1;
>    double arg2;
>    double retval;
>  };
>
>
>
>
>extern int matherr (struct exception *__exc);
># 426 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathinline.h" 1 3 4
># 35 "/usr/include/bits/mathinline.h" 3 4
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) __signbitf (float __x)
>{
>  __extension__ union { float __f; int __i; } __u = { __f: __x };
>  return __u.__i < 0;
>}
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) __signbit (double __x)
>{
>  __extension__ union { double __d; long __i; } __u = { __d: __x };
>  return __u.__i < 0;
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) __signbitl (long double __x)
>{
>  __extension__ union { long double __l; int __i[4]; } __u = { __l: __x };
>  return __u.__i[0] < 0;
>}
># 427 "/usr/include/math.h" 2 3 4
># 488 "/usr/include/math.h" 3 4
>
># 21 "method-to-ir.c" 2
># 1 "/usr/include/string.h" 1 3 4
># 27 "/usr/include/string.h" 3 4
>
>
>
>
>
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 33 "/usr/include/string.h" 2 3 4
># 44 "/usr/include/string.h" 3 4
>
>
>extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
>       size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memmove (void *__dest, const void *__src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
>        int __c, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern void *memset (void *__s, int __c, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int memcmp (const void *__s1, const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 96 "/usr/include/string.h" 3 4
>extern void *memchr (const void *__s, int __c, size_t __n)
>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
># 110 "/usr/include/string.h" 3 4
>extern void *rawmemchr (const void *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
># 121 "/usr/include/string.h" 3 4
>extern void *memrchr (const void *__s, int __c, size_t __n)
>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncpy (char *__restrict __dest,
>        const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strcat (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncat (char *__restrict __dest, const char *__restrict __src,
>        size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcmp (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int strncmp (const char *__s1, const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcoll (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern size_t strxfrm (char *__restrict __dest,
>         const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
># 1 "/usr/include/xlocale.h" 1 3 4
># 27 "/usr/include/xlocale.h" 3 4
>typedef struct __locale_struct
>{
>
>  struct __locale_data *__locales[13];
>
>
>  const unsigned short int *__ctype_b;
>  const int *__ctype_tolower;
>  const int *__ctype_toupper;
>
>
>  const char *__names[13];
>} *__locale_t;
>
>
>typedef __locale_t locale_t;
># 164 "/usr/include/string.h" 2 3 4
>
>
>extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
>    __locale_t __l) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
>
>
>
>
>extern char *strdup (const char *__s)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *strndup (const char *__string, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
># 210 "/usr/include/string.h" 3 4
>
># 235 "/usr/include/string.h" 3 4
>extern char *strchr (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
># 262 "/usr/include/string.h" 3 4
>extern char *strrchr (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
># 276 "/usr/include/string.h" 3 4
>extern char *strchrnul (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern size_t strcspn (const char *__s, const char *__reject)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern size_t strspn (const char *__s, const char *__accept)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 314 "/usr/include/string.h" 3 4
>extern char *strpbrk (const char *__s, const char *__accept)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 341 "/usr/include/string.h" 3 4
>extern char *strstr (const char *__haystack, const char *__needle)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern char *strtok (char *__restrict __s, const char *__restrict __delim)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern char *__strtok_r (char *__restrict __s,
>    const char *__restrict __delim,
>    char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
>
>extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
>         char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
># 372 "/usr/include/string.h" 3 4
>extern char *strcasestr (const char *__haystack, const char *__needle)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>extern void *memmem (const void *__haystack, size_t __haystacklen,
>       const void *__needle, size_t __needlelen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern void *__mempcpy (void *__restrict __dest,
>   const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern void *mempcpy (void *__restrict __dest,
>        const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern size_t strlen (const char *__s)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern size_t strnlen (const char *__string, size_t __maxlen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strerror (int __errnum) __attribute__ ((__nothrow__ , __leaf__));
>
># 437 "/usr/include/string.h" 3 4
>extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *strerror_l (int __errnum, __locale_t __l) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern void __bzero (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern void bcopy (const void *__src, void *__dest, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void bzero (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int bcmp (const void *__s1, const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 488 "/usr/include/string.h" 3 4
>extern char *index (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
># 516 "/usr/include/string.h" 3 4
>extern char *rindex (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int ffs (int __i) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern int ffsl (long int __l) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>__extension__ extern int ffsll (long long int __ll)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int strcasecmp (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int strcasecmp_l (const char *__s1, const char *__s2,
>    __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern int strncasecmp_l (const char *__s1, const char *__s2,
>     size_t __n, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
>
>
>
>
>
>extern char *strsep (char **__restrict __stringp,
>       const char *__restrict __delim)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern char *strsignal (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *__stpncpy (char *__restrict __dest,
>   const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpncpy (char *__restrict __dest,
>        const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int strverscmp (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strfry (char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memfrob (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 603 "/usr/include/string.h" 3 4
>extern char *basename (const char *__filename) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 631 "/usr/include/string.h" 3 4
># 1 "/usr/include/bits/string.h" 1 3 4
># 44 "/usr/include/bits/string.h" 3 4
>extern __inline size_t __strlen_g (const char *) __asm__ ("strlen");
>
>extern __inline size_t
>__strlen_g (const char *__str)
>{
>    char *__ptr, *__tmp;
>
>    __ptr = (char *) 0;
>    __tmp = (char *) __str;
>    __asm__ __volatile__ ("   la    0,0\n"
>     "0: srst  %0,%1\n"
>     "   jo    0b\n"
>     : "+&a" (__ptr), "+&a" (__tmp) :
>     : "cc", "memory", "0" );
>    return (size_t) (__ptr - __str);
>}
>
>
>
>
>
>
>
>extern __inline char *__strcpy_g (char *, const char *) __asm ("strcpy");
>
>extern __inline char *
>__strcpy_g (char *__dest, const char *__src)
>{
>    char *tmp = __dest;
>
>    __asm__ __volatile__ ("   la    0,0\n"
>     "0: mvst  %0,%1\n"
>     "   jo    0b"
>     : "+&a" (__dest), "+&a" (__src) :
>     : "cc", "memory", "0" );
>    return tmp;
>}
>
>
>
>
>
>
>extern __inline char *__strncpy_g (char *, const char *, size_t)
>     __asm__ ("strncpy");
>
>extern __inline char *
>__strncpy_g (char *__dest, const char *__src, size_t __n)
>{
>    char *__ret = __dest;
>    char *__ptr;
>    size_t __diff;
>
>    if (__n > 0) {
>      __diff = (size_t) (__dest - __src);
>      __ptr = (char *) __src;
>      __asm__ __volatile__ ("   j     1f\n"
>       "0: la    %0,1(%0)\n"
>       "1: icm   0,1,0(%0)\n"
>       "   stc   0,0(%2,%0)\n"
>       "   jz    3f\n"
>
>       "   brctg %1,0b\n"
>
>
>
>       "   j     4f\n"
>       "2: la    %0,1(%0)\n"
>       "   stc   0,0(%2,%0)\n"
>
>       "3: brctg %1,2b\n"
>
>
>
>       "4:"
>       : "+&a" (__ptr), "+&a" (__n) : "a" (__diff)
>       : "cc", "memory", "0" );
>    }
>    return __ret;
>}
>
>
>
>
>
>
>
>extern __inline char *__strcat_g (char *, const char *) __asm__ ("strcat");
>
>extern __inline char *
>__strcat_g (char *__dest, const char *__src)
>{
>    char *__ret = __dest;
>    char *__ptr, *__tmp;
>
>
>    __ptr = (char *) 0;
>    __tmp = __dest;
>    __asm__ __volatile__ ("   la    0,0\n"
>     "0: srst  %0,%1\n"
>     "   jo    0b\n"
>     : "+&a" (__ptr), "+&a" (__tmp) :
>     : "cc", "0" );
>
>
>    __asm__ __volatile__ ("   la    0,0\n"
>     "0: mvst  %0,%1\n"
>     "   jo    0b"
>     : "+&a" (__ptr), "+&a" (__src) :
>     : "cc", "memory", "0" );
>    return __ret;
>}
>
>
>
>
>
>
>
>extern __inline char *__strncat_g (char *, const char *, size_t)
>     __asm__ ("strncat");
>
>extern __inline char *
>__strncat_g (char *__dest, const char *__src, size_t __n)
>{
>    char *__ret = __dest;
>    char *__ptr, *__tmp;
>    size_t __diff;
>
>    if (__n > 0) {
>
>      __ptr = (char *) 0;
>      __tmp = __dest;
>      __asm__ __volatile__ ("   la    0,0\n"
>       "0: srst  %0,%1\n"
>     "   jo    0b\n"
>       : "+&a" (__ptr), "+&a" (__tmp) :
>       : "cc", "memory", "0" );
>
>      __diff = (size_t) (__ptr - __src);
>      __tmp = (char *) __src;
>      __asm__ __volatile__ ("   j     1f\n"
>       "0: la    %0,1(%0)\n"
>       "1: icm   0,1,0(%0)\n"
>       "   stc   0,0(%2,%0)\n"
>       "   jz    2f\n"
>
>       "   brctg %1,0b\n"
>
>
>
>       "   slr   0,0\n"
>       "   stc   0,1(%2,%0)\n"
>       "2:"
>       : "+&a" (__tmp), "+&a" (__n) : "a" (__diff)
>       : "cc", "memory", "0" );
>
>    }
>    return __ret;
>}
>
>
>
>
>
>extern __inline void *
>memchr (const void *__str, int __c, size_t __n)
>{
>    char *__ptr, *__tmp;
>
>    __tmp = (char *) __str;
>    __ptr = (char *) __tmp + __n;
>    __asm__ __volatile__ ("   lhi   0,0xff\n"
>     "   nr    0,%2\n"
>     "0: srst  %0,%1\n"
>     "   jo    0b\n"
>     "   brc   13,1f\n"
>     "   la    %0,0\n"
>     "1:"
>     : "+&a" (__ptr), "+&a" (__tmp) : "d" (__c)
>     : "cc", "memory", "0" );
>    return __ptr;
>}
>
>
>
>
>
>extern __inline int
>strcmp (const char *__s1, const char *__s2)
>{
>    char *__p1, *__p2;
>    int __ret;
>
>    __p1 = (char *) __s1;
>    __p2 = (char *) __s2;
>    __asm__ __volatile__ ("   slr   0,0\n"
>     "0: clst  %1,%2\n"
>     "   jo    0b\n"
>     "   ipm   %0\n"
>     "   srl   %0,28"
>     : "=d" (__ret), "+&a" (__p1), "+&a" (__p2) :
>     : "cc", "memory", "0" );
>    __ret = (__ret == 0) ? 0 : (__ret == 1) ? -1 : 1;
>    return __ret;
>}
># 632 "/usr/include/string.h" 2 3 4
>
>
># 1 "/usr/include/bits/string2.h" 1 3 4
># 51 "/usr/include/bits/string2.h" 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 36 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/endian.h" 1 3 4
># 37 "/usr/include/endian.h" 2 3 4
># 60 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 24 "/usr/include/bits/byteswap.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/byteswap.h" 2 3 4
># 33 "/usr/include/bits/byteswap.h" 3 4
># 1 "/usr/include/bits/byteswap-16.h" 1 3 4
># 24 "/usr/include/bits/byteswap-16.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/byteswap-16.h" 2 3 4
># 34 "/usr/include/bits/byteswap.h" 2 3 4
># 61 "/usr/include/endian.h" 2 3 4
># 52 "/usr/include/bits/string2.h" 2 3 4
># 393 "/usr/include/bits/string2.h" 3 4
>extern void *__rawmemchr (const void *__s, int __c);
># 945 "/usr/include/bits/string2.h" 3 4
>extern __inline size_t __strcspn_c1 (const char *__s, int __reject);
>extern __inline size_t
>__strcspn_c1 (const char *__s, int __reject)
>{
>  size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strcspn_c2 (const char *__s, int __reject1,
>         int __reject2);
>extern __inline size_t
>__strcspn_c2 (const char *__s, int __reject1, int __reject2)
>{
>  size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject1
>  && __s[__result] != __reject2)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strcspn_c3 (const char *__s, int __reject1,
>         int __reject2, int __reject3);
>extern __inline size_t
>__strcspn_c3 (const char *__s, int __reject1, int __reject2,
>       int __reject3)
>{
>  size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject1
>  && __s[__result] != __reject2 && __s[__result] != __reject3)
>    ++__result;
>  return __result;
>}
># 1021 "/usr/include/bits/string2.h" 3 4
>extern __inline size_t __strspn_c1 (const char *__s, int __accept);
>extern __inline size_t
>__strspn_c1 (const char *__s, int __accept)
>{
>  size_t __result = 0;
>
>  while (__s[__result] == __accept)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strspn_c2 (const char *__s, int __accept1,
>        int __accept2);
>extern __inline size_t
>__strspn_c2 (const char *__s, int __accept1, int __accept2)
>{
>  size_t __result = 0;
>
>  while (__s[__result] == __accept1 || __s[__result] == __accept2)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strspn_c3 (const char *__s, int __accept1,
>        int __accept2, int __accept3);
>extern __inline size_t
>__strspn_c3 (const char *__s, int __accept1, int __accept2, int __accept3)
>{
>  size_t __result = 0;
>
>  while (__s[__result] == __accept1 || __s[__result] == __accept2
>  || __s[__result] == __accept3)
>    ++__result;
>  return __result;
>}
># 1097 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strpbrk_c2 (const char *__s, int __accept1,
>        int __accept2);
>extern __inline char *
>__strpbrk_c2 (const char *__s, int __accept1, int __accept2)
>{
>
>  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
>    ++__s;
>  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
>}
>
>extern __inline char *__strpbrk_c3 (const char *__s, int __accept1,
>        int __accept2, int __accept3);
>extern __inline char *
>__strpbrk_c3 (const char *__s, int __accept1, int __accept2, int __accept3)
>{
>
>  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
>  && *__s != __accept3)
>    ++__s;
>  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
>}
># 1147 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
>extern __inline char *
>__strtok_r_1c (char *__s, char __sep, char **__nextp)
>{
>  char *__result;
>  if (__s == ((void *)0))
>    __s = *__nextp;
>  while (*__s == __sep)
>    ++__s;
>  __result = ((void *)0);
>  if (*__s != '\0')
>    {
>      __result = __s++;
>      while (*__s != '\0')
> if (*__s++ == __sep)
>   {
>     __s[-1] = '\0';
>     break;
>   }
>    }
>  *__nextp = __s;
>  return __result;
>}
># 1179 "/usr/include/bits/string2.h" 3 4
>extern char *__strsep_g (char **__stringp, const char *__delim);
># 1197 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strsep_1c (char **__s, char __reject);
>extern __inline char *
>__strsep_1c (char **__s, char __reject)
>{
>  char *__retval = *__s;
>  if (__retval != ((void *)0) && (*__s = (__extension__ (__builtin_constant_p (__reject) && !__builtin_constant_p (__retval) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : __builtin_strchr (__retval, __reject)))) != ((void *)0))
>    *(*__s)++ = '\0';
>  return __retval;
>}
>
>extern __inline char *__strsep_2c (char **__s, char __reject1, char __reject2);
>extern __inline char *
>__strsep_2c (char **__s, char __reject1, char __reject2)
>{
>  char *__retval = *__s;
>  if (__retval != ((void *)0))
>    {
>      char *__cp = __retval;
>      while (1)
> {
>   if (*__cp == '\0')
>     {
>       __cp = ((void *)0);
>   break;
>     }
>   if (*__cp == __reject1 || *__cp == __reject2)
>     {
>       *__cp++ = '\0';
>       break;
>     }
>   ++__cp;
> }
>      *__s = __cp;
>    }
>  return __retval;
>}
>
>extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
>       char __reject3);
>extern __inline char *
>__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
>{
>  char *__retval = *__s;
>  if (__retval != ((void *)0))
>    {
>      char *__cp = __retval;
>      while (1)
> {
>   if (*__cp == '\0')
>     {
>       __cp = ((void *)0);
>   break;
>     }
>   if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
>     {
>       *__cp++ = '\0';
>       break;
>     }
>   ++__cp;
> }
>      *__s = __cp;
>    }
>  return __retval;
>}
># 1273 "/usr/include/bits/string2.h" 3 4
># 1 "/usr/include/stdlib.h" 1 3 4
># 32 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 33 "/usr/include/stdlib.h" 2 3 4
>
>
># 464 "/usr/include/stdlib.h" 3 4
>
>
>extern void *malloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>extern void *calloc (size_t __nmemb, size_t __size)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
># 967 "/usr/include/stdlib.h" 3 4
>
># 1274 "/usr/include/bits/string2.h" 2 3 4
>
>
>
>
>extern char *__strdup (const char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__));
># 1297 "/usr/include/bits/string2.h" 3 4
>extern char *__strndup (const char *__string, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__));
># 635 "/usr/include/string.h" 2 3 4
>
>
>
>
># 1 "/usr/include/bits/string3.h" 1 3 4
># 22 "/usr/include/bits/string3.h" 3 4
>extern void __warn_memset_zero_len (void) __attribute__((__warning__ ("memset used with constant zero length parameter; this could be due to transposed parameters")))
>                                                                                                   ;
># 47 "/usr/include/bits/string3.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__nothrow__ , __leaf__)) memcpy (void *__restrict __dest, const void *__restrict __src, size_t __len)
>
>{
>  return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__nothrow__ , __leaf__)) memmove (void *__dest, const void *__src, size_t __len)
>{
>  return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__nothrow__ , __leaf__)) mempcpy (void *__restrict __dest, const void *__restrict __src, size_t __len)
>
>{
>  return __builtin___mempcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
># 75 "/usr/include/bits/string3.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__nothrow__ , __leaf__)) memset (void *__dest, int __ch, size_t __len)
>{
>  if (__builtin_constant_p (__len) && __len == 0
>      && (!__builtin_constant_p (__ch) || __ch != 0))
>    {
>      __warn_memset_zero_len ();
>      return __dest;
>    }
>  return __builtin___memset_chk (__dest, __ch, __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void
>__attribute__ ((__nothrow__ , __leaf__)) bcopy (const void *__src, void *__dest, size_t __len)
>{
>  (void) __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void
>__attribute__ ((__nothrow__ , __leaf__)) bzero (void *__dest, size_t __len)
>{
>  (void) __builtin___memset_chk (__dest, '\0', __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) strcpy (char *__restrict __dest, const char *__restrict __src)
>{
>  return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) stpcpy (char *__restrict __dest, const char *__restrict __src)
>{
>  return __builtin___stpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) strncpy (char *__restrict __dest, const char *__restrict __src, size_t __len)
>
>{
>  return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern char *__stpncpy_chk (char *__dest, const char *__src, size_t __n,
>       size_t __destlen) __attribute__ ((__nothrow__ , __leaf__));
>extern char *__stpncpy_alias (char *__dest, const char *__src, size_t __n) __asm__ ("" "stpncpy") __attribute__ ((__nothrow__ , __leaf__))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) stpncpy (char *__dest, const char *__src, size_t __n)
>{
>  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
>      && (!__builtin_constant_p (__n) || __n <= __builtin_object_size (__dest, 2 > 1)))
>    return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
>  return __stpncpy_alias (__dest, __src, __n);
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) strcat (char *__restrict __dest, const char *__restrict __src)
>{
>  return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) strncat (char *__restrict __dest, const char *__restrict __src, size_t __len)
>
>{
>  return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
>}
># 640 "/usr/include/string.h" 2 3 4
>
>
>
>
># 22 "method-to-ir.c" 2
># 1 "/usr/include/ctype.h" 1 3 4
># 28 "/usr/include/ctype.h" 3 4
>
># 46 "/usr/include/ctype.h" 3 4
>enum
>{
>  _ISupper = (1 << (0)),
>  _ISlower = (1 << (1)),
>  _ISalpha = (1 << (2)),
>  _ISdigit = (1 << (3)),
>  _ISxdigit = (1 << (4)),
>  _ISspace = (1 << (5)),
>  _ISprint = (1 << (6)),
>  _ISgraph = (1 << (7)),
>  _ISblank = (1 << (8)),
>  _IScntrl = (1 << (9)),
>  _ISpunct = (1 << (10)),
>  _ISalnum = (1 << (11))
>};
># 79 "/usr/include/ctype.h" 3 4
>extern const unsigned short int **__ctype_b_loc (void)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>extern const __int32_t **__ctype_tolower_loc (void)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>extern const __int32_t **__ctype_toupper_loc (void)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
># 104 "/usr/include/ctype.h" 3 4
>
>
>
>
>
>
>extern int isalnum (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isalpha (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int iscntrl (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isdigit (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int islower (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isgraph (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isprint (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int ispunct (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isspace (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isupper (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isxdigit (int) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int tolower (int __c) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int toupper (int __c) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int isblank (int) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int isctype (int __c, int __mask) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int isascii (int __c) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int toascii (int __c) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int _toupper (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int _tolower (int) __attribute__ ((__nothrow__ , __leaf__));
># 214 "/usr/include/ctype.h" 3 4
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) tolower (int __c)
>{
>  return __c >= -128 && __c < 256 ? (*__ctype_tolower_loc ())[__c] : __c;
>}
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) toupper (int __c)
>{
>  return __c >= -128 && __c < 256 ? (*__ctype_toupper_loc ())[__c] : __c;
>}
># 271 "/usr/include/ctype.h" 3 4
>extern int isalnum_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isalpha_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int iscntrl_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isdigit_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int islower_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isgraph_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isprint_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int ispunct_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isspace_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isupper_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isxdigit_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int isblank_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int __tolower_l (int __c, __locale_t __l) __attribute__ ((__nothrow__ , __leaf__));
>extern int tolower_l (int __c, __locale_t __l) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int __toupper_l (int __c, __locale_t __l) __attribute__ ((__nothrow__ , __leaf__));
>extern int toupper_l (int __c, __locale_t __l) __attribute__ ((__nothrow__ , __leaf__));
># 347 "/usr/include/ctype.h" 3 4
>
># 23 "method-to-ir.c" 2
>
>
># 1 "/usr/include/sys/time.h" 1 3 4
># 25 "/usr/include/sys/time.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 73 "/usr/include/time.h" 3 4
>
>
>typedef __time_t time_t;
>
>
>
># 26 "/usr/include/sys/time.h" 2 3 4
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 30 "/usr/include/bits/time.h" 3 4
>struct timeval
>  {
>    __time_t tv_sec;
>    __suseconds_t tv_usec;
>  };
># 28 "/usr/include/sys/time.h" 2 3 4
>
># 1 "/usr/include/sys/select.h" 1 3 4
># 30 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/select.h" 1 3 4
># 31 "/usr/include/sys/select.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 34 "/usr/include/sys/select.h" 2 3 4
># 43 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 44 "/usr/include/sys/select.h" 2 3 4
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 46 "/usr/include/sys/select.h" 2 3 4
>
>
>typedef __suseconds_t suseconds_t;
>
>
>
>
>
>typedef long int __fd_mask;
># 64 "/usr/include/sys/select.h" 3 4
>typedef struct
>  {
>
>
>
>    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
>
>
>
>
>
>  } fd_set;
>
>
>
>
>
>
>typedef __fd_mask fd_mask;
># 96 "/usr/include/sys/select.h" 3 4
>
># 106 "/usr/include/sys/select.h" 3 4
>extern int select (int __nfds, fd_set *__restrict __readfds,
>     fd_set *__restrict __writefds,
>     fd_set *__restrict __exceptfds,
>     struct timeval *__restrict __timeout);
># 118 "/usr/include/sys/select.h" 3 4
>extern int pselect (int __nfds, fd_set *__restrict __readfds,
>      fd_set *__restrict __writefds,
>      fd_set *__restrict __exceptfds,
>      const struct timespec *__restrict __timeout,
>      const __sigset_t *__restrict __sigmask);
>
>
>
>
>
># 1 "/usr/include/bits/select2.h" 1 3 4
># 24 "/usr/include/bits/select2.h" 3 4
>extern long int __fdelt_chk (long int __d);
>extern long int __fdelt_warn (long int __d)
>  __attribute__((__warning__ ("bit outside of fd_set selected")));
># 129 "/usr/include/sys/select.h" 2 3 4
>
>
>
># 30 "/usr/include/sys/time.h" 2 3 4
>
>
>
>
>
>
>
>
># 55 "/usr/include/sys/time.h" 3 4
>struct timezone
>  {
>    int tz_minuteswest;
>    int tz_dsttime;
>  };
>
>typedef struct timezone *__restrict __timezone_ptr_t;
># 71 "/usr/include/sys/time.h" 3 4
>extern int gettimeofday (struct timeval *__restrict __tv,
>    __timezone_ptr_t __tz) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int settimeofday (const struct timeval *__tv,
>    const struct timezone *__tz)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int adjtime (const struct timeval *__delta,
>      struct timeval *__olddelta) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>enum __itimer_which
>  {
>
>    ITIMER_REAL = 0,
>
>
>    ITIMER_VIRTUAL = 1,
>
>
>
>    ITIMER_PROF = 2
>
>  };
>
>
>
>struct itimerval
>  {
>
>    struct timeval it_interval;
>
>    struct timeval it_value;
>  };
>
>
>
>
>typedef enum __itimer_which __itimer_which_t;
>
>
>
>
>
>
>extern int getitimer (__itimer_which_t __which,
>        struct itimerval *__value) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int setitimer (__itimer_which_t __which,
>        const struct itimerval *__restrict __new,
>        struct itimerval *__restrict __old) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int utimes (const char *__file, const struct timeval __tvp[2])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int lutimes (const char *__file, const struct timeval __tvp[2])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int futimes (int __fd, const struct timeval __tvp[2]) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int futimesat (int __fd, const char *__file,
>        const struct timeval __tvp[2]) __attribute__ ((__nothrow__ , __leaf__));
># 189 "/usr/include/sys/time.h" 3 4
>
># 26 "method-to-ir.c" 2
>
>
>
># 1 "/usr/include/alloca.h" 1 3 4
># 24 "/usr/include/alloca.h" 3 4
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 25 "/usr/include/alloca.h" 2 3 4
>
>
>
>
>
>
>
>extern void *alloca (size_t __size) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
># 30 "method-to-ir.c" 2
>
>
># 1 "../../mono/utils/memcheck.h" 1
># 73 "../../mono/utils/memcheck.h"
># 1 "../../mono/utils/valgrind.h" 1
># 78 "../../mono/utils/valgrind.h"
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stdarg.h" 1 3 4
># 40 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 98 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stdarg.h" 3 4
>typedef __gnuc_va_list va_list;
># 79 "../../mono/utils/valgrind.h" 2
># 3610 "../../mono/utils/valgrind.h"
>typedef
>   enum { VG_USERREQ__RUNNING_ON_VALGRIND = 0x1001,
>          VG_USERREQ__DISCARD_TRANSLATIONS = 0x1002,
>
>
>
>
>
>
>          VG_USERREQ__CLIENT_CALL0 = 0x1101,
>          VG_USERREQ__CLIENT_CALL1 = 0x1102,
>          VG_USERREQ__CLIENT_CALL2 = 0x1103,
>          VG_USERREQ__CLIENT_CALL3 = 0x1104,
>
>
>
>
>          VG_USERREQ__COUNT_ERRORS = 0x1201,
>
>
>
>          VG_USERREQ__MALLOCLIKE_BLOCK = 0x1301,
>          VG_USERREQ__FREELIKE_BLOCK = 0x1302,
>
>          VG_USERREQ__CREATE_MEMPOOL = 0x1303,
>          VG_USERREQ__DESTROY_MEMPOOL = 0x1304,
>          VG_USERREQ__MEMPOOL_ALLOC = 0x1305,
>          VG_USERREQ__MEMPOOL_FREE = 0x1306,
>          VG_USERREQ__MEMPOOL_TRIM = 0x1307,
>          VG_USERREQ__MOVE_MEMPOOL = 0x1308,
>          VG_USERREQ__MEMPOOL_CHANGE = 0x1309,
>          VG_USERREQ__MEMPOOL_EXISTS = 0x130a,
>
>
>          VG_USERREQ__PRINTF = 0x1401,
>          VG_USERREQ__PRINTF_BACKTRACE = 0x1402,
>
>
>          VG_USERREQ__STACK_REGISTER = 0x1501,
>          VG_USERREQ__STACK_DEREGISTER = 0x1502,
>          VG_USERREQ__STACK_CHANGE = 0x1503,
>
>
>          VG_USERREQ__LOAD_PDB_DEBUGINFO = 0x1601
>   } Vg_ClientRequest;
># 74 "../../mono/utils/memcheck.h" 2
>
>
>
>
>
>typedef
>   enum {
>      VG_USERREQ__MAKE_MEM_NOACCESS = ((unsigned int)((('M')&0xff) << 24 | (('C')&0xff) << 16)),
>      VG_USERREQ__MAKE_MEM_UNDEFINED,
>      VG_USERREQ__MAKE_MEM_DEFINED,
>      VG_USERREQ__DISCARD,
>      VG_USERREQ__CHECK_MEM_IS_ADDRESSABLE,
>      VG_USERREQ__CHECK_MEM_IS_DEFINED,
>      VG_USERREQ__DO_LEAK_CHECK,
>      VG_USERREQ__COUNT_LEAKS,
>
>      VG_USERREQ__GET_VBITS,
>      VG_USERREQ__SET_VBITS,
>
>      VG_USERREQ__CREATE_BLOCK,
>
>      VG_USERREQ__MAKE_MEM_DEFINED_IF_ADDRESSABLE,
>
>
>      VG_USERREQ__COUNT_LEAK_BLOCKS,
>
>
>      _VG_USERREQ__MEMCHECK_RECORD_OVERLAP_ERROR
>         = ((unsigned int)((('M')&0xff) << 24 | (('C')&0xff) << 16)) + 256
>   } Vg_MemCheckClientRequest;
># 33 "method-to-ir.c" 2
>
># 1 "../../mono/metadata/assembly.h" 1
>
>
>
># 1 "../../mono/metadata/image.h" 1
>
>
>
># 1 "/usr/include/stdio.h" 1 3 4
># 29 "/usr/include/stdio.h" 3 4
>
>
>
>
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 34 "/usr/include/stdio.h" 2 3 4
># 44 "/usr/include/stdio.h" 3 4
>struct _IO_FILE;
>
>
>
>typedef struct _IO_FILE FILE;
>
>
>
>
>
># 64 "/usr/include/stdio.h" 3 4
>typedef struct _IO_FILE __FILE;
># 74 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/libio.h" 1 3 4
># 31 "/usr/include/libio.h" 3 4
># 1 "/usr/include/_G_config.h" 1 3 4
># 15 "/usr/include/_G_config.h" 3 4
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 16 "/usr/include/_G_config.h" 2 3 4
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 82 "/usr/include/wchar.h" 3 4
>typedef struct
>{
>  int __count;
>  union
>  {
>
>    unsigned int __wch;
>
>
>
>    char __wchb[4];
>  } __value;
>} __mbstate_t;
># 21 "/usr/include/_G_config.h" 2 3 4
>typedef struct
>{
>  __off_t __pos;
>  __mbstate_t __state;
>} _G_fpos_t;
>typedef struct
>{
>  __off64_t __pos;
>  __mbstate_t __state;
>} _G_fpos64_t;
># 32 "/usr/include/libio.h" 2 3 4
># 144 "/usr/include/libio.h" 3 4
>struct _IO_jump_t; struct _IO_FILE;
># 154 "/usr/include/libio.h" 3 4
>typedef void _IO_lock_t;
>
>
>
>
>
>struct _IO_marker {
>  struct _IO_marker *_next;
>  struct _IO_FILE *_sbuf;
>
>
>
>  int _pos;
># 177 "/usr/include/libio.h" 3 4
>};
>
>
>enum __codecvt_result
>{
>  __codecvt_ok,
>  __codecvt_partial,
>  __codecvt_error,
>  __codecvt_noconv
>};
># 245 "/usr/include/libio.h" 3 4
>struct _IO_FILE {
>  int _flags;
>
>
>
>
>  char* _IO_read_ptr;
>  char* _IO_read_end;
>  char* _IO_read_base;
>  char* _IO_write_base;
>  char* _IO_write_ptr;
>  char* _IO_write_end;
>  char* _IO_buf_base;
>  char* _IO_buf_end;
>
>  char *_IO_save_base;
>  char *_IO_backup_base;
>  char *_IO_save_end;
>
>  struct _IO_marker *_markers;
>
>  struct _IO_FILE *_chain;
>
>  int _fileno;
>
>
>
>  int _flags2;
>
>  __off_t _old_offset;
>
>
>
>  unsigned short _cur_column;
>  signed char _vtable_offset;
>  char _shortbuf[1];
>
>
>
>  _IO_lock_t *_lock;
># 293 "/usr/include/libio.h" 3 4
>  __off64_t _offset;
># 302 "/usr/include/libio.h" 3 4
>  void *__pad1;
>  void *__pad2;
>  void *__pad3;
>  void *__pad4;
>  size_t __pad5;
>
>  int _mode;
>
>  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
>
>};
>
>
>typedef struct _IO_FILE _IO_FILE;
>
>
>struct _IO_FILE_plus;
>
>extern struct _IO_FILE_plus _IO_2_1_stdin_;
>extern struct _IO_FILE_plus _IO_2_1_stdout_;
>extern struct _IO_FILE_plus _IO_2_1_stderr_;
># 338 "/usr/include/libio.h" 3 4
>typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
>
>
>
>
>
>
>
>typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
>     size_t __n);
>
>
>
>
>
>
>
>typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
>
>
>typedef int __io_close_fn (void *__cookie);
>
>
>
>
>typedef __io_read_fn cookie_read_function_t;
>typedef __io_write_fn cookie_write_function_t;
>typedef __io_seek_fn cookie_seek_function_t;
>typedef __io_close_fn cookie_close_function_t;
>
>
>typedef struct
>{
>  __io_read_fn *read;
>  __io_write_fn *write;
>  __io_seek_fn *seek;
>  __io_close_fn *close;
>} _IO_cookie_io_functions_t;
>typedef _IO_cookie_io_functions_t cookie_io_functions_t;
>
>struct _IO_cookie_file;
>
>
>extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
>        void *__cookie, _IO_cookie_io_functions_t __fns);
>
>
>
>
>
>
>
>extern int __underflow (_IO_FILE *);
>extern int __uflow (_IO_FILE *);
>extern int __overflow (_IO_FILE *, int);
># 434 "/usr/include/libio.h" 3 4
>extern int _IO_getc (_IO_FILE *__fp);
>extern int _IO_putc (int __c, _IO_FILE *__fp);
>extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__ , __leaf__));
>extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int _IO_peekc_locked (_IO_FILE *__fp);
>
>
>
>
>
>extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));
>extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));
>extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));
># 464 "/usr/include/libio.h" 3 4
>extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
>   __gnuc_va_list, int *__restrict);
>extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
>    __gnuc_va_list);
>extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
>extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
>
>extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
>extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
>
>extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));
># 75 "/usr/include/stdio.h" 2 3 4
># 108 "/usr/include/stdio.h" 3 4
>
>
>typedef _G_fpos_t fpos_t;
>
>
>
>
>
>typedef _G_fpos64_t fpos64_t;
># 164 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 165 "/usr/include/stdio.h" 2 3 4
>
>
>
>extern struct _IO_FILE *stdin;
>extern struct _IO_FILE *stdout;
>extern struct _IO_FILE *stderr;
>
>
>
>
>
>
>
>extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int renameat (int __oldfd, const char *__old, int __newfd,
>       const char *__new) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern FILE *tmpfile (void) __attribute__ ((__warn_unused_result__));
># 205 "/usr/include/stdio.h" 3 4
>extern FILE *tmpfile64 (void) __attribute__ ((__warn_unused_result__));
>
>
>
>extern char *tmpnam (char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 227 "/usr/include/stdio.h" 3 4
>extern char *tempnam (const char *__dir, const char *__pfx)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>extern int fclose (FILE *__stream);
>
>
>
>
>extern int fflush (FILE *__stream);
>
># 252 "/usr/include/stdio.h" 3 4
>extern int fflush_unlocked (FILE *__stream);
># 262 "/usr/include/stdio.h" 3 4
>extern int fcloseall (void);
>
>
>
>
>
>
>
>
>
>extern FILE *fopen (const char *__restrict __filename,
>      const char *__restrict __modes) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern FILE *freopen (const char *__restrict __filename,
>        const char *__restrict __modes,
>        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
># 295 "/usr/include/stdio.h" 3 4
>
>
>extern FILE *fopen64 (const char *__restrict __filename,
>        const char *__restrict __modes) __attribute__ ((__warn_unused_result__));
>extern FILE *freopen64 (const char *__restrict __filename,
>   const char *__restrict __modes,
>   FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern FILE *fopencookie (void *__restrict __magic_cookie,
>     const char *__restrict __modes,
>     _IO_cookie_io_functions_t __io_funcs) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
>  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
>      int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
>         size_t __size) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int fprintf (FILE *__restrict __stream,
>      const char *__restrict __format, ...);
>
>
>
>
>extern int printf (const char *__restrict __format, ...);
>
>extern int sprintf (char *__restrict __s,
>      const char *__restrict __format, ...) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
>       __gnuc_va_list __arg);
>
>
>
>
>extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
>
>extern int vsprintf (char *__restrict __s, const char *__restrict __format,
>       __gnuc_va_list __arg) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int snprintf (char *__restrict __s, size_t __maxlen,
>       const char *__restrict __format, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
>
>extern int vsnprintf (char *__restrict __s, size_t __maxlen,
>        const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>
>
>
>
>extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
>        __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0))) __attribute__ ((__warn_unused_result__));
>extern int __asprintf (char **__restrict __ptr,
>         const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
>extern int asprintf (char **__restrict __ptr,
>       const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int vdprintf (int __fd, const char *__restrict __fmt,
>       __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__printf__, 2, 0)));
>extern int dprintf (int __fd, const char *__restrict __fmt, ...)
>     __attribute__ ((__format__ (__printf__, 2, 3)));
>
>
>
>
>
>
>
>
>extern int fscanf (FILE *__restrict __stream,
>     const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int scanf (const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));
>
>extern int sscanf (const char *__restrict __s,
>     const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
># 463 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
>      __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn_unused_result__));
>
>
>extern int vsscanf (const char *__restrict __s,
>      const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
># 522 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>
>extern int fgetc (FILE *__stream);
>extern int getc (FILE *__stream);
>
>
>
>
>
>extern int getchar (void);
>
># 550 "/usr/include/stdio.h" 3 4
>extern int getc_unlocked (FILE *__stream);
>extern int getchar_unlocked (void);
># 561 "/usr/include/stdio.h" 3 4
>extern int fgetc_unlocked (FILE *__stream);
>
>
>
>
>
>
>
>
>
>
>
>extern int fputc (int __c, FILE *__stream);
>extern int putc (int __c, FILE *__stream);
>
>
>
>
>
>extern int putchar (int __c);
>
># 594 "/usr/include/stdio.h" 3 4
>extern int fputc_unlocked (int __c, FILE *__stream);
>
>
>
>
>
>
>
>extern int putc_unlocked (int __c, FILE *__stream);
>extern int putchar_unlocked (int __c);
>
>
>
>
>
>
>extern int getw (FILE *__stream);
>
>
>extern int putw (int __w, FILE *__stream);
>
>
>
>
>
>
>
>
>extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
>     __attribute__ ((__warn_unused_result__));
># 640 "/usr/include/stdio.h" 3 4
>
># 649 "/usr/include/stdio.h" 3 4
>extern char *fgets_unlocked (char *__restrict __s, int __n,
>        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
># 665 "/usr/include/stdio.h" 3 4
>extern __ssize_t __getdelim (char **__restrict __lineptr,
>          size_t *__restrict __n, int __delimiter,
>          FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern __ssize_t getdelim (char **__restrict __lineptr,
>        size_t *__restrict __n, int __delimiter,
>        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern __ssize_t getline (char **__restrict __lineptr,
>       size_t *__restrict __n,
>       FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
>
>
>
>
>
>extern int puts (const char *__s);
>
>
>
>
>
>
>extern int ungetc (int __c, FILE *__stream);
>
>
>
>
>
>
>extern size_t fread (void *__restrict __ptr, size_t __size,
>       size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern size_t fwrite (const void *__restrict __ptr, size_t __size,
>        size_t __n, FILE *__restrict __s);
>
># 726 "/usr/include/stdio.h" 3 4
>extern int fputs_unlocked (const char *__restrict __s,
>      FILE *__restrict __stream);
># 737 "/usr/include/stdio.h" 3 4
>extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
>         size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
>          size_t __n, FILE *__restrict __stream);
>
>
>
>
>
>
>
>
>extern int fseek (FILE *__stream, long int __off, int __whence);
>
>
>
>
>extern long int ftell (FILE *__stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void rewind (FILE *__stream);
>
># 773 "/usr/include/stdio.h" 3 4
>extern int fseeko (FILE *__stream, __off_t __off, int __whence);
>
>
>
>
>extern __off_t ftello (FILE *__stream) __attribute__ ((__warn_unused_result__));
># 792 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
>
>
>
>
>extern int fsetpos (FILE *__stream, const fpos_t *__pos);
># 815 "/usr/include/stdio.h" 3 4
>
>
>
>extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
>extern __off64_t ftello64 (FILE *__stream) __attribute__ ((__warn_unused_result__));
>extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
>extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
>
>
>
>
>extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
>extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>extern void perror (const char *__s);
>
>
>
>
>
>
># 1 "/usr/include/bits/sys_errlist.h" 1 3 4
># 26 "/usr/include/bits/sys_errlist.h" 3 4
>extern int sys_nerr;
>extern const char *const sys_errlist[];
>
>
>extern int _sys_nerr;
>extern const char *const _sys_errlist[];
># 854 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 872 "/usr/include/stdio.h" 3 4
>extern FILE *popen (const char *__command, const char *__modes) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int pclose (FILE *__stream);
>
>
>
>
>
>extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *cuserid (char *__s);
>
>
>
>
>struct obstack;
>
>
>extern int obstack_printf (struct obstack *__restrict __obstack,
>      const char *__restrict __format, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3)));
>extern int obstack_vprintf (struct obstack *__restrict __obstack,
>       const char *__restrict __format,
>       __gnuc_va_list __args)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0)));
>
>
>
>
>
>
>
>extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
># 933 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio.h" 1 3 4
># 43 "/usr/include/bits/stdio.h" 3 4
>extern __inline int
>getchar (void)
>{
>  return _IO_getc (stdin);
>}
>
>
>
>
>extern __inline int
>fgetc_unlocked (FILE *__fp)
>{
>  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>
>
>
>extern __inline int
>getc_unlocked (FILE *__fp)
>{
>  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>extern __inline int
>getchar_unlocked (void)
>{
>  return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
>}
>
>
>
>
>extern __inline int
>putchar (int __c)
>{
>  return _IO_putc (__c, stdout);
>}
>
>
>
>
>extern __inline int
>fputc_unlocked (int __c, FILE *__stream)
>{
>  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline int
>putc_unlocked (int __c, FILE *__stream)
>{
>  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>extern __inline int
>putchar_unlocked (int __c)
>{
>  return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline __ssize_t
>getline (char **__lineptr, size_t *__n, FILE *__stream)
>{
>  return __getdelim (__lineptr, __n, '\n', __stream);
>}
>
>
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) feof_unlocked (FILE *__stream)
>{
>  return (((__stream)->_flags & 0x10) != 0);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) ferror_unlocked (FILE *__stream)
>{
>  return (((__stream)->_flags & 0x20) != 0);
>}
># 934 "/usr/include/stdio.h" 2 3 4
>
>
># 1 "/usr/include/bits/stdio2.h" 1 3 4
># 23 "/usr/include/bits/stdio2.h" 3 4
>extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen,
>     const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
>extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen,
>      const char *__restrict __format,
>      __gnuc_va_list __ap) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) sprintf (char *__restrict __s, const char *__restrict __fmt, ...)
>{
>  return __builtin___sprintf_chk (__s, 2 - 1,
>      __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
>}
>
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) vsprintf (char *__restrict __s, const char *__restrict __fmt, __gnuc_va_list __ap)
>
>{
>  return __builtin___vsprintf_chk (__s, 2 - 1,
>       __builtin_object_size (__s, 2 > 1), __fmt, __ap);
>}
>
>
>
>extern int __snprintf_chk (char *__restrict __s, size_t __n, int __flag,
>      size_t __slen, const char *__restrict __format,
>      ...) __attribute__ ((__nothrow__ , __leaf__));
>extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag,
>       size_t __slen, const char *__restrict __format,
>       __gnuc_va_list __ap) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) snprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, ...)
>
>{
>  return __builtin___snprintf_chk (__s, __n, 2 - 1,
>       __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
>}
>
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) vsnprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, __gnuc_va_list __ap)
>
>{
>  return __builtin___vsnprintf_chk (__s, __n, 2 - 1,
>        __builtin_object_size (__s, 2 > 1), __fmt, __ap);
>}
>
>
>
>
>
>extern int __fprintf_chk (FILE *__restrict __stream, int __flag,
>     const char *__restrict __format, ...);
>extern int __printf_chk (int __flag, const char *__restrict __format, ...);
>extern int __vfprintf_chk (FILE *__restrict __stream, int __flag,
>      const char *__restrict __format, __gnuc_va_list __ap);
>extern int __vprintf_chk (int __flag, const char *__restrict __format,
>     __gnuc_va_list __ap);
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>fprintf (FILE *__restrict __stream, const char *__restrict __fmt, ...)
>{
>  return __fprintf_chk (__stream, 2 - 1, __fmt,
>   __builtin_va_arg_pack ());
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>printf (const char *__restrict __fmt, ...)
>{
>  return __printf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
>}
>
>
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>vprintf (const char *__restrict __fmt, __gnuc_va_list __ap)
>{
>
>  return __vfprintf_chk (stdout, 2 - 1, __fmt, __ap);
>
>
>
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>vfprintf (FILE *__restrict __stream,
>   const char *__restrict __fmt, __gnuc_va_list __ap)
>{
>  return __vfprintf_chk (__stream, 2 - 1, __fmt, __ap);
>}
>
>
>extern int __dprintf_chk (int __fd, int __flag, const char *__restrict __fmt,
>     ...) __attribute__ ((__format__ (__printf__, 3, 4)));
>extern int __vdprintf_chk (int __fd, int __flag,
>      const char *__restrict __fmt, __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>dprintf (int __fd, const char *__restrict __fmt, ...)
>{
>  return __dprintf_chk (__fd, 2 - 1, __fmt,
>   __builtin_va_arg_pack ());
>}
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __ap)
>{
>  return __vdprintf_chk (__fd, 2 - 1, __fmt, __ap);
>}
>
>
>
>
>extern int __asprintf_chk (char **__restrict __ptr, int __flag,
>      const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__printf__, 3, 4))) __attribute__ ((__warn_unused_result__));
>extern int __vasprintf_chk (char **__restrict __ptr, int __flag,
>       const char *__restrict __fmt, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__printf__, 3, 0))) __attribute__ ((__warn_unused_result__));
>extern int __obstack_printf_chk (struct obstack *__restrict __obstack,
>     int __flag, const char *__restrict __format,
>     ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__printf__, 3, 4)));
>extern int __obstack_vprintf_chk (struct obstack *__restrict __obstack,
>      int __flag,
>      const char *__restrict __format,
>      __gnuc_va_list __args)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...)
>{
>  return __asprintf_chk (__ptr, 2 - 1, __fmt,
>    __builtin_va_arg_pack ());
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) __asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...)
>
>{
>  return __asprintf_chk (__ptr, 2 - 1, __fmt,
>    __builtin_va_arg_pack ());
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) obstack_printf (struct obstack *__restrict __obstack, const char *__restrict __fmt, ...)
>
>{
>  return __obstack_printf_chk (__obstack, 2 - 1, __fmt,
>          __builtin_va_arg_pack ());
>}
># 206 "/usr/include/bits/stdio2.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) vasprintf (char **__restrict __ptr, const char *__restrict __fmt, __gnuc_va_list __ap)
>
>{
>  return __vasprintf_chk (__ptr, 2 - 1, __fmt, __ap);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) obstack_vprintf (struct obstack *__restrict __obstack, const char *__restrict __fmt, __gnuc_va_list __ap)
>
>{
>  return __obstack_vprintf_chk (__obstack, 2 - 1, __fmt,
>    __ap);
>}
># 241 "/usr/include/bits/stdio2.h" 3 4
>extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n,
>     FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern char *__fgets_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets")
>
>                                        __attribute__ ((__warn_unused_result__));
>extern char *__fgets_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets called with bigger size than length " "of destination buffer")))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n) || __n <= 0)
> return __fgets_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
>
>      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
> return __fgets_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
>    }
>  return __fgets_alias (__s, __n, __stream);
>}
>
>extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen,
>      size_t __size, size_t __n,
>      FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern size_t __fread_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread")
>
>
>            __attribute__ ((__warn_unused_result__));
>extern size_t __fread_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_chk")
>
>
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread called with bigger size * nmemb than length " "of destination buffer")))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
>fread (void *__restrict __ptr, size_t __size, size_t __n,
>       FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__size)
>   || !__builtin_constant_p (__n)
>   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
> return __fread_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
>
>      if (__size * __n > __builtin_object_size (__ptr, 0))
> return __fread_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
>    }
>  return __fread_alias (__ptr, __size, __n, __stream);
>}
>
>
>extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size,
>       int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern char *__fgets_unlocked_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets_unlocked")
>
>                                                 __attribute__ ((__warn_unused_result__));
>extern char *__fgets_unlocked_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_unlocked_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets_unlocked called with bigger size than length " "of destination buffer")))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n) || __n <= 0)
> return __fgets_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
>
>      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
> return __fgets_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
>    }
>  return __fgets_unlocked_alias (__s, __n, __stream);
>}
>
>
>
>
>extern size_t __fread_unlocked_chk (void *__restrict __ptr, size_t __ptrlen,
>        size_t __size, size_t __n,
>        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern size_t __fread_unlocked_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread_unlocked")
>
>
>                     __attribute__ ((__warn_unused_result__));
>extern size_t __fread_unlocked_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_unlocked_chk")
>
>
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread_unlocked called with bigger size * nmemb than " "length of destination buffer")))
>                                        ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
>fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n,
>  FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__size)
>   || !__builtin_constant_p (__n)
>   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
> return __fread_unlocked_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
>         __stream);
>
>      if (__size * __n > __builtin_object_size (__ptr, 0))
> return __fread_unlocked_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
>       __stream);
>    }
>
>
>  if (__builtin_constant_p (__size)
>      && __builtin_constant_p (__n)
>      && (__size | __n) < (((size_t) 1) << (8 * sizeof (size_t) / 2))
>      && __size * __n <= 8)
>    {
>      size_t __cnt = __size * __n;
>      char *__cptr = (char *) __ptr;
>      if (__cnt == 0)
> return 0;
>
>      for (; __cnt > 0; --__cnt)
> {
>   int __c = (__builtin_expect (((__stream)->_IO_read_ptr >= (__stream)->_IO_read_end), 0) ? __uflow (__stream) : *(unsigned char *) (__stream)->_IO_read_ptr++);
>   if (__c == (-1))
>     break;
>   *__cptr++ = __c;
> }
>      return (__cptr - (char *) __ptr) / __size;
>    }
>
>  return __fread_unlocked_alias (__ptr, __size, __n, __stream);
>}
># 937 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>
>
># 5 "../../mono/metadata/image.h" 2
># 1 "../../mono/utils/mono-publib.h" 1
># 18 "../../mono/utils/mono-publib.h"
>
># 34 "../../mono/utils/mono-publib.h"
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stdint.h" 1 3 4
># 9 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stdint.h" 3 4
># 1 "/usr/include/stdint.h" 1 3 4
># 26 "/usr/include/stdint.h" 3 4
># 1 "/usr/include/bits/wchar.h" 1 3 4
># 27 "/usr/include/stdint.h" 2 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 28 "/usr/include/stdint.h" 2 3 4
># 36 "/usr/include/stdint.h" 3 4
>typedef signed char int8_t;
>typedef short int int16_t;
>typedef int int32_t;
>
>typedef long int int64_t;
>
>
>
>
>
>
>
>typedef unsigned char uint8_t;
>typedef unsigned short int uint16_t;
>
>typedef unsigned int uint32_t;
>
>
>
>typedef unsigned long int uint64_t;
># 65 "/usr/include/stdint.h" 3 4
>typedef signed char int_least8_t;
>typedef short int int_least16_t;
>typedef int int_least32_t;
>
>typedef long int int_least64_t;
>
>
>
>
>
>
>typedef unsigned char uint_least8_t;
>typedef unsigned short int uint_least16_t;
>typedef unsigned int uint_least32_t;
>
>typedef unsigned long int uint_least64_t;
># 90 "/usr/include/stdint.h" 3 4
>typedef signed char int_fast8_t;
>
>typedef long int int_fast16_t;
>typedef long int int_fast32_t;
>typedef long int int_fast64_t;
># 103 "/usr/include/stdint.h" 3 4
>typedef unsigned char uint_fast8_t;
>
>typedef unsigned long int uint_fast16_t;
>typedef unsigned long int uint_fast32_t;
>typedef unsigned long int uint_fast64_t;
># 122 "/usr/include/stdint.h" 3 4
>typedef unsigned long int uintptr_t;
># 134 "/usr/include/stdint.h" 3 4
>typedef long int intmax_t;
>typedef unsigned long int uintmax_t;
># 10 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stdint.h" 2 3 4
># 35 "../../mono/utils/mono-publib.h" 2
>
>
>
>typedef int32_t mono_bool;
>typedef uint8_t mono_byte;
>typedef uint16_t mono_unichar2;
>
>typedef void (*MonoFunc) (void* data, void* user_data);
>typedef void (*MonoHFunc) (void* key, void* value, void* user_data);
>
>void mono_free (void *);
>
>
>
>
># 6 "../../mono/metadata/image.h" 2
>
>
>
>typedef struct _MonoImage MonoImage;
>typedef struct _MonoAssembly MonoAssembly;
>typedef struct _MonoAssemblyName MonoAssemblyName;
>typedef struct _MonoTableInfo MonoTableInfo;
>
>typedef enum {
> MONO_IMAGE_OK,
> MONO_IMAGE_ERROR_ERRNO,
> MONO_IMAGE_MISSING_ASSEMBLYREF,
> MONO_IMAGE_IMAGE_INVALID
>} MonoImageOpenStatus;
>
>void mono_images_init (void);
>void mono_images_cleanup (void);
>
>MonoImage *mono_image_open (const char *fname,
>       MonoImageOpenStatus *status);
>MonoImage *mono_image_open_full (const char *fname,
>       MonoImageOpenStatus *status, mono_bool refonly);
>MonoImage *mono_pe_file_open (const char *fname,
>         MonoImageOpenStatus *status);
>MonoImage *mono_image_open_from_data (char *data, uint32_t data_len, mono_bool need_copy,
>                                         MonoImageOpenStatus *status);
>MonoImage *mono_image_open_from_data_full (char *data, uint32_t data_len, mono_bool need_copy,
>                                         MonoImageOpenStatus *status, mono_bool refonly);
>MonoImage *mono_image_open_from_data_with_name (char *data, uint32_t data_len, mono_bool need_copy,
>                                                   MonoImageOpenStatus *status, mono_bool refonly, const char *name);
>void mono_image_fixup_vtable (MonoImage *image);
>MonoImage *mono_image_loaded (const char *name);
>MonoImage *mono_image_loaded_full (const char *name, mono_bool refonly);
>MonoImage *mono_image_loaded_by_guid (const char *guid);
>MonoImage *mono_image_loaded_by_guid_full (const char *guid, mono_bool refonly);
>void mono_image_init (MonoImage *image);
>void mono_image_close (MonoImage *image);
>void mono_image_addref (MonoImage *image);
>const char *mono_image_strerror (MonoImageOpenStatus status);
>
>int mono_image_ensure_section (MonoImage *image,
>          const char *section);
>int mono_image_ensure_section_idx (MonoImage *image,
>          int section);
>
>uint32_t mono_image_get_entry_point (MonoImage *image);
>const char *mono_image_get_resource (MonoImage *image, uint32_t offset, uint32_t *size);
>MonoImage* mono_image_load_file_for_image (MonoImage *image, int fileidx);
>
>MonoImage* mono_image_load_module (MonoImage *image, int idx);
>
>const char* mono_image_get_name (MonoImage *image);
>const char* mono_image_get_filename (MonoImage *image);
>const char * mono_image_get_guid (MonoImage *image);
>MonoAssembly* mono_image_get_assembly (MonoImage *image);
>mono_bool mono_image_is_dynamic (MonoImage *image);
>char* mono_image_rva_map (MonoImage *image, uint32_t rva);
>
>const MonoTableInfo *mono_image_get_table_info (MonoImage *image, int table_id);
>int mono_image_get_table_rows (MonoImage *image, int table_id);
>int mono_table_info_get_rows (const MonoTableInfo *table);
>
>
>
>
>void* mono_image_lookup_resource (MonoImage *image, uint32_t res_id,
>       uint32_t lang_id, mono_unichar2 *name);
>
>const char* mono_image_get_public_key (MonoImage *image, uint32_t *size);
>const char* mono_image_get_strong_name (MonoImage *image, uint32_t *size);
>uint32_t mono_image_strong_name_position (MonoImage *image, uint32_t *size);
>void mono_image_add_to_name_cache (MonoImage *image,
>   const char *nspace, const char *name, uint32_t idx);
>mono_bool mono_image_has_authenticode_entry (MonoImage *image);
>
>
># 5 "../../mono/metadata/assembly.h" 2
>
>
>
>void mono_assemblies_init (void);
>void mono_assemblies_cleanup (void);
>MonoAssembly *mono_assembly_open (const char *filename,
>            MonoImageOpenStatus *status);
>MonoAssembly *mono_assembly_open_full (const char *filename,
>            MonoImageOpenStatus *status,
>     mono_bool refonly);
>MonoAssembly* mono_assembly_load (MonoAssemblyName *aname,
>                                        const char *basedir,
>          MonoImageOpenStatus *status);
>MonoAssembly* mono_assembly_load_full (MonoAssemblyName *aname,
>                                        const char *basedir,
>          MonoImageOpenStatus *status,
>     mono_bool refonly);
>MonoAssembly* mono_assembly_load_from (MonoImage *image, const char *fname,
>     MonoImageOpenStatus *status);
>MonoAssembly* mono_assembly_load_from_full (MonoImage *image, const char *fname,
>     MonoImageOpenStatus *status,
>     mono_bool refonly);
>
>MonoAssembly* mono_assembly_load_with_partial_name (const char *name, MonoImageOpenStatus *status);
>
>MonoAssembly* mono_assembly_loaded (MonoAssemblyName *aname);
>MonoAssembly* mono_assembly_loaded_full (MonoAssemblyName *aname, mono_bool refonly);
>void mono_assembly_get_assemblyref (MonoImage *image, int index, MonoAssemblyName *aname);
>void mono_assembly_load_reference (MonoImage *image, int index);
>void mono_assembly_load_references (MonoImage *image, MonoImageOpenStatus *status);
>MonoImage* mono_assembly_load_module (MonoAssembly *assembly, uint32_t idx);
>void mono_assembly_close (MonoAssembly *assembly);
>void mono_assembly_setrootdir (const char *root_dir);
>const char *mono_assembly_getrootdir (void);
>void mono_assembly_foreach (MonoFunc func, void* user_data);
>void mono_assembly_set_main (MonoAssembly *assembly);
>MonoAssembly *mono_assembly_get_main (void);
>MonoImage *mono_assembly_get_image (MonoAssembly *assembly);
>mono_bool mono_assembly_fill_assembly_name (MonoImage *image, MonoAssemblyName *aname);
>mono_bool mono_assembly_names_equal (MonoAssemblyName *l, MonoAssemblyName *r);
>char* mono_stringify_assembly_name (MonoAssemblyName *aname);
>
>
>typedef void (*MonoAssemblyLoadFunc) (MonoAssembly *assembly, void* user_data);
>void mono_install_assembly_load_hook (MonoAssemblyLoadFunc func, void* user_data);
>
>
>
>
>
>typedef MonoAssembly *(*MonoAssemblySearchFunc) (MonoAssemblyName *aname, void* user_data);
>void mono_install_assembly_search_hook (MonoAssemblySearchFunc func, void* user_data);
>void mono_install_assembly_refonly_search_hook (MonoAssemblySearchFunc func, void* user_data);
>
>MonoAssembly* mono_assembly_invoke_search_hook (MonoAssemblyName *aname);
>
>
>
>
>
>void
>mono_install_assembly_postload_search_hook (MonoAssemblySearchFunc func, void* user_data);
>
>void
>mono_install_assembly_postload_refonly_search_hook (MonoAssemblySearchFunc func, void* user_data);
>
>
>
>
>
>typedef MonoAssembly * (*MonoAssemblyPreLoadFunc) (MonoAssemblyName *aname,
>         char **assemblies_path,
>         void* user_data);
>
>void mono_install_assembly_preload_hook (MonoAssemblyPreLoadFunc func,
>        void* user_data);
>void mono_install_assembly_refonly_preload_hook (MonoAssemblyPreLoadFunc func,
>        void* user_data);
>
>void mono_assembly_invoke_load_hook (MonoAssembly *ass);
>
>MonoAssemblyName* mono_assembly_name_new (const char *name);
>const char* mono_assembly_name_get_name (MonoAssemblyName *aname);
>const char* mono_assembly_name_get_culture (MonoAssemblyName *aname);
>uint16_t mono_assembly_name_get_version (MonoAssemblyName *aname,
>            uint16_t *minor, uint16_t *build, uint16_t *revision);
>mono_byte* mono_assembly_name_get_pubkeytoken (MonoAssemblyName *aname);
>void mono_assembly_name_free (MonoAssemblyName *aname);
>
>typedef struct {
> const char *name;
> const unsigned char *data;
> const unsigned int size;
>} MonoBundledAssembly;
>
>void mono_register_bundled_assemblies (const MonoBundledAssembly **assemblies);
>void mono_register_config_for_assembly (const char* assembly_name, const char* config_xml);
>void mono_register_symfile_for_assembly (const char* assembly_name, const mono_byte *raw_contents, int size);
>void mono_register_machine_config (const char *config_xml);
>
>void mono_set_rootdir (void);
>void mono_set_dirs (const char *assembly_dir, const char *config_dir);
>void mono_set_assemblies_path (const char* path);
>
># 35 "method-to-ir.c" 2
># 1 "../../mono/metadata/attrdefs.h" 1
># 21 "../../mono/metadata/attrdefs.h"
>enum {
> MONO_ASSEMBLY_HASH_NONE,
> MONO_ASSEMBLY_HASH_MD5 = 0x8003,
> MONO_ASSEMBLY_HASH_SHA1 = 0x8004
>};
>
>
>
>
>enum {
> MONO_ASSEMBLYREF_FULL_PUBLIC_KEY = 0x0001,
> MONO_ASSEMBLYREF_RETARGETABLE = 0x0100,
> MONO_ASSEMBLYREF_JIT_TRACKING = 0x8000,
> MONO_ASSEMBLYREF_NO_JIT_OPT = 0x4000
>};
>
>
>
>
>enum {
> MONO_EVENT_SPECIALNAME = 0x0200,
> MONO_EVENT_RTSPECIALNAME = 0x0400
>};
>
>
>
>
>enum {
> MONO_FIELD_ATTR_FIELD_ACCESS_MASK = 0x0007,
> MONO_FIELD_ATTR_COMPILER_CONTROLLED = 0x0000,
> MONO_FIELD_ATTR_PRIVATE = 0x0001,
> MONO_FIELD_ATTR_FAM_AND_ASSEM = 0x0002,
> MONO_FIELD_ATTR_ASSEMBLY = 0x0003,
> MONO_FIELD_ATTR_FAMILY = 0x0004,
> MONO_FIELD_ATTR_FAM_OR_ASSEM = 0x0005,
> MONO_FIELD_ATTR_PUBLIC = 0x0006,
>
> MONO_FIELD_ATTR_STATIC = 0x0010,
> MONO_FIELD_ATTR_INIT_ONLY = 0x0020,
> MONO_FIELD_ATTR_LITERAL = 0x0040,
> MONO_FIELD_ATTR_NOT_SERIALIZED = 0x0080,
> MONO_FIELD_ATTR_SPECIAL_NAME = 0x0200,
> MONO_FIELD_ATTR_PINVOKE_IMPL = 0x2000,
>
>
> MONO_FIELD_ATTR_RESERVED_MASK = 0x9500,
> MONO_FIELD_ATTR_RT_SPECIAL_NAME = 0x0400,
> MONO_FIELD_ATTR_HAS_MARSHAL = 0x1000,
> MONO_FIELD_ATTR_HAS_DEFAULT = 0x8000,
> MONO_FIELD_ATTR_HAS_RVA = 0x0100
>};
>
>
>
>
>enum {
> MONO_FILE_HAS_METADATA = 0,
> MONO_FILE_HAS_NO_METADATA = 1
>};
>
>
>
>
>enum {
> MONO_GEN_PARAM_VARIANCE_MASK = 0x0003,
> MONO_GEN_PARAM_NON_VARIANT = 0x0000,
> MONO_GEN_PARAM_VARIANT = 0x0001,
> MONO_GEN_PARAM_COVARIANT = 0x0002,
> MONO_GEN_PARAM_CONSTRAINT_MASK = 0x001c,
> MONO_GEN_PARAM_CONSTRAINT_CLASS = 0x0004,
> MONO_GEN_PARAM_CONSTRAINT_VTYPE = 0x0008,
> MONO_GEN_PARAM_CONSTRAINT_DCTOR = 0x0010
>};
>
>
>
>
>enum {
> MONO_PINVOKE_NO_MANGLE = 0x0001,
> MONO_PINVOKE_CHAR_SET_MASK = 0x0006,
> MONO_PINVOKE_CHAR_SET_NOT_SPEC = 0x0000,
> MONO_PINVOKE_CHAR_SET_ANSI = 0x0002,
> MONO_PINVOKE_CHAR_SET_UNICODE = 0x0004,
> MONO_PINVOKE_CHAR_SET_AUTO = 0x0006,
> MONO_PINVOKE_BEST_FIT_ENABLED = 0x0010,
> MONO_PINVOKE_BEST_FIT_DISABLED = 0x0020,
> MONO_PINVOKE_BEST_FIT_MASK = 0x0030,
> MONO_PINVOKE_SUPPORTS_LAST_ERROR = 0x0040,
> MONO_PINVOKE_CALL_CONV_MASK = 0x0700,
> MONO_PINVOKE_CALL_CONV_WINAPI = 0x0100,
> MONO_PINVOKE_CALL_CONV_CDECL = 0x0200,
> MONO_PINVOKE_CALL_CONV_STDCALL = 0x0300,
> MONO_PINVOKE_CALL_CONV_THISCALL = 0x0400,
> MONO_PINVOKE_CALL_CONV_FASTCALL = 0x0500,
> MONO_PINVOKE_THROW_ON_UNMAPPABLE_ENABLED = 0x1000,
> MONO_PINVOKE_THROW_ON_UNMAPPABLE_DISABLED = 0x2000,
> MONO_PINVOKE_THROW_ON_UNMAPPABLE_MASK = 0x3000,
> MONO_PINVOKE_CALL_CONV_GENERIC = 0x0010,
> MONO_PINVOKE_CALL_CONV_GENERICINST = 0x000a
>};
>
>
>
>
>enum {
> MONO_MANIFEST_RESOURCE_VISIBILITY_MASK = 0x00000007,
> MONO_MANIFEST_RESOURCE_PUBLIC = 0x00000001,
> MONO_MANIFEST_RESOURCE_PRIVATE = 0x00000002
>};
>
>
>
>
>enum {
> MONO_METHOD_ATTR_ACCESS_MASK = 0x0007,
> MONO_METHOD_ATTR_COMPILER_CONTROLLED = 0x0000,
> MONO_METHOD_ATTR_PRIVATE = 0x0001,
> MONO_METHOD_ATTR_FAM_AND_ASSEM = 0x0002,
> MONO_METHOD_ATTR_ASSEM = 0x0003,
> MONO_METHOD_ATTR_FAMILY = 0x0004,
> MONO_METHOD_ATTR_FAM_OR_ASSEM = 0x0005,
> MONO_METHOD_ATTR_PUBLIC = 0x0006,
>
> MONO_METHOD_ATTR_STATIC = 0x0010,
> MONO_METHOD_ATTR_FINAL = 0x0020,
> MONO_METHOD_ATTR_VIRTUAL = 0x0040,
> MONO_METHOD_ATTR_HIDE_BY_SIG = 0x0080,
>
> MONO_METHOD_ATTR_VTABLE_LAYOUT_MASK = 0x0100,
> MONO_METHOD_ATTR_REUSE_SLOT = 0x0000,
> MONO_METHOD_ATTR_NEW_SLOT = 0x0100,
> MONO_METHOD_ATTR_STRICT = 0x0200,
> MONO_METHOD_ATTR_ABSTRACT = 0x0400,
>
> MONO_METHOD_ATTR_SPECIAL_NAME = 0x0800,
>
> MONO_METHOD_ATTR_PINVOKE_IMPL = 0x2000,
> MONO_METHOD_ATTR_UNMANAGED_EXPORT = 0x0008,
>
>
>
>
> MONO_METHOD_ATTR_RESERVED_MASK = 0xd000,
> MONO_METHOD_ATTR_RT_SPECIAL_NAME = 0x1000,
> MONO_METHOD_ATTR_HAS_SECURITY = 0x4000,
> MONO_METHOD_ATTR_REQUIRE_SEC_OBJECT = 0x8000
>};
>
>
>
>
>enum {
> MONO_METHOD_IMPL_ATTR_CODE_TYPE_MASK = 0x0003,
> MONO_METHOD_IMPL_ATTR_IL = 0x0000,
> MONO_METHOD_IMPL_ATTR_NATIVE = 0x0001,
> MONO_METHOD_IMPL_ATTR_OPTIL = 0x0002,
> MONO_METHOD_IMPL_ATTR_RUNTIME = 0x0003,
>
> MONO_METHOD_IMPL_ATTR_MANAGED_MASK = 0x0004,
> MONO_METHOD_IMPL_ATTR_UNMANAGED = 0x0004,
> MONO_METHOD_IMPL_ATTR_MANAGED = 0x0000,
>
> MONO_METHOD_IMPL_ATTR_FORWARD_REF = 0x0010,
> MONO_METHOD_IMPL_ATTR_PRESERVE_SIG = 0x0080,
> MONO_METHOD_IMPL_ATTR_INTERNAL_CALL = 0x1000,
> MONO_METHOD_IMPL_ATTR_SYNCHRONIZED = 0x0020,
> MONO_METHOD_IMPL_ATTR_NOINLINING = 0x0008,
> MONO_METHOD_IMPL_ATTR_NOOPTIMIZATION = 0x0040,
> MONO_METHOD_IMPL_ATTR_MAX_METHOD_IMPL_VAL = 0xffff
>};
>
>
>
>
>enum {
> MONO_METHOD_SEMANTIC_SETTER = 0x0001,
> MONO_METHOD_SEMANTIC_GETTER = 0x0002,
> MONO_METHOD_SEMANTIC_OTHER = 0x0004,
> MONO_METHOD_SEMANTIC_ADD_ON = 0x0008,
> MONO_METHOD_SEMANTIC_REMOVE_ON = 0x0010,
> MONO_METHOD_SEMANTIC_FIRE = 0x0020
>};
>
>
>
>
>enum {
> MONO_PARAM_ATTR_IN = 0x0001,
> MONO_PARAM_ATTR_OUT = 0x0002,
> MONO_PARAM_ATTR_OPTIONAL = 0x0010,
> MONO_PARAM_ATTR_RESERVED_MASK = 0xf000,
> MONO_PARAM_ATTR_HAS_DEFAULT = 0x1000,
> MONO_PARAM_ATTR_HAS_MARSHAL = 0x2000,
> MONO_PARAM_ATTR_UNUSED = 0xcfe0
>};
>
>
>
>
>enum {
> MONO_PROPERTY_ATTR_SPECIAL_NAME = 0x0200,
> MONO_PROPERTY_ATTR_RESERVED_MASK = 0xf400,
> MONO_PROPERTY_ATTR_RT_SPECIAL_NAME = 0x0400,
> MONO_PROPERTY_ATTR_HAS_DEFAULT = 0x1000,
> MONO_PROPERTY_ATTR_UNUSED = 0xe9ff
>};
>
>
>
>
>enum {
> MONO_TYPE_ATTR_VISIBILITY_MASK = 0x00000007,
> MONO_TYPE_ATTR_NOT_PUBLIC = 0x00000000,
> MONO_TYPE_ATTR_PUBLIC = 0x00000001,
> MONO_TYPE_ATTR_NESTED_PUBLIC = 0x00000002,
> MONO_TYPE_ATTR_NESTED_PRIVATE = 0x00000003,
> MONO_TYPE_ATTR_NESTED_FAMILY = 0x00000004,
> MONO_TYPE_ATTR_NESTED_ASSEMBLY = 0x00000005,
> MONO_TYPE_ATTR_NESTED_FAM_AND_ASSEM = 0x00000006,
> MONO_TYPE_ATTR_NESTED_FAM_OR_ASSEM = 0x00000007,
>
> MONO_TYPE_ATTR_LAYOUT_MASK = 0x00000018,
> MONO_TYPE_ATTR_AUTO_LAYOUT = 0x00000000,
> MONO_TYPE_ATTR_SEQUENTIAL_LAYOUT = 0x00000008,
> MONO_TYPE_ATTR_EXPLICIT_LAYOUT = 0x00000010,
>
> MONO_TYPE_ATTR_CLASS_SEMANTIC_MASK = 0x00000020,
> MONO_TYPE_ATTR_CLASS = 0x00000000,
> MONO_TYPE_ATTR_INTERFACE = 0x00000020,
>
> MONO_TYPE_ATTR_ABSTRACT = 0x00000080,
> MONO_TYPE_ATTR_SEALED = 0x00000100,
> MONO_TYPE_ATTR_SPECIAL_NAME = 0x00000400,
>
> MONO_TYPE_ATTR_IMPORT = 0x00001000,
> MONO_TYPE_ATTR_SERIALIZABLE = 0x00002000,
>
> MONO_TYPE_ATTR_STRING_FORMAT_MASK = 0x00030000,
> MONO_TYPE_ATTR_ANSI_CLASS = 0x00000000,
> MONO_TYPE_ATTR_UNICODE_CLASS = 0x00010000,
> MONO_TYPE_ATTR_AUTO_CLASS = 0x00020000,
> MONO_TYPE_ATTR_CUSTOM_CLASS = 0x00030000,
> MONO_TYPE_ATTR_CUSTOM_MASK = 0x00c00000,
>
> MONO_TYPE_ATTR_BEFORE_FIELD_INIT = 0x00100000,
> MONO_TYPE_ATTR_FORWARDER = 0x00200000,
>
> MONO_TYPE_ATTR_RESERVED_MASK = 0x00040800,
> MONO_TYPE_ATTR_RT_SPECIAL_NAME = 0x00000800,
> MONO_TYPE_ATTR_HAS_SECURITY = 0x00040000
>};
># 36 "method-to-ir.c" 2
># 1 "../../mono/metadata/loader.h" 1
>
>
>
># 1 "../../mono/metadata/metadata.h" 1
>
>
>
>
>
>
># 1 "../../mono/metadata/blob.h" 1
># 11 "../../mono/metadata/blob.h"
>typedef enum {
> MONO_TYPE_END = 0x00,
> MONO_TYPE_VOID = 0x01,
> MONO_TYPE_BOOLEAN = 0x02,
> MONO_TYPE_CHAR = 0x03,
> MONO_TYPE_I1 = 0x04,
> MONO_TYPE_U1 = 0x05,
> MONO_TYPE_I2 = 0x06,
> MONO_TYPE_U2 = 0x07,
> MONO_TYPE_I4 = 0x08,
> MONO_TYPE_U4 = 0x09,
> MONO_TYPE_I8 = 0x0a,
> MONO_TYPE_U8 = 0x0b,
> MONO_TYPE_R4 = 0x0c,
> MONO_TYPE_R8 = 0x0d,
> MONO_TYPE_STRING = 0x0e,
> MONO_TYPE_PTR = 0x0f,
> MONO_TYPE_BYREF = 0x10,
> MONO_TYPE_VALUETYPE = 0x11,
> MONO_TYPE_CLASS = 0x12,
> MONO_TYPE_VAR = 0x13,
> MONO_TYPE_ARRAY = 0x14,
> MONO_TYPE_GENERICINST= 0x15,
> MONO_TYPE_TYPEDBYREF = 0x16,
> MONO_TYPE_I = 0x18,
> MONO_TYPE_U = 0x19,
> MONO_TYPE_FNPTR = 0x1b,
> MONO_TYPE_OBJECT = 0x1c,
> MONO_TYPE_SZARRAY = 0x1d,
> MONO_TYPE_MVAR = 0x1e,
> MONO_TYPE_CMOD_REQD = 0x1f,
> MONO_TYPE_CMOD_OPT = 0x20,
> MONO_TYPE_INTERNAL = 0x21,
>
> MONO_TYPE_MODIFIER = 0x40,
> MONO_TYPE_SENTINEL = 0x41,
> MONO_TYPE_PINNED = 0x45,
>
> MONO_TYPE_ENUM = 0x55
>} MonoTypeEnum;
>
>typedef enum {
> MONO_TABLE_MODULE,
> MONO_TABLE_TYPEREF,
> MONO_TABLE_TYPEDEF,
> MONO_TABLE_FIELD_POINTER,
> MONO_TABLE_FIELD,
> MONO_TABLE_METHOD_POINTER,
> MONO_TABLE_METHOD,
> MONO_TABLE_PARAM_POINTER,
> MONO_TABLE_PARAM,
> MONO_TABLE_INTERFACEIMPL,
> MONO_TABLE_MEMBERREF,
> MONO_TABLE_CONSTANT,
> MONO_TABLE_CUSTOMATTRIBUTE,
> MONO_TABLE_FIELDMARSHAL,
> MONO_TABLE_DECLSECURITY,
> MONO_TABLE_CLASSLAYOUT,
> MONO_TABLE_FIELDLAYOUT,
> MONO_TABLE_STANDALONESIG,
> MONO_TABLE_EVENTMAP,
> MONO_TABLE_EVENT_POINTER,
> MONO_TABLE_EVENT,
> MONO_TABLE_PROPERTYMAP,
> MONO_TABLE_PROPERTY_POINTER,
> MONO_TABLE_PROPERTY,
> MONO_TABLE_METHODSEMANTICS,
> MONO_TABLE_METHODIMPL,
> MONO_TABLE_MODULEREF,
> MONO_TABLE_TYPESPEC,
> MONO_TABLE_IMPLMAP,
> MONO_TABLE_FIELDRVA,
> MONO_TABLE_UNUSED6,
> MONO_TABLE_UNUSED7,
> MONO_TABLE_ASSEMBLY,
> MONO_TABLE_ASSEMBLYPROCESSOR,
> MONO_TABLE_ASSEMBLYOS,
> MONO_TABLE_ASSEMBLYREF,
> MONO_TABLE_ASSEMBLYREFPROCESSOR,
> MONO_TABLE_ASSEMBLYREFOS,
> MONO_TABLE_FILE,
> MONO_TABLE_EXPORTEDTYPE,
> MONO_TABLE_MANIFESTRESOURCE,
> MONO_TABLE_NESTEDCLASS,
> MONO_TABLE_GENERICPARAM,
> MONO_TABLE_METHODSPEC,
> MONO_TABLE_GENERICPARAMCONSTRAINT
>
>
>
>
>} MonoMetaTableEnum;
># 8 "../../mono/metadata/metadata.h" 2
># 1 "../../mono/metadata/row-indexes.h" 1
># 10 "../../mono/metadata/row-indexes.h"
>enum {
> MONO_ASSEMBLY_HASH_ALG,
> MONO_ASSEMBLY_MAJOR_VERSION,
> MONO_ASSEMBLY_MINOR_VERSION,
> MONO_ASSEMBLY_BUILD_NUMBER,
> MONO_ASSEMBLY_REV_NUMBER,
> MONO_ASSEMBLY_FLAGS,
> MONO_ASSEMBLY_PUBLIC_KEY,
> MONO_ASSEMBLY_NAME,
> MONO_ASSEMBLY_CULTURE,
> MONO_ASSEMBLY_SIZE
>};
>
>enum {
> MONO_ASSEMBLYOS_PLATFORM,
> MONO_ASSEMBLYOS_MAJOR_VERSION,
> MONO_ASSEMBLYOS_MINOR_VERSION,
> MONO_ASSEMBLYOS_SIZE
>};
>
>enum {
> MONO_ASSEMBLY_PROCESSOR,
> MONO_ASSEMBLY_PROCESSOR_SIZE
>};
>
>enum {
> MONO_ASSEMBLYREF_MAJOR_VERSION,
> MONO_ASSEMBLYREF_MINOR_VERSION,
> MONO_ASSEMBLYREF_BUILD_NUMBER,
> MONO_ASSEMBLYREF_REV_NUMBER,
> MONO_ASSEMBLYREF_FLAGS,
> MONO_ASSEMBLYREF_PUBLIC_KEY,
> MONO_ASSEMBLYREF_NAME,
> MONO_ASSEMBLYREF_CULTURE,
> MONO_ASSEMBLYREF_HASH_VALUE,
> MONO_ASSEMBLYREF_SIZE
>};
>
>enum {
> MONO_ASSEMBLYREFOS_PLATFORM,
> MONO_ASSEMBLYREFOS_MAJOR_VERSION,
> MONO_ASSEMBLYREFOS_MINOR_VERSION,
> MONO_ASSEMBLYREFOS_ASSEMBLYREF,
> MONO_ASSEMBLYREFOS_SIZE
>};
>
>enum {
> MONO_ASSEMBLYREFPROC_PROCESSOR,
> MONO_ASSEMBLYREFPROC_ASSEMBLYREF,
> MONO_ASSEMBLYREFPROC_SIZE
>};
>
>enum {
> MONO_CLASS_LAYOUT_PACKING_SIZE,
> MONO_CLASS_LAYOUT_CLASS_SIZE,
> MONO_CLASS_LAYOUT_PARENT,
> MONO_CLASS_LAYOUT_SIZE
>};
>
>enum {
> MONO_CONSTANT_TYPE,
> MONO_CONSTANT_PADDING,
> MONO_CONSTANT_PARENT,
> MONO_CONSTANT_VALUE,
> MONO_CONSTANT_SIZE
>};
>
>enum {
> MONO_CUSTOM_ATTR_PARENT,
> MONO_CUSTOM_ATTR_TYPE,
> MONO_CUSTOM_ATTR_VALUE,
> MONO_CUSTOM_ATTR_SIZE
>};
>
>enum {
> MONO_DECL_SECURITY_ACTION,
> MONO_DECL_SECURITY_PARENT,
> MONO_DECL_SECURITY_PERMISSIONSET,
> MONO_DECL_SECURITY_SIZE
>};
>
>enum {
> MONO_EVENT_MAP_PARENT,
> MONO_EVENT_MAP_EVENTLIST,
> MONO_EVENT_MAP_SIZE
>};
>
>enum {
> MONO_EVENT_FLAGS,
> MONO_EVENT_NAME,
> MONO_EVENT_TYPE,
> MONO_EVENT_SIZE
>};
>
>enum {
> MONO_EVENT_POINTER_EVENT,
> MONO_EVENT_POINTER_SIZE
>};
>
>enum {
> MONO_EXP_TYPE_FLAGS,
> MONO_EXP_TYPE_TYPEDEF,
> MONO_EXP_TYPE_NAME,
> MONO_EXP_TYPE_NAMESPACE,
> MONO_EXP_TYPE_IMPLEMENTATION,
> MONO_EXP_TYPE_SIZE
>};
>
>enum {
> MONO_FIELD_FLAGS,
> MONO_FIELD_NAME,
> MONO_FIELD_SIGNATURE,
> MONO_FIELD_SIZE
>};
>
>enum {
> MONO_FIELD_LAYOUT_OFFSET,
> MONO_FIELD_LAYOUT_FIELD,
> MONO_FIELD_LAYOUT_SIZE
>};
>
>enum {
> MONO_FIELD_MARSHAL_PARENT,
> MONO_FIELD_MARSHAL_NATIVE_TYPE,
> MONO_FIELD_MARSHAL_SIZE
>};
>
>enum {
> MONO_FIELD_POINTER_FIELD,
> MONO_FIELD_POINTER_SIZE
>};
>
>enum {
> MONO_FIELD_RVA_RVA,
> MONO_FIELD_RVA_FIELD,
> MONO_FIELD_RVA_SIZE
>};
>
>enum {
> MONO_FILE_FLAGS,
> MONO_FILE_NAME,
> MONO_FILE_HASH_VALUE,
> MONO_FILE_SIZE
>};
>
>enum {
> MONO_IMPLMAP_FLAGS,
> MONO_IMPLMAP_MEMBER,
> MONO_IMPLMAP_NAME,
> MONO_IMPLMAP_SCOPE,
> MONO_IMPLMAP_SIZE
>};
>
>enum {
> MONO_INTERFACEIMPL_CLASS,
> MONO_INTERFACEIMPL_INTERFACE,
> MONO_INTERFACEIMPL_SIZE
>};
>
>enum {
> MONO_MANIFEST_OFFSET,
> MONO_MANIFEST_FLAGS,
> MONO_MANIFEST_NAME,
> MONO_MANIFEST_IMPLEMENTATION,
> MONO_MANIFEST_SIZE
>};
>
>enum {
> MONO_MEMBERREF_CLASS,
> MONO_MEMBERREF_NAME,
> MONO_MEMBERREF_SIGNATURE,
> MONO_MEMBERREF_SIZE
>};
>
>enum {
> MONO_METHOD_RVA,
> MONO_METHOD_IMPLFLAGS,
> MONO_METHOD_FLAGS,
> MONO_METHOD_NAME,
> MONO_METHOD_SIGNATURE,
> MONO_METHOD_PARAMLIST,
> MONO_METHOD_SIZE
>};
>
>enum {
> MONO_METHODIMPL_CLASS,
> MONO_METHODIMPL_BODY,
> MONO_METHODIMPL_DECLARATION,
> MONO_METHODIMPL_SIZE
>};
>
>enum {
> MONO_METHOD_POINTER_METHOD,
> MONO_METHOD_POINTER_SIZE
>};
>
>enum {
> MONO_METHOD_SEMA_SEMANTICS,
> MONO_METHOD_SEMA_METHOD,
> MONO_METHOD_SEMA_ASSOCIATION,
> MONO_METHOD_SEMA_SIZE
>};
>
>enum {
> MONO_MODULE_GENERATION,
> MONO_MODULE_NAME,
> MONO_MODULE_MVID,
> MONO_MODULE_ENC,
> MONO_MODULE_ENCBASE,
> MONO_MODULE_SIZE
>};
>
>enum {
> MONO_MODULEREF_NAME,
> MONO_MODULEREF_SIZE
>};
>
>enum {
> MONO_NESTED_CLASS_NESTED,
> MONO_NESTED_CLASS_ENCLOSING,
> MONO_NESTED_CLASS_SIZE
>};
>
>enum {
> MONO_PARAM_FLAGS,
> MONO_PARAM_SEQUENCE,
> MONO_PARAM_NAME,
> MONO_PARAM_SIZE
>};
>
>enum {
> MONO_PARAM_POINTER_PARAM,
> MONO_PARAM_POINTER_SIZE
>};
>
>enum {
> MONO_PROPERTY_FLAGS,
> MONO_PROPERTY_NAME,
> MONO_PROPERTY_TYPE,
> MONO_PROPERTY_SIZE
>};
>
>enum {
> MONO_PROPERTY_POINTER_PROPERTY,
> MONO_PROPERTY_POINTER_SIZE
>};
>
>enum {
> MONO_PROPERTY_MAP_PARENT,
> MONO_PROPERTY_MAP_PROPERTY_LIST,
> MONO_PROPERTY_MAP_SIZE
>};
>
>enum {
> MONO_STAND_ALONE_SIGNATURE,
> MONO_STAND_ALONE_SIGNATURE_SIZE
>};
>
>enum {
> MONO_TYPEDEF_FLAGS,
> MONO_TYPEDEF_NAME,
> MONO_TYPEDEF_NAMESPACE,
> MONO_TYPEDEF_EXTENDS,
> MONO_TYPEDEF_FIELD_LIST,
> MONO_TYPEDEF_METHOD_LIST,
> MONO_TYPEDEF_SIZE
>};
>
>enum {
> MONO_TYPEREF_SCOPE,
> MONO_TYPEREF_NAME,
> MONO_TYPEREF_NAMESPACE,
> MONO_TYPEREF_SIZE
>};
>
>enum {
> MONO_TYPESPEC_SIGNATURE,
> MONO_TYPESPEC_SIZE
>};
>
>enum {
> MONO_GENERICPARAM_NUMBER,
> MONO_GENERICPARAM_FLAGS,
> MONO_GENERICPARAM_OWNER,
> MONO_GENERICPARAM_NAME,
>
> MONO_GENERICPARAM_SIZE
>};
>
>enum {
> MONO_METHODSPEC_METHOD,
> MONO_METHODSPEC_SIGNATURE,
> MONO_METHODSPEC_SIZE
>};
>
>enum {
> MONO_GENPARCONSTRAINT_GENERICPAR,
> MONO_GENPARCONSTRAINT_CONSTRAINT,
> MONO_GENPARCONSTRAINT_SIZE
>};
>
>
>
>
>
>
>
>enum {
> MONO_TYPEDEFORREF_TYPEDEF,
> MONO_TYPEDEFORREF_TYPEREF,
> MONO_TYPEDEFORREF_TYPESPEC,
> MONO_TYPEDEFORREF_BITS = 2,
> MONO_TYPEDEFORREF_MASK = 3
>};
>
>enum {
> MONO_HASCONSTANT_FIEDDEF,
> MONO_HASCONSTANT_PARAM,
> MONO_HASCONSTANT_PROPERTY,
> MONO_HASCONSTANT_BITS = 2,
> MONO_HASCONSTANT_MASK = 3
>};
>
>enum {
> MONO_CUSTOM_ATTR_METHODDEF,
> MONO_CUSTOM_ATTR_FIELDDEF,
> MONO_CUSTOM_ATTR_TYPEREF,
> MONO_CUSTOM_ATTR_TYPEDEF,
> MONO_CUSTOM_ATTR_PARAMDEF,
> MONO_CUSTOM_ATTR_INTERFACE,
> MONO_CUSTOM_ATTR_MEMBERREF,
> MONO_CUSTOM_ATTR_MODULE,
> MONO_CUSTOM_ATTR_PERMISSION,
> MONO_CUSTOM_ATTR_PROPERTY,
> MONO_CUSTOM_ATTR_EVENT,
> MONO_CUSTOM_ATTR_SIGNATURE,
> MONO_CUSTOM_ATTR_MODULEREF,
> MONO_CUSTOM_ATTR_TYPESPEC,
> MONO_CUSTOM_ATTR_ASSEMBLY,
> MONO_CUSTOM_ATTR_ASSEMBLYREF,
> MONO_CUSTOM_ATTR_FILE,
> MONO_CUSTOM_ATTR_EXP_TYPE,
> MONO_CUSTOM_ATTR_MANIFEST,
> MONO_CUSTOM_ATTR_GENERICPAR,
> MONO_CUSTOM_ATTR_BITS = 5,
> MONO_CUSTOM_ATTR_MASK = 0x1F
>};
>
>enum {
> MONO_HAS_FIELD_MARSHAL_FIELDSREF,
> MONO_HAS_FIELD_MARSHAL_PARAMDEF,
> MONO_HAS_FIELD_MARSHAL_BITS = 1,
> MONO_HAS_FIELD_MARSHAL_MASK = 1
>};
>
>enum {
> MONO_HAS_DECL_SECURITY_TYPEDEF,
> MONO_HAS_DECL_SECURITY_METHODDEF,
> MONO_HAS_DECL_SECURITY_ASSEMBLY,
> MONO_HAS_DECL_SECURITY_BITS = 2,
> MONO_HAS_DECL_SECURITY_MASK = 3
>};
>
>enum {
> MONO_MEMBERREF_PARENT_TYPEDEF,
> MONO_MEMBERREF_PARENT_TYPEREF,
> MONO_MEMBERREF_PARENT_MODULEREF,
> MONO_MEMBERREF_PARENT_METHODDEF,
> MONO_MEMBERREF_PARENT_TYPESPEC,
> MONO_MEMBERREF_PARENT_BITS = 3,
> MONO_MEMBERREF_PARENT_MASK = 7
>};
>
>enum {
> MONO_HAS_SEMANTICS_EVENT,
> MONO_HAS_SEMANTICS_PROPERTY,
> MONO_HAS_SEMANTICS_BITS = 1,
> MONO_HAS_SEMANTICS_MASK = 1
>};
>
>enum {
> MONO_METHODDEFORREF_METHODDEF,
> MONO_METHODDEFORREF_METHODREF,
> MONO_METHODDEFORREF_BITS = 1,
> MONO_METHODDEFORREF_MASK = 1
>};
>
>enum {
> MONO_MEMBERFORWD_FIELDDEF,
> MONO_MEMBERFORWD_METHODDEF,
> MONO_MEMBERFORWD_BITS = 1,
> MONO_MEMBERFORWD_MASK = 1
>};
>
>enum {
> MONO_IMPLEMENTATION_FILE,
> MONO_IMPLEMENTATION_ASSEMBLYREF,
> MONO_IMPLEMENTATION_EXP_TYPE,
> MONO_IMPLEMENTATION_BITS = 2,
> MONO_IMPLEMENTATION_MASK = 3
>};
>
>enum {
> MONO_CUSTOM_ATTR_TYPE_TYPEREF,
> MONO_CUSTOM_ATTR_TYPE_TYPEDEF,
> MONO_CUSTOM_ATTR_TYPE_METHODDEF,
> MONO_CUSTOM_ATTR_TYPE_MEMBERREF,
> MONO_CUSTOM_ATTR_TYPE_STRING,
> MONO_CUSTOM_ATTR_TYPE_BITS = 3,
> MONO_CUSTOM_ATTR_TYPE_MASK = 7
>};
>
>enum {
> MONO_RESOLTION_SCOPE_MODULE,
> MONO_RESOLTION_SCOPE_MODULEREF,
> MONO_RESOLTION_SCOPE_ASSEMBLYREF,
> MONO_RESOLTION_SCOPE_TYPEREF,
> MONO_RESOLTION_SCOPE_BITS = 2,
> MONO_RESOLTION_SCOPE_MASK = 3
>};
>
>enum {
> MONO_TYPEORMETHOD_TYPE,
> MONO_TYPEORMETHOD_METHOD,
> MONO_TYPEORMETHOD_BITS = 1,
> MONO_TYPEORMETHOD_MASK = 1
>};
># 9 "../../mono/metadata/metadata.h" 2
>
>
>
># 35 "../../mono/metadata/metadata.h"
>typedef struct _MonoClass MonoClass;
>typedef struct _MonoDomain MonoDomain;
>typedef struct _MonoMethod MonoMethod;
>
>typedef enum {
> MONO_EXCEPTION_CLAUSE_NONE,
> MONO_EXCEPTION_CLAUSE_FILTER,
> MONO_EXCEPTION_CLAUSE_FINALLY,
> MONO_EXCEPTION_CLAUSE_FAULT = 4
>} MonoExceptionEnum;
>
>typedef enum {
> MONO_CALL_DEFAULT,
> MONO_CALL_C,
> MONO_CALL_STDCALL,
> MONO_CALL_THISCALL,
> MONO_CALL_FASTCALL,
> MONO_CALL_VARARG
>} MonoCallConvention;
>
>
>typedef enum {
> MONO_NATIVE_BOOLEAN = 0x02,
> MONO_NATIVE_I1 = 0x03,
> MONO_NATIVE_U1 = 0x04,
> MONO_NATIVE_I2 = 0x05,
> MONO_NATIVE_U2 = 0x06,
> MONO_NATIVE_I4 = 0x07,
> MONO_NATIVE_U4 = 0x08,
> MONO_NATIVE_I8 = 0x09,
> MONO_NATIVE_U8 = 0x0a,
> MONO_NATIVE_R4 = 0x0b,
> MONO_NATIVE_R8 = 0x0c,
> MONO_NATIVE_CURRENCY = 0x0f,
> MONO_NATIVE_BSTR = 0x13,
> MONO_NATIVE_LPSTR = 0x14,
> MONO_NATIVE_LPWSTR = 0x15,
> MONO_NATIVE_LPTSTR = 0x16,
> MONO_NATIVE_BYVALTSTR = 0x17,
> MONO_NATIVE_IUNKNOWN = 0x19,
> MONO_NATIVE_IDISPATCH = 0x1a,
> MONO_NATIVE_STRUCT = 0x1b,
> MONO_NATIVE_INTERFACE = 0x1c,
> MONO_NATIVE_SAFEARRAY = 0x1d,
> MONO_NATIVE_BYVALARRAY = 0x1e,
> MONO_NATIVE_INT = 0x1f,
> MONO_NATIVE_UINT = 0x20,
> MONO_NATIVE_VBBYREFSTR = 0x22,
> MONO_NATIVE_ANSIBSTR = 0x23,
> MONO_NATIVE_TBSTR = 0x24,
> MONO_NATIVE_VARIANTBOOL = 0x25,
> MONO_NATIVE_FUNC = 0x26,
> MONO_NATIVE_ASANY = 0x28,
> MONO_NATIVE_LPARRAY = 0x2a,
> MONO_NATIVE_LPSTRUCT = 0x2b,
> MONO_NATIVE_CUSTOM = 0x2c,
> MONO_NATIVE_ERROR = 0x2d,
> MONO_NATIVE_MAX = 0x50
>} MonoMarshalNative;
>
>
>typedef enum {
> MONO_VARIANT_EMPTY = 0x00,
> MONO_VARIANT_NULL = 0x01,
> MONO_VARIANT_I2 = 0x02,
> MONO_VARIANT_I4 = 0x03,
> MONO_VARIANT_R4 = 0x04,
> MONO_VARIANT_R8 = 0x05,
> MONO_VARIANT_CY = 0x06,
> MONO_VARIANT_DATE = 0x07,
> MONO_VARIANT_BSTR = 0x08,
> MONO_VARIANT_DISPATCH = 0x09,
> MONO_VARIANT_ERROR = 0x0a,
> MONO_VARIANT_BOOL = 0x0b,
> MONO_VARIANT_VARIANT = 0x0c,
> MONO_VARIANT_UNKNOWN = 0x0d,
> MONO_VARIANT_DECIMAL = 0x0e,
> MONO_VARIANT_I1 = 0x10,
> MONO_VARIANT_UI1 = 0x11,
> MONO_VARIANT_UI2 = 0x12,
> MONO_VARIANT_UI4 = 0x13,
> MONO_VARIANT_I8 = 0x14,
> MONO_VARIANT_UI8 = 0x15,
> MONO_VARIANT_INT = 0x16,
> MONO_VARIANT_UINT = 0x17,
> MONO_VARIANT_VOID = 0x18,
> MONO_VARIANT_HRESULT = 0x19,
> MONO_VARIANT_PTR = 0x1a,
> MONO_VARIANT_SAFEARRAY = 0x1b,
> MONO_VARIANT_CARRAY = 0x1c,
> MONO_VARIANT_USERDEFINED = 0x1d,
> MONO_VARIANT_LPSTR = 0x1e,
> MONO_VARIANT_LPWSTR = 0x1f,
> MONO_VARIANT_RECORD = 0x24,
> MONO_VARIANT_FILETIME = 0x40,
> MONO_VARIANT_BLOB = 0x41,
> MONO_VARIANT_STREAM = 0x42,
> MONO_VARIANT_STORAGE = 0x43,
> MONO_VARIANT_STREAMED_OBJECT = 0x44,
> MONO_VARIANT_STORED_OBJECT = 0x45,
> MONO_VARIANT_BLOB_OBJECT = 0x46,
> MONO_VARIANT_CF = 0x47,
> MONO_VARIANT_CLSID = 0x48,
> MONO_VARIANT_VECTOR = 0x1000,
> MONO_VARIANT_ARRAY = 0x2000,
> MONO_VARIANT_BYREF = 0x4000
>} MonoMarshalVariant;
>
>typedef enum {
> MONO_MARSHAL_CONV_NONE,
> MONO_MARSHAL_CONV_BOOL_VARIANTBOOL,
> MONO_MARSHAL_CONV_BOOL_I4,
> MONO_MARSHAL_CONV_STR_BSTR,
> MONO_MARSHAL_CONV_STR_LPSTR,
> MONO_MARSHAL_CONV_LPSTR_STR,
> MONO_MARSHAL_CONV_LPTSTR_STR,
> MONO_MARSHAL_CONV_STR_LPWSTR,
> MONO_MARSHAL_CONV_LPWSTR_STR,
> MONO_MARSHAL_CONV_STR_LPTSTR,
> MONO_MARSHAL_CONV_STR_ANSIBSTR,
> MONO_MARSHAL_CONV_STR_TBSTR,
> MONO_MARSHAL_CONV_STR_BYVALSTR,
> MONO_MARSHAL_CONV_STR_BYVALWSTR,
> MONO_MARSHAL_CONV_SB_LPSTR,
> MONO_MARSHAL_CONV_SB_LPTSTR,
> MONO_MARSHAL_CONV_SB_LPWSTR,
> MONO_MARSHAL_CONV_LPSTR_SB,
> MONO_MARSHAL_CONV_LPTSTR_SB,
> MONO_MARSHAL_CONV_LPWSTR_SB,
> MONO_MARSHAL_CONV_ARRAY_BYVALARRAY,
> MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY,
> MONO_MARSHAL_CONV_ARRAY_SAVEARRAY,
> MONO_MARSHAL_CONV_ARRAY_LPARRAY,
> MONO_MARSHAL_FREE_LPARRAY,
> MONO_MARSHAL_CONV_OBJECT_INTERFACE,
> MONO_MARSHAL_CONV_OBJECT_IDISPATCH,
> MONO_MARSHAL_CONV_OBJECT_IUNKNOWN,
> MONO_MARSHAL_CONV_OBJECT_STRUCT,
> MONO_MARSHAL_CONV_DEL_FTN,
> MONO_MARSHAL_CONV_FTN_DEL,
> MONO_MARSHAL_FREE_ARRAY,
> MONO_MARSHAL_CONV_BSTR_STR,
> MONO_MARSHAL_CONV_SAFEHANDLE,
> MONO_MARSHAL_CONV_HANDLEREF
>} MonoMarshalConv;
>
>typedef struct {
> MonoMarshalNative native;
> union {
>  struct {
>   MonoMarshalNative elem_type;
>   int32_t num_elem;
>   int16_t param_num;
>   int16_t elem_mult;
>  } array_data;
>  struct {
>   char *custom_name;
>   char *cookie;
>  } custom_data;
>  struct {
>   MonoMarshalVariant elem_type;
>   int32_t num_elem;
>  } safearray_data;
> } data;
>} MonoMarshalSpec;
>
>void mono_metadata_init (void);
>
>void mono_metadata_decode_row (const MonoTableInfo *t,
>           int idx,
>           uint32_t *res,
>           int res_size);
>
>uint32_t mono_metadata_decode_row_col (const MonoTableInfo *t,
>        int idx,
>        unsigned int col);
># 219 "../../mono/metadata/metadata.h"
>int mono_metadata_compute_size (MonoImage *meta,
>                                int tableindex,
>                                uint32_t *result_bitfield);
>
>
>
>
>const char *mono_metadata_locate (MonoImage *meta, int table, int idx);
>const char *mono_metadata_locate_token (MonoImage *meta, uint32_t token);
>
>const char *mono_metadata_string_heap (MonoImage *meta, uint32_t table_index);
>const char *mono_metadata_blob_heap (MonoImage *meta, uint32_t table_index);
>const char *mono_metadata_user_string (MonoImage *meta, uint32_t table_index);
>const char *mono_metadata_guid_heap (MonoImage *meta, uint32_t table_index);
>
>uint32_t mono_metadata_typedef_from_field (MonoImage *meta, uint32_t table_index);
>uint32_t mono_metadata_typedef_from_method (MonoImage *meta, uint32_t table_index);
>uint32_t mono_metadata_nested_in_typedef (MonoImage *meta, uint32_t table_index);
>uint32_t mono_metadata_nesting_typedef (MonoImage *meta, uint32_t table_index, uint32_t start_index);
>
>MonoClass** mono_metadata_interfaces_from_typedef (MonoImage *meta, uint32_t table_index, unsigned int *count);
>
>uint32_t mono_metadata_events_from_typedef (MonoImage *meta, uint32_t table_index, unsigned int *end_idx);
>uint32_t mono_metadata_methods_from_event (MonoImage *meta, uint32_t table_index, unsigned int *end);
>uint32_t mono_metadata_properties_from_typedef (MonoImage *meta, uint32_t table_index, unsigned int *end);
>uint32_t mono_metadata_methods_from_property (MonoImage *meta, uint32_t table_index, unsigned int *end);
>uint32_t mono_metadata_packing_from_typedef (MonoImage *meta, uint32_t table_index, uint32_t *packing, uint32_t *size);
>const char* mono_metadata_get_marshal_info (MonoImage *meta, uint32_t idx, mono_bool is_field);
>uint32_t mono_metadata_custom_attrs_from_index (MonoImage *meta, uint32_t cattr_index);
>
>MonoMarshalSpec *mono_metadata_parse_marshal_spec (MonoImage *image, const char *ptr);
>
>void mono_metadata_free_marshal_spec (MonoMarshalSpec *spec);
>
>uint32_t mono_metadata_implmap_from_method (MonoImage *meta, uint32_t method_idx);
>
>void mono_metadata_field_info (MonoImage *meta,
>          uint32_t table_index,
>          uint32_t *offset,
>          uint32_t *rva,
>          MonoMarshalSpec **marshal_spec);
>
>uint32_t mono_metadata_get_constant_index (MonoImage *meta, uint32_t token, uint32_t hint);
>
>
>
>
>uint32_t mono_metadata_decode_value (const char *ptr,
>                                        const char **rptr);
>int32_t mono_metadata_decode_signed_value (const char *ptr, const char **rptr);
>
>uint32_t mono_metadata_decode_blob_size (const char *ptr,
>                                        const char **rptr);
>
>void mono_metadata_encode_value (uint32_t value, char *bug, char **endbuf);
># 282 "../../mono/metadata/metadata.h"
>typedef struct {
> uint32_t flags;
> uint32_t try_offset;
> uint32_t try_len;
> uint32_t handler_offset;
> uint32_t handler_len;
> union {
>  uint32_t filter_offset;
>  MonoClass *catch_class;
> } data;
>} MonoExceptionClause;
>
>typedef struct _MonoType MonoType;
>typedef struct _MonoGenericInst MonoGenericInst;
>typedef struct _MonoGenericClass MonoGenericClass;
>typedef struct _MonoDynamicGenericClass MonoDynamicGenericClass;
>typedef struct _MonoGenericContext MonoGenericContext;
>typedef struct _MonoGenericContainer MonoGenericContainer;
>typedef struct _MonoGenericParam MonoGenericParam;
>typedef struct _MonoArrayType MonoArrayType;
>typedef struct _MonoMethodSignature MonoMethodSignature;
>
>
>typedef struct invalid_name MonoGenericMethod;
>
>typedef struct {
> unsigned int required : 1;
> unsigned int token : 31;
>} MonoCustomMod;
>
>struct _MonoArrayType {
> MonoClass *eklass;
> uint8_t rank;
> uint8_t numsizes;
> uint8_t numlobounds;
> int *sizes;
> int *lobounds;
>};
>
>typedef struct _MonoMethodHeader MonoMethodHeader;
>
>typedef enum {
> MONO_PARSE_TYPE,
> MONO_PARSE_MOD_TYPE,
> MONO_PARSE_LOCAL,
> MONO_PARSE_PARAM,
> MONO_PARSE_RET,
> MONO_PARSE_FIELD
>} MonoParseTypeMode;
>
>mono_bool
>mono_type_is_byref (MonoType *type);
>
>int
>mono_type_get_type (MonoType *type);
>
>
>MonoMethodSignature*
>mono_type_get_signature (MonoType *type);
>
>
>MonoClass*
>mono_type_get_class (MonoType *type);
>
>MonoArrayType*
>mono_type_get_array_type (MonoType *type);
>
>
>MonoType*
>mono_type_get_ptr_type (MonoType *type);
>
>MonoClass*
>mono_type_get_modifiers (MonoType *type, mono_bool *is_required, void **iter);
>
>mono_bool mono_type_is_struct (MonoType *type);
>mono_bool mono_type_is_void (MonoType *type);
>mono_bool mono_type_is_pointer (MonoType *type);
>mono_bool mono_type_is_reference (MonoType *type);
>
>MonoType*
>mono_signature_get_return_type (MonoMethodSignature *sig);
>
>MonoType*
>mono_signature_get_params (MonoMethodSignature *sig, void **iter);
>
>uint32_t
>mono_signature_get_param_count (MonoMethodSignature *sig);
>
>uint32_t
>mono_signature_get_call_conv (MonoMethodSignature *sig);
>
>int
>mono_signature_vararg_start (MonoMethodSignature *sig);
>
>mono_bool
>mono_signature_is_instance (MonoMethodSignature *sig);
>
>mono_bool
>mono_signature_explicit_this (MonoMethodSignature *sig);
>
>uint32_t mono_metadata_parse_typedef_or_ref (MonoImage *m,
>                                                const char *ptr,
>                                                const char **rptr);
>int mono_metadata_parse_custom_mod (MonoImage *m,
>      MonoCustomMod *dest,
>      const char *ptr,
>      const char **rptr);
>MonoArrayType *mono_metadata_parse_array (MonoImage *m,
>      const char *ptr,
>      const char **rptr);
>void mono_metadata_free_array (MonoArrayType *array);
>MonoType *mono_metadata_parse_type (MonoImage *m,
>      MonoParseTypeMode mode,
>      short opt_attrs,
>      const char *ptr,
>      const char **rptr);
>MonoType *mono_metadata_parse_param (MonoImage *m,
>      const char *ptr,
>      const char **rptr);
>MonoType *mono_metadata_parse_ret_type (MonoImage *m,
>      const char *ptr,
>      const char **rptr);
>MonoType *mono_metadata_parse_field_type (MonoImage *m,
>                                  short field_flags,
>      const char *ptr,
>      const char **rptr);
>MonoType *mono_type_create_from_typespec (MonoImage *image,
>             uint32_t type_spec);
>void mono_metadata_free_type (MonoType *type);
>int mono_type_size (MonoType *type,
>      int *alignment);
>int mono_type_stack_size (MonoType *type,
>      int *alignment);
>
>mono_bool mono_type_generic_inst_is_valuetype (MonoType *type);
>mono_bool mono_metadata_generic_class_is_valuetype (MonoGenericClass *gclass);
>unsigned int mono_metadata_generic_class_hash (MonoGenericClass *gclass);
>mono_bool mono_metadata_generic_class_equal (MonoGenericClass *g1, MonoGenericClass *g2);
>
>unsigned int mono_metadata_type_hash (MonoType *t1);
>mono_bool mono_metadata_type_equal (MonoType *t1, MonoType *t2);
>
>MonoMethodSignature *mono_metadata_signature_alloc (MonoImage *image, uint32_t nparams);
>
>MonoMethodSignature *mono_metadata_signature_dup (MonoMethodSignature *sig);
>
>MonoMethodSignature *mono_metadata_parse_signature (MonoImage *image,
>           uint32_t token);
>
>MonoMethodSignature *mono_metadata_parse_method_signature (MonoImage *m,
>                                                            int def,
>                                                            const char *ptr,
>                                                            const char **rptr);
>void mono_metadata_free_method_signature (MonoMethodSignature *method);
>
>mono_bool mono_metadata_signature_equal (MonoMethodSignature *sig1,
>       MonoMethodSignature *sig2);
>
>unsigned int mono_signature_hash (MonoMethodSignature *sig);
>
>MonoMethodHeader *mono_metadata_parse_mh (MonoImage *m, const char *ptr);
>void mono_metadata_free_mh (MonoMethodHeader *mh);
>
>
>const unsigned char*
>mono_method_header_get_code (MonoMethodHeader *header, uint32_t* code_size, uint32_t* max_stack);
>
>MonoType**
>mono_method_header_get_locals (MonoMethodHeader *header, uint32_t* num_locals, mono_bool *init_locals);
>
>int
>mono_method_header_get_num_clauses (MonoMethodHeader *header);
>
>int
>mono_method_header_get_clauses (MonoMethodHeader *header, MonoMethod *method, void **iter, MonoExceptionClause *clause);
>
>uint32_t
>mono_type_to_unmanaged (MonoType *type, MonoMarshalSpec *mspec,
>   mono_bool as_field, mono_bool unicode, MonoMarshalConv *conv);
># 480 "../../mono/metadata/metadata.h"
>uint32_t mono_metadata_token_from_dor (uint32_t dor_index);
>
>char *mono_guid_to_string (const uint8_t *guid);
>
>uint32_t mono_metadata_declsec_from_index (MonoImage *meta, uint32_t idx);
>
>uint32_t mono_metadata_translate_token_index (MonoImage *image, int table, uint32_t idx);
>
>void mono_metadata_decode_table_row (MonoImage *image, int table,
>           int idx,
>           uint32_t *res,
>           int res_size);
>
>uint32_t mono_metadata_decode_table_row_col (MonoImage *image, int table,
>        int idx,
>        unsigned int col);
>
>
># 5 "../../mono/metadata/loader.h" 2
>
>
>
>
>typedef mono_bool (*MonoStackWalk) (MonoMethod *method, int32_t native_offset, int32_t il_offset, mono_bool managed, void* data);
>
>MonoMethod *
>mono_get_method (MonoImage *image, uint32_t token, MonoClass *klass);
>
>MonoMethod *
>mono_get_method_full (MonoImage *image, uint32_t token, MonoClass *klass,
>        MonoGenericContext *context);
>
>MonoMethod *
>mono_get_method_constrained (MonoImage *image, uint32_t token, MonoClass *constrained_class,
>        MonoGenericContext *context, MonoMethod **cil_method);
>
>void
>mono_free_method (MonoMethod *method);
>
>MonoMethodSignature*
>mono_method_get_signature_full (MonoMethod *method, MonoImage *image, uint32_t token,
>    MonoGenericContext *context);
>
>MonoMethodSignature*
>mono_method_get_signature (MonoMethod *method, MonoImage *image, uint32_t token);
>
>MonoMethodSignature*
>mono_method_signature (MonoMethod *method);
>
>MonoMethodHeader*
>mono_method_get_header (MonoMethod *method);
>
>const char*
>mono_method_get_name (MonoMethod *method);
>
>MonoClass*
>mono_method_get_class (MonoMethod *method);
>
>uint32_t
>mono_method_get_token (MonoMethod *method);
>
>uint32_t
>mono_method_get_flags (MonoMethod *method, uint32_t *iflags);
>
>uint32_t
>mono_method_get_index (MonoMethod *method);
>
>MonoImage *
>mono_load_image (const char *fname, MonoImageOpenStatus *status);
>
>void
>mono_add_internal_call (const char *name, const void* method);
>
>void*
>mono_lookup_internal_call (MonoMethod *method);
>
>void
>mono_dllmap_insert (MonoImage *assembly, const char *dll, const char *func, const char *tdll, const char *tfunc);
>
>void*
>mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char **exc_arg);
>
>void
>mono_method_get_param_names (MonoMethod *method, const char **names);
>
>uint32_t
>mono_method_get_param_token (MonoMethod *method, int idx);
>
>void
>mono_method_get_marshal_info (MonoMethod *method, MonoMarshalSpec **mspecs);
>
>mono_bool
>mono_method_has_marshal_info (MonoMethod *method);
>
>MonoMethod*
>mono_method_get_last_managed (void);
>
>void
>mono_stack_walk (MonoStackWalk func, void* user_data);
>
>
>void
>mono_stack_walk_no_il (MonoStackWalk func, void* user_data);
>
>
># 37 "method-to-ir.c" 2
># 1 "../../mono/metadata/tabledefs.h" 1
># 20 "../../mono/metadata/tabledefs.h"
>enum {
> ASSEMBLY_HASH_NONE,
> ASSEMBLY_HASH_MD5 = 0x8003,
> ASSEMBLY_HASH_SHA1 = 0x8004
>};
>
>
>
>
>
>enum {
> EVENT_SPECIALNAME = 0x0200,
> EVENT_RTSPECIALNAME = 0x0400
>};
>
>
>
>
>
>enum {
> FILE_CONTAINS_METADATA = 0,
> FILE_CONTAINS_NO_METADATA = 1
>};
>
>
>
>enum {
> SECURITY_ACTION_DEMAND = 2,
> SECURITY_ACTION_ASSERT = 3,
> SECURITY_ACTION_DENY = 4,
> SECURITY_ACTION_PERMITONLY = 5,
> SECURITY_ACTION_LINKDEMAND = 6,
> SECURITY_ACTION_INHERITDEMAND = 7,
> SECURITY_ACTION_REQMIN = 8,
> SECURITY_ACTION_REQOPT = 9,
> SECURITY_ACTION_REQREFUSE = 10,
>
> SECURITY_ACTION_NONCASDEMAND = 13,
> SECURITY_ACTION_NONCASLINKDEMAND = 14,
> SECURITY_ACTION_NONCASINHERITANCE = 15,
>
> SECURITY_ACTION_LINKDEMANDCHOICE = 16,
> SECURITY_ACTION_INHERITDEMANDCHOICE = 17,
> SECURITY_ACTION_DEMANDCHOICE = 18
>};
># 38 "method-to-ir.c" 2
># 1 "../../mono/metadata/class.h" 1
>
>
>
>
>
>
>
>
>
>typedef struct MonoVTable MonoVTable;
>
>typedef struct _MonoClassField MonoClassField;
>typedef struct _MonoProperty MonoProperty;
>typedef struct _MonoEvent MonoEvent;
>
>MonoClass *
>mono_class_get (MonoImage *image, uint32_t type_token);
>
>MonoClass *
>mono_class_get_full (MonoImage *image, uint32_t type_token, MonoGenericContext *context);
>
>mono_bool
>mono_class_init (MonoClass *klass);
>
>MonoVTable *
>mono_class_vtable (MonoDomain *domain, MonoClass *klass);
>
>MonoClass *
>mono_class_from_name (MonoImage *image, const char* name_space, const char *name);
>
>MonoClass *
>mono_class_from_name_case (MonoImage *image, const char* name_space, const char *name);
>
>MonoMethod *
>mono_class_get_method_from_name_flags (MonoClass *klass, const char *name, int param_count, int flags);
>
>MonoClass *
>mono_class_from_typeref (MonoImage *image, uint32_t type_token);
>
>MonoClass *
>mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, mono_bool is_mvar);
>
>MonoType*
>mono_class_inflate_generic_type (MonoType *type, MonoGenericContext *context) ;
>
>MonoMethod*
>mono_class_inflate_generic_method (MonoMethod *method, MonoGenericContext *context);
>
>MonoMethod *
>mono_get_inflated_method (MonoMethod *method);
>
>MonoClassField*
>mono_field_from_token (MonoImage *image, uint32_t token, MonoClass **retklass, MonoGenericContext *context);
>
>MonoClass *
>mono_bounded_array_class_get (MonoClass *element_class, uint32_t rank, mono_bool bounded);
>
>MonoClass *
>mono_array_class_get (MonoClass *element_class, uint32_t rank);
>
>MonoClass *
>mono_ptr_class_get (MonoType *type);
>
>MonoClassField *
>mono_class_get_field (MonoClass *klass, uint32_t field_token);
>
>MonoClassField *
>mono_class_get_field_from_name (MonoClass *klass, const char *name);
>
>uint32_t
>mono_class_get_field_token (MonoClassField *field);
>
>uint32_t
>mono_class_get_event_token (MonoEvent *event);
>
>MonoProperty*
>mono_class_get_property_from_name (MonoClass *klass, const char *name);
>
>uint32_t
>mono_class_get_property_token (MonoProperty *prop);
>
>int32_t
>mono_array_element_size (MonoClass *ac);
>
>int32_t
>mono_class_instance_size (MonoClass *klass);
>
>int32_t
>mono_class_array_element_size (MonoClass *klass);
>
>int32_t
>mono_class_data_size (MonoClass *klass);
>
>int32_t
>mono_class_value_size (MonoClass *klass, uint32_t *align);
>
>int32_t
>mono_class_min_align (MonoClass *klass);
>
>MonoClass *
>mono_class_from_mono_type (MonoType *type);
>
>mono_bool
>mono_class_is_subclass_of (MonoClass *klass, MonoClass *klassc,
>         mono_bool check_interfaces);
>
>mono_bool
>mono_class_is_assignable_from (MonoClass *klass, MonoClass *oklass);
>
>void*
>mono_ldtoken (MonoImage *image, uint32_t token, MonoClass **retclass, MonoGenericContext *context);
>
>char*
>mono_type_get_name (MonoType *type);
>
>MonoType*
>mono_type_get_underlying_type (MonoType *type);
>
>
>MonoImage*
>mono_class_get_image (MonoClass *klass);
>
>MonoClass*
>mono_class_get_element_class (MonoClass *klass);
>
>mono_bool
>mono_class_is_valuetype (MonoClass *klass);
>
>mono_bool
>mono_class_is_enum (MonoClass *klass);
>
>MonoType*
>mono_class_enum_basetype (MonoClass *klass);
>
>MonoClass*
>mono_class_get_parent (MonoClass *klass);
>
>MonoClass*
>mono_class_get_nesting_type (MonoClass *klass);
>
>int
>mono_class_get_rank (MonoClass *klass);
>
>uint32_t
>mono_class_get_flags (MonoClass *klass);
>
>const char*
>mono_class_get_name (MonoClass *klass);
>
>const char*
>mono_class_get_namespace (MonoClass *klass);
>
>MonoType*
>mono_class_get_type (MonoClass *klass);
>
>uint32_t
>mono_class_get_type_token (MonoClass *klass);
>
>MonoType*
>mono_class_get_byref_type (MonoClass *klass);
>
>int
>mono_class_num_fields (MonoClass *klass);
>
>int
>mono_class_num_methods (MonoClass *klass);
>
>int
>mono_class_num_properties (MonoClass *klass);
>
>int
>mono_class_num_events (MonoClass *klass);
>
>MonoClassField*
>mono_class_get_fields (MonoClass* klass, void **iter);
>
>MonoMethod*
>mono_class_get_methods (MonoClass* klass, void **iter);
>
>MonoProperty*
>mono_class_get_properties (MonoClass* klass, void **iter);
>
>MonoEvent*
>mono_class_get_events (MonoClass* klass, void **iter);
>
>MonoClass*
>mono_class_get_interfaces (MonoClass* klass, void **iter);
>
>MonoClass*
>mono_class_get_nested_types (MonoClass* klass, void **iter);
>
>
>const char*
>mono_field_get_name (MonoClassField *field);
>
>MonoType*
>mono_field_get_type (MonoClassField *field);
>
>MonoClass*
>mono_field_get_parent (MonoClassField *field);
>
>uint32_t
>mono_field_get_flags (MonoClassField *field);
>
>uint32_t
>mono_field_get_offset (MonoClassField *field);
>
>const char *
>mono_field_get_data (MonoClassField *field);
>
>
>const char*
>mono_property_get_name (MonoProperty *prop);
>
>MonoMethod*
>mono_property_get_set_method (MonoProperty *prop);
>
>MonoMethod*
>mono_property_get_get_method (MonoProperty *prop);
>
>MonoClass*
>mono_property_get_parent (MonoProperty *prop);
>
>uint32_t
>mono_property_get_flags (MonoProperty *prop);
>
>
>const char*
>mono_event_get_name (MonoEvent *event);
>
>MonoMethod*
>mono_event_get_add_method (MonoEvent *event);
>
>MonoMethod*
>mono_event_get_remove_method (MonoEvent *event);
>
>MonoMethod*
>mono_event_get_remove_method (MonoEvent *event);
>
>MonoMethod*
>mono_event_get_raise_method (MonoEvent *event);
>
>MonoClass*
>mono_event_get_parent (MonoEvent *event);
>
>uint32_t
>mono_event_get_flags (MonoEvent *event);
>
>MonoMethod *
>mono_class_get_method_from_name (MonoClass *klass, const char *name, int param_count);
>
>char *
>mono_class_name_from_token (MonoImage *image, uint32_t type_token);
>
>mono_bool
>mono_method_can_access_field (MonoMethod *method, MonoClassField *field);
>
>mono_bool
>mono_method_can_access_method (MonoMethod *method, MonoMethod *called);
>
>
># 39 "method-to-ir.c" 2
># 1 "../../mono/metadata/object.h" 1
>
>
>
>
># 1 "../../mono/utils/mono-error.h" 1
>
>
>
>
>
>enum {
>
>
>
> MONO_ERROR_FREE_STRINGS = 0x0001,
>
>
>
>
> MONO_ERROR_INCOMPLETE = 0x0002
>};
>
>enum {
> MONO_ERROR_NONE = 0,
> MONO_ERROR_MISSING_METHOD = 1,
> MONO_ERROR_MISSING_FIELD = 2,
> MONO_ERROR_TYPE_LOAD = 3,
> MONO_ERROR_FILE_NOT_FOUND = 4,
> MONO_ERROR_BAD_IMAGE = 5,
> MONO_ERROR_OUT_OF_MEMORY = 6,
> MONO_ERROR_ARGUMENT = 7,
> MONO_ERROR_NOT_VERIFIABLE = 8,
>
>
>
>
> MONO_ERROR_GENERIC = 9
>};
>
>
>typedef struct {
> unsigned short error_code;
>    unsigned short hidden_0;
>
> void *hidden_1 [12];
>    char hidden_2 [128];
>} MonoError;
>
>
>
>void
>mono_error_init (MonoError *error);
>
>void
>mono_error_init_flags (MonoError *error, unsigned short flags);
>
>void
>mono_error_cleanup (MonoError *error);
>
>mono_bool
>mono_error_ok (MonoError *error);
>
>unsigned short
>mono_error_get_error_code (MonoError *error);
>
>const char*
>mono_error_get_message (MonoError *error);
>
>
># 6 "../../mono/metadata/object.h" 2
>
>
>
>typedef mono_byte MonoBoolean;
>
>typedef struct _MonoString MonoString;
>typedef struct _MonoArray MonoArray;
>typedef struct _MonoReflectionMethod MonoReflectionMethod;
>typedef struct _MonoReflectionAssembly MonoReflectionAssembly;
>typedef struct _MonoReflectionModule MonoReflectionModule;
>typedef struct _MonoReflectionField MonoReflectionField;
>typedef struct _MonoReflectionProperty MonoReflectionProperty;
>typedef struct _MonoReflectionEvent MonoReflectionEvent;
>typedef struct _MonoReflectionType MonoReflectionType;
>typedef struct _MonoDelegate MonoDelegate;
>typedef struct _MonoException MonoException;
>typedef struct _MonoThreadsSync MonoThreadsSync;
>typedef struct _MonoThread MonoThread;
>typedef struct _MonoDynamicAssembly MonoDynamicAssembly;
>typedef struct _MonoDynamicImage MonoDynamicImage;
>typedef struct _MonoReflectionMethodBody MonoReflectionMethodBody;
>typedef struct _MonoAppContext MonoAppContext;
>
>typedef struct {
> MonoVTable *vtable;
> MonoThreadsSync *synchronisation;
>} MonoObject;
>
>typedef MonoObject* (*MonoInvokeFunc) (MonoMethod *method, void *obj, void **params, MonoObject **exc);
>typedef void* (*MonoCompileFunc) (MonoMethod *method);
>typedef void (*MonoMainThreadFunc) (void* user_data);
># 68 "../../mono/metadata/object.h"
>mono_unichar2 *mono_string_chars (MonoString *s);
>int mono_string_length (MonoString *s);
>
>MonoObject *
>mono_object_new (MonoDomain *domain, MonoClass *klass);
>
>MonoObject *
>mono_object_new_specific (MonoVTable *vtable);
>
>
>MonoObject *
>mono_object_new_fast (MonoVTable *vtable);
>
>MonoObject *
>mono_object_new_alloc_specific (MonoVTable *vtable);
>
>MonoObject *
>mono_object_new_from_token (MonoDomain *domain, MonoImage *image, uint32_t token);
>
>MonoArray*
>mono_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n);
>
>MonoArray*
>mono_array_new_full (MonoDomain *domain, MonoClass *array_class,
>        uintptr_t *lengths, intptr_t *lower_bounds);
>
>MonoArray *
>mono_array_new_specific (MonoVTable *vtable, uintptr_t n);
>
>MonoArray*
>mono_array_clone (MonoArray *array);
>
>char*
>mono_array_addr_with_size (MonoArray *array, int size, uintptr_t idx);
>
>uintptr_t
>mono_array_length (MonoArray *array);
>
>MonoString*
>mono_string_new_utf16 (MonoDomain *domain, const mono_unichar2 *text, int32_t len);
>
>MonoString*
>mono_string_new_size (MonoDomain *domain, int32_t len);
>
>MonoString*
>mono_ldstr (MonoDomain *domain, MonoImage *image, uint32_t str_index);
>
>MonoString*
>mono_string_is_interned (MonoString *str);
>
>MonoString*
>mono_string_intern (MonoString *str);
>
>MonoString*
>mono_string_new (MonoDomain *domain, const char *text);
>
>MonoString*
>mono_string_new_wrapper (const char *text);
>
>MonoString*
>mono_string_new_len (MonoDomain *domain, const char *text, unsigned int length);
>
>char *
>mono_string_to_utf8 (MonoString *string_obj);
>
>char *
>mono_string_to_utf8_checked (MonoString *string_obj, MonoError *error);
>
>mono_unichar2 *
>mono_string_to_utf16 (MonoString *string_obj);
>
>MonoString *
>mono_string_from_utf16 (mono_unichar2 *data);
>
>mono_bool
>mono_string_equal (MonoString *s1, MonoString *s2);
>
>unsigned int
>mono_string_hash (MonoString *s);
>
>int
>mono_object_hash (MonoObject* obj);
>
>MonoString *
>mono_object_to_string (MonoObject *obj, MonoObject **exc);
>
>MonoObject *
>mono_value_box (MonoDomain *domain, MonoClass *klass, void* val);
>
>void
>mono_value_copy (void* dest, void* src, MonoClass *klass);
>
>void
>mono_value_copy_array (MonoArray *dest, int dest_idx, void* src, int count);
>
>MonoDomain*
>mono_object_get_domain (MonoObject *obj);
>
>MonoClass*
>mono_object_get_class (MonoObject *obj);
>
>void*
>mono_object_unbox (MonoObject *obj);
>
>MonoObject *
>mono_object_clone (MonoObject *obj);
>
>MonoObject *
>mono_object_isinst (MonoObject *obj, MonoClass *klass);
>
>MonoObject *
>mono_object_isinst_mbyref (MonoObject *obj, MonoClass *klass);
>
>MonoObject *
>mono_object_castclass_mbyref (MonoObject *obj, MonoClass *klass);
>
>mono_bool
>mono_monitor_try_enter (MonoObject *obj, uint32_t ms);
>
>mono_bool
>mono_monitor_enter (MonoObject *obj);
>
>unsigned int
>mono_object_get_size (MonoObject *o);
>
>void
>mono_monitor_exit (MonoObject *obj);
>
>void
>mono_raise_exception (MonoException *ex);
>
>void
>mono_runtime_object_init (MonoObject *this_obj);
>
>void
>mono_runtime_class_init (MonoVTable *vtable);
>
>MonoMethod*
>mono_object_get_virtual_method (MonoObject *obj, MonoMethod *method);
>
>MonoObject*
>mono_runtime_invoke (MonoMethod *method, void *obj, void **params,
>        MonoObject **exc);
>
>MonoMethod *
>mono_get_delegate_invoke (MonoClass *klass);
>
>MonoObject*
>mono_runtime_delegate_invoke (MonoObject *delegate, void **params,
>         MonoObject **exc);
>
>MonoObject*
>mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
>        MonoObject **exc);
>
>void*
>mono_method_get_unmanaged_thunk (MonoMethod *method);
>
>MonoArray*
>mono_runtime_get_main_args (void);
>
>void
>mono_runtime_exec_managed_code (MonoDomain *domain,
>    MonoMainThreadFunc main_func,
>    void* main_args);
>
>int
>mono_runtime_run_main (MonoMethod *method, int argc, char* argv[],
>        MonoObject **exc);
>
>int
>mono_runtime_exec_main (MonoMethod *method, MonoArray *args,
>        MonoObject **exc);
>
>void*
>mono_load_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void **res);
>
>MonoObject *
>mono_load_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field);
>
>void
>mono_store_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void* val);
>
>void
>mono_store_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg);
>
>void
>mono_unhandled_exception (MonoObject *exc);
>
>void
>mono_print_unhandled_exception (MonoObject *exc);
>
>void*
>mono_compile_method (MonoMethod *method);
>
>
>void
>mono_field_set_value (MonoObject *obj, MonoClassField *field, void *value);
>
>void
>mono_field_static_set_value (MonoVTable *vt, MonoClassField *field, void *value);
>
>void
>mono_field_get_value (MonoObject *obj, MonoClassField *field, void *value);
>
>void
>mono_field_static_get_value (MonoVTable *vt, MonoClassField *field, void *value);
>
>MonoObject *
>mono_field_get_value_object (MonoDomain *domain, MonoClassField *field, MonoObject *obj);
>
>void
>mono_property_set_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc);
>
>MonoObject*
>mono_property_get_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc);
># 299 "../../mono/metadata/object.h"
>uint32_t mono_gchandle_new (MonoObject *obj, mono_bool pinned);
>uint32_t mono_gchandle_new_weakref (MonoObject *obj, mono_bool track_resurrection);
>MonoObject* mono_gchandle_get_target (uint32_t gchandle);
>void mono_gchandle_free (uint32_t gchandle);
>
>
>void mono_gc_wbarrier_set_field (MonoObject *obj, void* field_ptr, MonoObject* value);
>void mono_gc_wbarrier_set_arrayref (MonoArray *arr, void* slot_ptr, MonoObject* value);
>void mono_gc_wbarrier_arrayref_copy (void* dest_ptr, void* src_ptr, int count);
>void mono_gc_wbarrier_generic_store (void* ptr, MonoObject* value);
>void mono_gc_wbarrier_generic_nostore (void* ptr);
>void mono_gc_wbarrier_value_copy (void* dest, void* src, int count, MonoClass *klass);
>void mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src);
>
>
># 40 "method-to-ir.c" 2
># 1 "../../mono/metadata/exception.h" 1
># 10 "../../mono/metadata/exception.h"
>
>
>extern MonoException *
>mono_exception_from_name (MonoImage *image,
>     const char* name_space,
>     const char *name);
>
>MonoException *
>mono_exception_from_token (MonoImage *image, uint32_t token);
>
>MonoException *
>mono_exception_from_name_two_strings (MonoImage *image, const char *name_space,
>          const char *name, MonoString *a1, MonoString *a2);
>
>MonoException *
>mono_exception_from_name_msg (MonoImage *image, const char *name_space,
>     const char *name, const char *msg);
>
>MonoException *
>mono_exception_from_token_two_strings (MonoImage *image, uint32_t token,
>         MonoString *a1, MonoString *a2);
>
>extern MonoException *
>mono_exception_from_name_domain (MonoDomain *domain, MonoImage *image,
>     const char* name_space,
>     const char *name);
>
>MonoException *
>mono_get_exception_divide_by_zero (void);
>
>MonoException *
>mono_get_exception_security (void);
>
>MonoException *
>mono_get_exception_arithmetic (void);
>
>MonoException *
>mono_get_exception_overflow (void);
>
>MonoException *
>mono_get_exception_null_reference (void);
>
>MonoException *
>mono_get_exception_execution_engine (const char *msg);
>
>MonoException *
>mono_get_exception_thread_abort (void);
>
>MonoException *
>mono_get_exception_thread_state (const char *msg);
>
>MonoException *
>mono_get_exception_thread_interrupted (void);
>
>MonoException *
>mono_get_exception_serialization (const char *msg);
>
>MonoException *
>mono_get_exception_invalid_cast (void);
>
>MonoException *
>mono_get_exception_invalid_operation (const char *msg);
>
>MonoException *
>mono_get_exception_index_out_of_range (void);
>
>MonoException *
>mono_get_exception_array_type_mismatch (void);
>
>MonoException *
>mono_get_exception_type_load (MonoString *class_name, char *assembly_name);
>
>MonoException *
>mono_get_exception_missing_method (const char *class_name, const char *member_name);
>
>MonoException *
>mono_get_exception_missing_field (const char *class_name, const char *member_name);
>
>MonoException *
>mono_get_exception_not_implemented (const char *msg);
>
>MonoException *
>mono_get_exception_not_supported (const char *msg);
>
>MonoException*
>mono_get_exception_argument_null (const char *arg);
>
>MonoException *
>mono_get_exception_argument (const char *arg, const char *msg);
>
>MonoException *
>mono_get_exception_argument_out_of_range (const char *arg);
>
>MonoException *
>mono_get_exception_io (const char *msg);
>
>MonoException *
>mono_get_exception_file_not_found (MonoString *fname);
>
>MonoException *
>mono_get_exception_file_not_found2 (const char *msg, MonoString *fname);
>
>MonoException *
>mono_get_exception_type_initialization (const char *type_name, MonoException *inner);
>
>MonoException *
>mono_get_exception_synchronization_lock (const char *msg);
>
>MonoException *
>mono_get_exception_cannot_unload_appdomain (const char *msg);
>
>MonoException *
>mono_get_exception_appdomain_unloaded (void);
>
>MonoException *
>mono_get_exception_bad_image_format (const char *msg);
>
>MonoException *
>mono_get_exception_bad_image_format2 (const char *msg, MonoString *fname);
>
>MonoException *
>mono_get_exception_stack_overflow (void);
>
>MonoException *
>mono_get_exception_out_of_memory (void);
>
>MonoException *
>mono_get_exception_field_access (void);
>
>MonoException *
>mono_get_exception_method_access (void);
>
>MonoException *
>mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions);
>
>MonoException *
>mono_get_exception_runtime_wrapped (MonoObject *wrapped_exception);
>
>
># 41 "method-to-ir.c" 2
># 1 "../../mono/metadata/opcodes.h" 1
># 15 "../../mono/metadata/opcodes.h"
>
>
>
>
>
>
>
>typedef enum {
># 1 "../../mono/cil/opcode.def" 1
>MONO_CEE_NOP,
>MONO_CEE_BREAK,
>MONO_CEE_LDARG_0,
>MONO_CEE_LDARG_1,
>MONO_CEE_LDARG_2,
>MONO_CEE_LDARG_3,
>MONO_CEE_LDLOC_0,
>MONO_CEE_LDLOC_1,
>MONO_CEE_LDLOC_2,
>MONO_CEE_LDLOC_3,
>MONO_CEE_STLOC_0,
>MONO_CEE_STLOC_1,
>MONO_CEE_STLOC_2,
>MONO_CEE_STLOC_3,
>MONO_CEE_LDARG_S,
>MONO_CEE_LDARGA_S,
>MONO_CEE_STARG_S,
>MONO_CEE_LDLOC_S,
>MONO_CEE_LDLOCA_S,
>MONO_CEE_STLOC_S,
>MONO_CEE_LDNULL,
>MONO_CEE_LDC_I4_M1,
>MONO_CEE_LDC_I4_0,
>MONO_CEE_LDC_I4_1,
>MONO_CEE_LDC_I4_2,
>MONO_CEE_LDC_I4_3,
>MONO_CEE_LDC_I4_4,
>MONO_CEE_LDC_I4_5,
>MONO_CEE_LDC_I4_6,
>MONO_CEE_LDC_I4_7,
>MONO_CEE_LDC_I4_8,
>MONO_CEE_LDC_I4_S,
>MONO_CEE_LDC_I4,
>MONO_CEE_LDC_I8,
>MONO_CEE_LDC_R4,
>MONO_CEE_LDC_R8,
>MONO_CEE_UNUSED99,
>MONO_CEE_DUP,
>MONO_CEE_POP,
>MONO_CEE_JMP,
>MONO_CEE_CALL,
>MONO_CEE_CALLI,
>MONO_CEE_RET,
>MONO_CEE_BR_S,
>MONO_CEE_BRFALSE_S,
>MONO_CEE_BRTRUE_S,
>MONO_CEE_BEQ_S,
>MONO_CEE_BGE_S,
>MONO_CEE_BGT_S,
>MONO_CEE_BLE_S,
>MONO_CEE_BLT_S,
>MONO_CEE_BNE_UN_S,
>MONO_CEE_BGE_UN_S,
>MONO_CEE_BGT_UN_S,
>MONO_CEE_BLE_UN_S,
>MONO_CEE_BLT_UN_S,
>MONO_CEE_BR,
>MONO_CEE_BRFALSE,
>MONO_CEE_BRTRUE,
>MONO_CEE_BEQ,
>MONO_CEE_BGE,
>MONO_CEE_BGT,
>MONO_CEE_BLE,
>MONO_CEE_BLT,
>MONO_CEE_BNE_UN,
>MONO_CEE_BGE_UN,
>MONO_CEE_BGT_UN,
>MONO_CEE_BLE_UN,
>MONO_CEE_BLT_UN,
>MONO_CEE_SWITCH,
>MONO_CEE_LDIND_I1,
>MONO_CEE_LDIND_U1,
>MONO_CEE_LDIND_I2,
>MONO_CEE_LDIND_U2,
>MONO_CEE_LDIND_I4,
>MONO_CEE_LDIND_U4,
>MONO_CEE_LDIND_I8,
>MONO_CEE_LDIND_I,
>MONO_CEE_LDIND_R4,
>MONO_CEE_LDIND_R8,
>MONO_CEE_LDIND_REF,
>MONO_CEE_STIND_REF,
>MONO_CEE_STIND_I1,
>MONO_CEE_STIND_I2,
>MONO_CEE_STIND_I4,
>MONO_CEE_STIND_I8,
>MONO_CEE_STIND_R4,
>MONO_CEE_STIND_R8,
>MONO_CEE_ADD,
>MONO_CEE_SUB,
>MONO_CEE_MUL,
>MONO_CEE_DIV,
>MONO_CEE_DIV_UN,
>MONO_CEE_REM,
>MONO_CEE_REM_UN,
>MONO_CEE_AND,
>MONO_CEE_OR,
>MONO_CEE_XOR,
>MONO_CEE_SHL,
>MONO_CEE_SHR,
>MONO_CEE_SHR_UN,
>MONO_CEE_NEG,
>MONO_CEE_NOT,
>MONO_CEE_CONV_I1,
>MONO_CEE_CONV_I2,
>MONO_CEE_CONV_I4,
>MONO_CEE_CONV_I8,
>MONO_CEE_CONV_R4,
>MONO_CEE_CONV_R8,
>MONO_CEE_CONV_U4,
>MONO_CEE_CONV_U8,
>MONO_CEE_CALLVIRT,
>MONO_CEE_CPOBJ,
>MONO_CEE_LDOBJ,
>MONO_CEE_LDSTR,
>MONO_CEE_NEWOBJ,
>MONO_CEE_CASTCLASS,
>MONO_CEE_ISINST,
>MONO_CEE_CONV_R_UN,
>MONO_CEE_UNUSED58,
>MONO_CEE_UNUSED1,
>MONO_CEE_UNBOX,
>MONO_CEE_THROW,
>MONO_CEE_LDFLD,
>MONO_CEE_LDFLDA,
>MONO_CEE_STFLD,
>MONO_CEE_LDSFLD,
>MONO_CEE_LDSFLDA,
>MONO_CEE_STSFLD,
>MONO_CEE_STOBJ,
>MONO_CEE_CONV_OVF_I1_UN,
>MONO_CEE_CONV_OVF_I2_UN,
>MONO_CEE_CONV_OVF_I4_UN,
>MONO_CEE_CONV_OVF_I8_UN,
>MONO_CEE_CONV_OVF_U1_UN,
>MONO_CEE_CONV_OVF_U2_UN,
>MONO_CEE_CONV_OVF_U4_UN,
>MONO_CEE_CONV_OVF_U8_UN,
>MONO_CEE_CONV_OVF_I_UN,
>MONO_CEE_CONV_OVF_U_UN,
>MONO_CEE_BOX,
>MONO_CEE_NEWARR,
>MONO_CEE_LDLEN,
>MONO_CEE_LDELEMA,
>MONO_CEE_LDELEM_I1,
>MONO_CEE_LDELEM_U1,
>MONO_CEE_LDELEM_I2,
>MONO_CEE_LDELEM_U2,
>MONO_CEE_LDELEM_I4,
>MONO_CEE_LDELEM_U4,
>MONO_CEE_LDELEM_I8,
>MONO_CEE_LDELEM_I,
>MONO_CEE_LDELEM_R4,
>MONO_CEE_LDELEM_R8,
>MONO_CEE_LDELEM_REF,
>MONO_CEE_STELEM_I,
>MONO_CEE_STELEM_I1,
>MONO_CEE_STELEM_I2,
>MONO_CEE_STELEM_I4,
>MONO_CEE_STELEM_I8,
>MONO_CEE_STELEM_R4,
>MONO_CEE_STELEM_R8,
>MONO_CEE_STELEM_REF,
>MONO_CEE_LDELEM,
>MONO_CEE_STELEM,
>MONO_CEE_UNBOX_ANY,
>MONO_CEE_UNUSED5,
>MONO_CEE_UNUSED6,
>MONO_CEE_UNUSED7,
>MONO_CEE_UNUSED8,
>MONO_CEE_UNUSED9,
>MONO_CEE_UNUSED10,
>MONO_CEE_UNUSED11,
>MONO_CEE_UNUSED12,
>MONO_CEE_UNUSED13,
>MONO_CEE_UNUSED14,
>MONO_CEE_UNUSED15,
>MONO_CEE_UNUSED16,
>MONO_CEE_UNUSED17,
>MONO_CEE_CONV_OVF_I1,
>MONO_CEE_CONV_OVF_U1,
>MONO_CEE_CONV_OVF_I2,
>MONO_CEE_CONV_OVF_U2,
>MONO_CEE_CONV_OVF_I4,
>MONO_CEE_CONV_OVF_U4,
>MONO_CEE_CONV_OVF_I8,
>MONO_CEE_CONV_OVF_U8,
>MONO_CEE_UNUSED50,
>MONO_CEE_UNUSED18,
>MONO_CEE_UNUSED19,
>MONO_CEE_UNUSED20,
>MONO_CEE_UNUSED21,
>MONO_CEE_UNUSED22,
>MONO_CEE_UNUSED23,
>MONO_CEE_REFANYVAL,
>MONO_CEE_CKFINITE,
>MONO_CEE_UNUSED24,
>MONO_CEE_UNUSED25,
>MONO_CEE_MKREFANY,
>MONO_CEE_UNUSED59,
>MONO_CEE_UNUSED60,
>MONO_CEE_UNUSED61,
>MONO_CEE_UNUSED62,
>MONO_CEE_UNUSED63,
>MONO_CEE_UNUSED64,
>MONO_CEE_UNUSED65,
>MONO_CEE_UNUSED66,
>MONO_CEE_UNUSED67,
>MONO_CEE_LDTOKEN,
>MONO_CEE_CONV_U2,
>MONO_CEE_CONV_U1,
>MONO_CEE_CONV_I,
>MONO_CEE_CONV_OVF_I,
>MONO_CEE_CONV_OVF_U,
>MONO_CEE_ADD_OVF,
>MONO_CEE_ADD_OVF_UN,
>MONO_CEE_MUL_OVF,
>MONO_CEE_MUL_OVF_UN,
>MONO_CEE_SUB_OVF,
>MONO_CEE_SUB_OVF_UN,
>MONO_CEE_ENDFINALLY,
>MONO_CEE_LEAVE,
>MONO_CEE_LEAVE_S,
>MONO_CEE_STIND_I,
>MONO_CEE_CONV_U,
>MONO_CEE_UNUSED26,
>MONO_CEE_UNUSED27,
>MONO_CEE_UNUSED28,
>MONO_CEE_UNUSED29,
>MONO_CEE_UNUSED30,
>MONO_CEE_UNUSED31,
>MONO_CEE_UNUSED32,
>MONO_CEE_UNUSED33,
>MONO_CEE_UNUSED34,
>MONO_CEE_UNUSED35,
>MONO_CEE_UNUSED36,
>MONO_CEE_UNUSED37,
>MONO_CEE_UNUSED38,
>MONO_CEE_UNUSED39,
>MONO_CEE_UNUSED40,
>MONO_CEE_UNUSED41,
>MONO_CEE_UNUSED42,
>MONO_CEE_UNUSED43,
>MONO_CEE_UNUSED44,
>MONO_CEE_UNUSED45,
>MONO_CEE_UNUSED46,
>MONO_CEE_UNUSED47,
>MONO_CEE_UNUSED48,
>MONO_CEE_PREFIX7,
>MONO_CEE_PREFIX6,
>MONO_CEE_PREFIX5,
>MONO_CEE_PREFIX4,
>MONO_CEE_PREFIX3,
>MONO_CEE_PREFIX2,
>MONO_CEE_PREFIX1,
>MONO_CEE_PREFIXREF,
>MONO_CEE_ARGLIST,
>MONO_CEE_CEQ,
>MONO_CEE_CGT,
>MONO_CEE_CGT_UN,
>MONO_CEE_CLT,
>MONO_CEE_CLT_UN,
>MONO_CEE_LDFTN,
>MONO_CEE_LDVIRTFTN,
>MONO_CEE_UNUSED56,
>MONO_CEE_LDARG,
>MONO_CEE_LDARGA,
>MONO_CEE_STARG,
>MONO_CEE_LDLOC,
>MONO_CEE_LDLOCA,
>MONO_CEE_STLOC,
>MONO_CEE_LOCALLOC,
>MONO_CEE_UNUSED57,
>MONO_CEE_ENDFILTER,
>MONO_CEE_UNALIGNED_,
>MONO_CEE_VOLATILE_,
>MONO_CEE_TAIL_,
>MONO_CEE_INITOBJ,
>MONO_CEE_CONSTRAINED_,
>MONO_CEE_CPBLK,
>MONO_CEE_INITBLK,
>MONO_CEE_NO_,
>MONO_CEE_RETHROW,
>MONO_CEE_UNUSED,
>MONO_CEE_SIZEOF,
>MONO_CEE_REFANYTYPE,
>MONO_CEE_READONLY_,
>MONO_CEE_UNUSED53,
>MONO_CEE_UNUSED54,
>MONO_CEE_UNUSED55,
>MONO_CEE_UNUSED70,
>MONO_CEE_ILLEGAL,
>MONO_CEE_ENDMAC,
>MONO_CEE_MONO_ICALL,
>MONO_CEE_MONO_OBJADDR,
>MONO_CEE_MONO_LDPTR,
>MONO_CEE_MONO_VTADDR,
>MONO_CEE_MONO_NEWOBJ,
>MONO_CEE_MONO_RETOBJ,
>MONO_CEE_MONO_LDNATIVEOBJ,
>MONO_CEE_MONO_CISINST,
>MONO_CEE_MONO_CCASTCLASS,
>MONO_CEE_MONO_SAVE_LMF,
>MONO_CEE_MONO_RESTORE_LMF,
>MONO_CEE_MONO_CLASSCONST,
>MONO_CEE_MONO_NOT_TAKEN,
>MONO_CEE_MONO_TLS,
>MONO_CEE_MONO_ICALL_ADDR,
>MONO_CEE_MONO_DYN_CALL,
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
># 24 "../../mono/metadata/opcodes.h" 2
> MONO_CEE_LAST
>} MonoOpcodeEnum;
>
>
>
>enum {
> MONO_FLOW_NEXT,
> MONO_FLOW_BRANCH,
> MONO_FLOW_COND_BRANCH,
> MONO_FLOW_ERROR,
> MONO_FLOW_CALL,
> MONO_FLOW_RETURN,
> MONO_FLOW_META
>};
>
>enum {
> MonoInlineNone,
> MonoInlineType,
> MonoInlineField,
> MonoInlineMethod,
> MonoInlineTok,
> MonoInlineString,
> MonoInlineSig,
> MonoInlineVar,
> MonoShortInlineVar,
> MonoInlineBrTarget,
> MonoShortInlineBrTarget,
> MonoInlineSwitch,
> MonoInlineR,
> MonoShortInlineR,
> MonoInlineI,
> MonoShortInlineI,
> MonoInlineI8
>};
>
>typedef struct {
> unsigned char argument;
> unsigned char flow_type;
> unsigned short opval;
>} MonoOpcode;
>
>extern const MonoOpcode mono_opcodes [];
>
>const char*
>mono_opcode_name (int opcode);
>
>MonoOpcodeEnum
>mono_opcode_value (const mono_byte **ip, const mono_byte *end);
>
>
># 42 "method-to-ir.c" 2
># 1 "../../mono/metadata/mono-endian.h" 1
>
>
>
># 1 "../../eglib/src/glib.h" 1
>
>
>
>
># 1 "/usr/include/stdlib.h" 1 3 4
># 32 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 324 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 3 4
>typedef int wchar_t;
># 33 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>
>
># 1 "/usr/include/bits/waitflags.h" 1 3 4
># 42 "/usr/include/stdlib.h" 2 3 4
># 1 "/usr/include/bits/waitstatus.h" 1 3 4
># 66 "/usr/include/bits/waitstatus.h" 3 4
>union wait
>  {
>    int w_status;
>    struct
>      {
>
>
>
>
>
>
>
> unsigned int:16;
> unsigned int __w_retcode:8;
> unsigned int __w_coredump:1;
> unsigned int __w_termsig:7;
>
>      } __wait_terminated;
>    struct
>      {
>
>
>
>
>
>
> unsigned int:16;
> unsigned int __w_stopsig:8;
> unsigned int __w_stopval:8;
>
>      } __wait_stopped;
>  };
># 43 "/usr/include/stdlib.h" 2 3 4
># 67 "/usr/include/stdlib.h" 3 4
>typedef union
>  {
>    union wait *__uptr;
>    int *__iptr;
>  } __WAIT_STATUS __attribute__ ((__transparent_union__));
># 95 "/usr/include/stdlib.h" 3 4
>
>
>typedef struct
>  {
>    int quot;
>    int rem;
>  } div_t;
>
>
>
>typedef struct
>  {
>    long int quot;
>    long int rem;
>  } ldiv_t;
>
>
>
>
>
>
>
>__extension__ typedef struct
>  {
>    long long int quot;
>    long long int rem;
>  } lldiv_t;
>
>
># 139 "/usr/include/stdlib.h" 3 4
>extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern double atof (const char *__nptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>extern int atoi (const char *__nptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>extern long int atol (const char *__nptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>__extension__ extern long long int atoll (const char *__nptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern double strtod (const char *__restrict __nptr,
>        char **__restrict __endptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern float strtof (const char *__restrict __nptr,
>       char **__restrict __endptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>extern long double strtold (const char *__restrict __nptr,
>       char **__restrict __endptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern long int strtol (const char *__restrict __nptr,
>   char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>extern unsigned long int strtoul (const char *__restrict __nptr,
>      char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>__extension__
>extern long long int strtoq (const char *__restrict __nptr,
>        char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>__extension__
>extern unsigned long long int strtouq (const char *__restrict __nptr,
>           char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>__extension__
>extern long long int strtoll (const char *__restrict __nptr,
>         char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>__extension__
>extern unsigned long long int strtoull (const char *__restrict __nptr,
>     char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
># 239 "/usr/include/stdlib.h" 3 4
>extern long int strtol_l (const char *__restrict __nptr,
>     char **__restrict __endptr, int __base,
>     __locale_t __loc) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 4)));
>
>extern unsigned long int strtoul_l (const char *__restrict __nptr,
>        char **__restrict __endptr,
>        int __base, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 4)));
>
>__extension__
>extern long long int strtoll_l (const char *__restrict __nptr,
>    char **__restrict __endptr, int __base,
>    __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 4)));
>
>__extension__
>extern unsigned long long int strtoull_l (const char *__restrict __nptr,
>       char **__restrict __endptr,
>       int __base, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 4)));
>
>extern double strtod_l (const char *__restrict __nptr,
>   char **__restrict __endptr, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>extern float strtof_l (const char *__restrict __nptr,
>         char **__restrict __endptr, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>extern long double strtold_l (const char *__restrict __nptr,
>         char **__restrict __endptr,
>         __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) atoi (const char *__nptr)
>{
>  return (int) strtol (__nptr, (char **) ((void *)0), 10);
>}
>extern __inline long int
>__attribute__ ((__nothrow__ , __leaf__)) atol (const char *__nptr)
>{
>  return strtol (__nptr, (char **) ((void *)0), 10);
>}
>
>
>
>
>__extension__ extern __inline long long int
>__attribute__ ((__nothrow__ , __leaf__)) atoll (const char *__nptr)
>{
>  return strtoll (__nptr, (char **) ((void *)0), 10);
>}
>
># 305 "/usr/include/stdlib.h" 3 4
>extern char *l64a (long int __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>extern long int a64l (const char *__s)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
># 1 "/usr/include/sys/types.h" 1 3 4
># 27 "/usr/include/sys/types.h" 3 4
>
>
>
>
>
>
>typedef __u_char u_char;
>typedef __u_short u_short;
>typedef __u_int u_int;
>typedef __u_long u_long;
>typedef __quad_t quad_t;
>typedef __u_quad_t u_quad_t;
>typedef __fsid_t fsid_t;
>
>
>
>
>typedef __loff_t loff_t;
>
>
>
>typedef __ino_t ino_t;
>
>
>
>
>
>
>typedef __ino64_t ino64_t;
>
>
>
>
>typedef __dev_t dev_t;
># 70 "/usr/include/sys/types.h" 3 4
>typedef __mode_t mode_t;
>
>
>
>
>typedef __nlink_t nlink_t;
># 104 "/usr/include/sys/types.h" 3 4
>typedef __id_t id_t;
># 115 "/usr/include/sys/types.h" 3 4
>typedef __daddr_t daddr_t;
>typedef __caddr_t caddr_t;
>
>
>
>
>
>typedef __key_t key_t;
># 132 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 57 "/usr/include/time.h" 3 4
>
>
>typedef __clock_t clock_t;
>
>
>
># 91 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
># 103 "/usr/include/time.h" 3 4
>typedef __timer_t timer_t;
># 133 "/usr/include/sys/types.h" 2 3 4
># 146 "/usr/include/sys/types.h" 3 4
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 147 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef unsigned long int ulong;
>typedef unsigned short int ushort;
>typedef unsigned int uint;
># 200 "/usr/include/sys/types.h" 3 4
>typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
>typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
>
>typedef int register_t __attribute__ ((__mode__ (__word__)));
># 222 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 24 "/usr/include/sys/sysmacros.h" 3 4
>
>
>__extension__
>extern unsigned int gnu_dev_major (unsigned long long int __dev)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>__extension__
>extern unsigned int gnu_dev_minor (unsigned long long int __dev)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>__extension__
>extern unsigned long long int gnu_dev_makedev (unsigned int __major,
>            unsigned int __minor)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>__extension__ extern __inline __attribute__ ((__const__)) unsigned int
>__attribute__ ((__nothrow__ , __leaf__)) gnu_dev_major (unsigned long long int __dev)
>{
>  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
>}
>
>__extension__ extern __inline __attribute__ ((__const__)) unsigned int
>__attribute__ ((__nothrow__ , __leaf__)) gnu_dev_minor (unsigned long long int __dev)
>{
>  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
>}
>
>__extension__ extern __inline __attribute__ ((__const__)) unsigned long long int
>__attribute__ ((__nothrow__ , __leaf__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor)
>{
>  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
>   | (((unsigned long long int) (__minor & ~0xff)) << 12)
>   | (((unsigned long long int) (__major & ~0xfff)) << 32));
>}
>
>
># 223 "/usr/include/sys/types.h" 2 3 4
>
>
>
>
>
>typedef __blksize_t blksize_t;
>
>
>
>
>
>
>typedef __blkcnt_t blkcnt_t;
>
>
>
>typedef __fsblkcnt_t fsblkcnt_t;
>
>
>
>typedef __fsfilcnt_t fsfilcnt_t;
># 262 "/usr/include/sys/types.h" 3 4
>typedef __blkcnt64_t blkcnt64_t;
>typedef __fsblkcnt64_t fsblkcnt64_t;
>typedef __fsfilcnt64_t fsfilcnt64_t;
># 273 "/usr/include/sys/types.h" 3 4
>
># 315 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>extern long int random (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *initstate (unsigned int __seed, char *__statebuf,
>   size_t __statelen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>struct random_data
>  {
>    int32_t *fptr;
>    int32_t *rptr;
>    int32_t *state;
>    int rand_type;
>    int rand_deg;
>    int rand_sep;
>    int32_t *end_ptr;
>  };
>
>extern int random_r (struct random_data *__restrict __buf,
>       int32_t *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int srandom_r (unsigned int __seed, struct random_data *__buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
>   size_t __statelen,
>   struct random_data *__restrict __buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
>
>extern int setstate_r (char *__restrict __statebuf,
>         struct random_data *__restrict __buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int rand (void) __attribute__ ((__nothrow__ , __leaf__));
>
>extern void srand (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern double drand48 (void) __attribute__ ((__nothrow__ , __leaf__));
>extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int lrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
>extern long int nrand48 (unsigned short int __xsubi[3])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int mrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
>extern long int jrand48 (unsigned short int __xsubi[3])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void srand48 (long int __seedval) __attribute__ ((__nothrow__ , __leaf__));
>extern unsigned short int *seed48 (unsigned short int __seed16v[3])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>struct drand48_data
>  {
>    unsigned short int __x[3];
>    unsigned short int __old_x[3];
>    unsigned short int __c;
>    unsigned short int __init;
>    __extension__ unsigned long long int __a;
>
>  };
>
>
>extern int drand48_r (struct drand48_data *__restrict __buffer,
>        double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int erand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int lrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int nrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int mrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int jrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>extern int seed48_r (unsigned short int __seed16v[3],
>       struct drand48_data *__buffer) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int lcong48_r (unsigned short int __param[7],
>        struct drand48_data *__buffer)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
># 474 "/usr/include/stdlib.h" 3 4
>
>
>
>
>
>
>extern void *realloc (void *__ptr, size_t __size)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void cfree (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
># 498 "/usr/include/stdlib.h" 3 4
>extern void *valloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void *aligned_alloc (size_t __alignment, size_t __size)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void abort (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int at_quick_exit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>extern void quick_exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>
>extern void _Exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern char *getenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *secure_getenv (const char *__name)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int putenv (char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int setenv (const char *__name, const char *__value, int __replace)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int unsetenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int clearenv (void) __attribute__ ((__nothrow__ , __leaf__));
># 606 "/usr/include/stdlib.h" 3 4
>extern char *mktemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 619 "/usr/include/stdlib.h" 3 4
>extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 629 "/usr/include/stdlib.h" 3 4
>extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 641 "/usr/include/stdlib.h" 3 4
>extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 651 "/usr/include/stdlib.h" 3 4
>extern int mkstemps64 (char *__template, int __suffixlen)
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 662 "/usr/include/stdlib.h" 3 4
>extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 673 "/usr/include/stdlib.h" 3 4
>extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 683 "/usr/include/stdlib.h" 3 4
>extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 693 "/usr/include/stdlib.h" 3 4
>extern int mkostemps (char *__template, int __suffixlen, int __flags)
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 705 "/usr/include/stdlib.h" 3 4
>extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>
>extern int system (const char *__command) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern char *canonicalize_file_name (const char *__name)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 733 "/usr/include/stdlib.h" 3 4
>extern char *realpath (const char *__restrict __name,
>         char *__restrict __resolved) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>typedef int (*__compar_fn_t) (const void *, const void *);
>
>
>typedef __compar_fn_t comparison_fn_t;
>
>
>
>typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
>
>
>
>
>
>extern void *bsearch (const void *__key, const void *__base,
>        size_t __nmemb, size_t __size, __compar_fn_t __compar)
>     __attribute__ ((__nonnull__ (1, 2, 5))) __attribute__ ((__warn_unused_result__));
>
>
># 1 "/usr/include/bits/stdlib-bsearch.h" 1 3 4
># 19 "/usr/include/bits/stdlib-bsearch.h" 3 4
>extern __inline void *
>bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size,
>  __compar_fn_t __compar)
>{
>  size_t __l, __u, __idx;
>  const void *__p;
>  int __comparison;
>
>  __l = 0;
>  __u = __nmemb;
>  while (__l < __u)
>    {
>      __idx = (__l + __u) / 2;
>      __p = (void *) (((const char *) __base) + (__idx * __size));
>      __comparison = (*__compar) (__key, __p);
>      if (__comparison < 0)
> __u = __idx;
>      else if (__comparison > 0)
> __l = __idx + 1;
>      else
> return (void *) __p;
>    }
>
>  return ((void *)0);
>}
># 760 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>extern void qsort (void *__base, size_t __nmemb, size_t __size,
>     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
>
>extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
>       __compar_d_fn_t __compar, void *__arg)
>  __attribute__ ((__nonnull__ (1, 4)));
>
>
>
>
>extern int abs (int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>extern long int labs (long int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
>
>
>__extension__ extern long long int llabs (long long int __x)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern div_t div (int __numer, int __denom)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>extern ldiv_t ldiv (long int __numer, long int __denom)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>__extension__ extern lldiv_t lldiv (long long int __numer,
>        long long int __denom)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
># 811 "/usr/include/stdlib.h" 3 4
>extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *gcvt (double __value, int __ndigit, char *__buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *qecvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>extern char *qfcvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>extern char *qgcvt (long double __value, int __ndigit, char *__buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>
>extern int qecvt_r (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int qfcvt_r (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>
>
>
>
>
>
>extern int mblen (const char *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int mbtowc (wchar_t *__restrict __pwc,
>     const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern size_t mbstowcs (wchar_t *__restrict __pwcs,
>   const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
>
>extern size_t wcstombs (char *__restrict __s,
>   const wchar_t *__restrict __pwcs, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int rpmatch (const char *__response) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 898 "/usr/include/stdlib.h" 3 4
>extern int getsubopt (char **__restrict __optionp,
>        char *const *__restrict __tokens,
>        char **__restrict __valuep)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern void setkey (const char *__key) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int posix_openpt (int __oflag) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern int grantpt (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int unlockpt (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern char *ptsname (int __fd) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int getpt (void);
>
>
>
>
>
>
>extern int getloadavg (double __loadavg[], int __nelem)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
># 1 "/usr/include/bits/stdlib-float.h" 1 3 4
># 24 "/usr/include/bits/stdlib-float.h" 3 4
>
>extern __inline double
>__attribute__ ((__nothrow__ , __leaf__)) atof (const char *__nptr)
>{
>  return strtod (__nptr, (char **) ((void *)0));
>}
>
># 955 "/usr/include/stdlib.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/stdlib.h" 1 3 4
># 23 "/usr/include/bits/stdlib.h" 3 4
>extern char *__realpath_chk (const char *__restrict __name,
>        char *__restrict __resolved,
>        size_t __resolvedlen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern char *__realpath_alias (const char *__restrict __name, char *__restrict __resolved) __asm__ ("" "realpath") __attribute__ ((__nothrow__ , __leaf__))
>
>                                                 __attribute__ ((__warn_unused_result__));
>extern char *__realpath_chk_warn (const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) __asm__ ("" "__realpath_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                                                __attribute__ ((__warn_unused_result__))
>     __attribute__((__warning__ ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer")))
>                                      ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) realpath (const char *__restrict __name, char *__restrict __resolved)
>{
>  if (__builtin_object_size (__resolved, 2 > 1) != (size_t) -1)
>    {
>
>
>
>
>      return __realpath_chk (__name, __resolved, __builtin_object_size (__resolved, 2 > 1));
>    }
>
>  return __realpath_alias (__name, __resolved);
>}
>
>
>extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen,
>       size_t __nreal) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>extern int __ptsname_r_alias (int __fd, char *__buf, size_t __buflen) __asm__ ("" "ptsname_r") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (2)));
>extern int __ptsname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__ptsname_r_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsname_r called with buflen bigger than " "size of buf")))
>                   ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) ptsname_r (int __fd, char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __ptsname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __ptsname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __ptsname_r_alias (__fd, __buf, __buflen);
>}
>
>
>extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen)
>  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern int __wctomb_alias (char *__s, wchar_t __wchar) __asm__ ("" "wctomb") __attribute__ ((__nothrow__ , __leaf__))
>              __attribute__ ((__warn_unused_result__));
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) int
>__attribute__ ((__nothrow__ , __leaf__)) wctomb (char *__s, wchar_t __wchar)
>{
>
>
>
>
>
>
>
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
>    return __wctomb_chk (__s, __wchar, __builtin_object_size (__s, 2 > 1));
>  return __wctomb_alias (__s, __wchar);
>}
>
>
>extern size_t __mbstowcs_chk (wchar_t *__restrict __dst,
>         const char *__restrict __src,
>         size_t __len, size_t __dstlen) __attribute__ ((__nothrow__ , __leaf__));
>extern size_t __mbstowcs_alias (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) __asm__ ("" "mbstowcs") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                                  ;
>extern size_t __mbstowcs_chk_warn (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len, size_t __dstlen) __asm__ ("" "__mbstowcs_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__((__warning__ ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
>                        ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__nothrow__ , __leaf__)) mbstowcs (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len)
>
>{
>  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __mbstowcs_chk (__dst, __src, __len,
>          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
>
>      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
> return __mbstowcs_chk_warn (__dst, __src, __len,
>         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
>    }
>  return __mbstowcs_alias (__dst, __src, __len);
>}
>
>
>extern size_t __wcstombs_chk (char *__restrict __dst,
>         const wchar_t *__restrict __src,
>         size_t __len, size_t __dstlen) __attribute__ ((__nothrow__ , __leaf__));
>extern size_t __wcstombs_alias (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len) __asm__ ("" "wcstombs") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                                  ;
>extern size_t __wcstombs_chk_warn (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len, size_t __dstlen) __asm__ ("" "__wcstombs_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__((__warning__ ("wcstombs called with dst buffer smaller than len")));
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__nothrow__ , __leaf__)) wcstombs (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len)
>
>{
>  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __wcstombs_chk (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
>      if (__len > __builtin_object_size (__dst, 2 > 1))
> return __wcstombs_chk_warn (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
>    }
>  return __wcstombs_alias (__dst, __src, __len);
>}
># 959 "/usr/include/stdlib.h" 2 3 4
># 967 "/usr/include/stdlib.h" 3 4
>
># 6 "../../eglib/src/glib.h" 2
>
>
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 147 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 3 4
>typedef long int ptrdiff_t;
># 9 "../../eglib/src/glib.h" 2
>
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/limits.h" 1 3 4
># 34 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/limits.h" 3 4
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/limits.h" 1 3 4
># 168 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 143 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/posix1_lim.h" 1 3 4
># 160 "/usr/include/bits/posix1_lim.h" 3 4
># 1 "/usr/include/bits/local_lim.h" 1 3 4
># 38 "/usr/include/bits/local_lim.h" 3 4
># 1 "/usr/include/linux/limits.h" 1 3 4
># 39 "/usr/include/bits/local_lim.h" 2 3 4
># 161 "/usr/include/bits/posix1_lim.h" 2 3 4
># 144 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/posix2_lim.h" 1 3 4
># 148 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/xopen_lim.h" 1 3 4
># 33 "/usr/include/bits/xopen_lim.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 34 "/usr/include/bits/xopen_lim.h" 2 3 4
># 152 "/usr/include/limits.h" 2 3 4
># 169 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/limits.h" 2 3 4
># 8 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/syslimits.h" 2 3 4
># 35 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/limits.h" 2 3 4
># 11 "../../eglib/src/glib.h" 2
>
>
>
>
>
>
>
># 1 "../../eglib/src/eglib-config.h" 1
># 26 "../../eglib/src/eglib-config.h"
>typedef unsigned long gsize;
>typedef signed long gssize;
># 45 "../../eglib/src/eglib-config.h"
>typedef int GPid;
># 19 "../../eglib/src/glib.h" 2
>
># 1 "../../eglib/src/eglib-remap.h" 1
># 21 "../../eglib/src/glib.h" 2
># 41 "../../eglib/src/glib.h"
>
># 52 "../../eglib/src/glib.h"
>typedef int gint;
>typedef unsigned int guint;
>typedef short gshort;
>typedef unsigned short gushort;
>typedef long glong;
>typedef unsigned long gulong;
>typedef void * gpointer;
>typedef const void * gconstpointer;
>typedef char gchar;
>typedef unsigned char guchar;
># 79 "../../eglib/src/glib.h"
>typedef int8_t gint8;
>typedef uint8_t guint8;
>typedef int16_t gint16;
>typedef uint16_t guint16;
>typedef int32_t gint32;
>typedef uint32_t guint32;
>typedef int64_t gint64;
>typedef uint64_t guint64;
>typedef float gfloat;
>typedef double gdouble;
>typedef uint16_t gunichar2;
>typedef int32_t gboolean;
># 132 "../../eglib/src/glib.h"
>void monoeg_g_free (void *ptr);
>gpointer monoeg_realloc (gpointer obj, gsize size);
>gpointer monoeg_malloc (gsize x);
>gpointer monoeg_malloc0 (gsize x);
>gpointer monoeg_try_malloc (gsize x);
>gpointer monoeg_try_realloc (gpointer obj, gsize size);
># 147 "../../eglib/src/glib.h"
>gpointer monoeg_g_memdup (gconstpointer mem, guint byte_size);
>static inline gchar *monoeg_strdup (const gchar *str) { if (str) {return (__extension__ (__builtin_constant_p (str) && ((size_t)(const void *)((str) + 1) - (size_t)(const void *)(str) == 1) ? (((const char *) (str))[0] == '\0' ? (char *) calloc ((size_t) 1, (size_t) 1) : ({ size_t __len = __strlen_g ((str)) + 1; char *__retval = (char *) malloc (__len); if (__retval != ((void *)0)) __retval = (char *) memcpy (__retval, str, __len); __retval; })) : __strdup (str)));} return ((void *)0); }
>gchar **monoeg_g_strdupv (gchar **str_array);
>
>typedef struct {
> gpointer (*malloc) (gsize n_bytes);
> gpointer (*realloc) (gpointer mem, gsize n_bytes);
> void (*free) (gpointer mem);
> gpointer (*calloc) (gsize n_blocks, gsize n_block_bytes);
> gpointer (*try_malloc) (gsize n_bytes);
> gpointer (*try_realloc) (gpointer mem, gsize n_bytes);
>} GMemVTable;
>
>
>
>struct _GMemChunk {
> guint alloc_size;
>};
>
>typedef struct _GMemChunk GMemChunk;
>
>
>
>
>
>const gchar * monoeg_g_getenv(const gchar *variable);
>gboolean monoeg_g_setenv(const gchar *variable, const gchar *value, gboolean overwrite);
>void monoeg_g_unsetenv(const gchar *variable);
>
>gchar* monoeg_g_win32_getlocale(void);
># 187 "../../eglib/src/glib.h"
>typedef struct _GHashTable GHashTable;
>typedef struct _GHashTableIter GHashTableIter;
>
>
>struct _GHashTableIter
>{
> gpointer dummy [8];
>};
>
>typedef void (*GFunc) (gpointer data, gpointer user_data);
>typedef gint (*GCompareFunc) (gconstpointer a, gconstpointer b);
>typedef gint (*GCompareDataFunc) (gconstpointer a, gconstpointer b, gpointer user_data);
>typedef void (*GHFunc) (gpointer key, gpointer value, gpointer user_data);
>typedef gboolean (*GHRFunc) (gpointer key, gpointer value, gpointer user_data);
>typedef void (*GDestroyNotify) (gpointer data);
>typedef guint (*GHashFunc) (gconstpointer key);
>typedef gboolean (*GEqualFunc) (gconstpointer a, gconstpointer b);
>typedef void (*GFreeFunc) (gpointer data);
>
>GHashTable *monoeg_g_hash_table_new (GHashFunc hash_func, GEqualFunc key_equal_func);
>GHashTable *monoeg_g_hash_table_new_full (GHashFunc hash_func, GEqualFunc key_equal_func,
>           GDestroyNotify key_destroy_func, GDestroyNotify value_destroy_func);
>void monoeg_g_hash_table_insert_replace (GHashTable *hash, gpointer key, gpointer value, gboolean replace);
>guint monoeg_g_hash_table_size (GHashTable *hash);
>gpointer monoeg_g_hash_table_lookup (GHashTable *hash, gconstpointer key);
>gboolean monoeg_g_hash_table_lookup_extended (GHashTable *hash, gconstpointer key, gpointer *orig_key, gpointer *value);
>void monoeg_g_hash_table_foreach (GHashTable *hash, GHFunc func, gpointer user_data);
>gpointer monoeg_g_hash_table_find (GHashTable *hash, GHRFunc predicate, gpointer user_data);
>gboolean monoeg_g_hash_table_remove (GHashTable *hash, gconstpointer key);
>void monoeg_g_hash_table_remove_all (GHashTable *hash);
>guint monoeg_g_hash_table_foreach_remove (GHashTable *hash, GHRFunc func, gpointer user_data);
>guint monoeg_g_hash_table_foreach_steal (GHashTable *hash, GHRFunc func, gpointer user_data);
>void monoeg_g_hash_table_destroy (GHashTable *hash);
>void monoeg_g_hash_table_print_stats (GHashTable *table);
>
>void monoeg_g_hash_table_iter_init (GHashTableIter *iter, GHashTable *hash_table);
>gboolean monoeg_g_hash_table_iter_next (GHashTableIter *iter, gpointer *key, gpointer *value);
>
>guint monoeg_g_spaced_primes_closest (guint x);
>
>
>
>
>gboolean monoeg_g_direct_equal (gconstpointer v1, gconstpointer v2);
>guint monoeg_g_direct_hash (gconstpointer v1);
>gboolean monoeg_g_int_equal (gconstpointer v1, gconstpointer v2);
>guint monoeg_g_int_hash (gconstpointer v1);
>gboolean monoeg_g_str_equal (gconstpointer v1, gconstpointer v2);
>guint monoeg_g_str_hash (gconstpointer v1);
>
>
>
>
>
>
>
>typedef struct {
>
> gpointer domain;
> gint code;
> gchar *message;
>} GError;
>
>void monoeg_g_clear_error (GError **error);
>void monoeg_g_error_free (GError *error);
>GError *monoeg_g_error_new (gpointer domain, gint code, const char *format, ...);
>void monoeg_g_set_error (GError **err, gpointer domain, gint code, const gchar *format, ...);
>void monoeg_g_propagate_error (GError **dest, GError *src);
>
>
>
>
>gchar *monoeg_g_strdup_printf (const gchar *format, ...);
>gchar *monoeg_g_strdup_vprintf (const gchar *format, va_list args);
>gchar *monoeg_g_strndup (const gchar *str, gsize n);
>const gchar *monoeg_g_strerror (gint errnum);
>gchar *monoeg_g_strndup (const gchar *str, gsize n);
>void monoeg_g_strfreev (gchar **str_array);
>gchar *monoeg_g_strconcat (const gchar *first, ...);
>gchar **monoeg_g_strsplit (const gchar *string, const gchar *delimiter, gint max_tokens);
>gchar **monoeg_g_strsplit_set (const gchar *string, const gchar *delimiter, gint max_tokens);
>gchar *monoeg_g_strreverse (gchar *str);
>gboolean monoeg_g_str_has_prefix (const gchar *str, const gchar *prefix);
>gboolean monoeg_g_str_has_suffix (const gchar *str, const gchar *suffix);
>guint monoeg_g_strv_length (gchar **str_array);
>gchar *monoeg_g_strjoin (const gchar *separator, ...);
>gchar *monoeg_g_strjoinv (const gchar *separator, gchar **str_array);
>gchar *monoeg_g_strchug (gchar *str);
>gchar *monoeg_g_strchomp (gchar *str);
>void monoeg_g_strdown (gchar *string);
>gchar *monoeg_g_strnfill (gsize length, gchar fill_char);
>
>gchar *monoeg_g_strdelimit (gchar *string, const gchar *delimiters, gchar new_delimiter);
>gchar *monoeg_g_strescape (const gchar *source, const gchar *exceptions);
>
>gchar *monoeg_g_filename_to_uri (const gchar *filename, const gchar *hostname, GError **error);
>gchar *monoeg_g_filename_from_uri (const gchar *uri, gchar **hostname, GError **error);
>
>gint monoeg_g_printf (gchar const *format, ...);
>gint monoeg_g_fprintf (FILE *file, gchar const *format, ...);
>gint monoeg_g_sprintf (gchar *string, gchar const *format, ...);
>gint monoeg_g_snprintf (gchar *string, gulong n, gchar const *format, ...);
>
>
>
>
>
>
>gsize monoeg_g_strlcpy (gchar *dest, const gchar *src, gsize dest_size);
>
>gchar monoeg_g_ascii_tolower (gchar c);
>gchar *monoeg_g_ascii_strdown (const gchar *str, gssize len);
>gint monoeg_g_ascii_strncasecmp (const gchar *s1, const gchar *s2, gsize n);
>gint monoeg_g_ascii_xdigit_value (gchar c);
># 326 "../../eglib/src/glib.h"
>typedef struct {
> char *str;
> gsize len;
> gsize allocated_len;
>} GString;
>
>GString *monoeg_g_string_new (const gchar *init);
>GString *monoeg_g_string_new_len (const gchar *init, gssize len);
>GString *monoeg_g_string_sized_new (gsize default_size);
>gchar *monoeg_g_string_free (GString *string, gboolean free_segment);
>GString *monoeg_g_string_append (GString *string, const gchar *val);
>void monoeg_g_string_printf (GString *string, const gchar *format, ...);
>void monoeg_g_string_append_printf (GString *string, const gchar *format, ...);
>GString *monoeg_g_string_append_c (GString *string, gchar c);
>GString *monoeg_g_string_append (GString *string, const gchar *val);
>GString *monoeg_g_string_append_len (GString *string, const gchar *val, gssize len);
>GString *monoeg_g_string_truncate (GString *string, gsize len);
>GString *monoeg_g_string_prepend (GString *string, const gchar *val);
>
>
>
>
>
>
>typedef struct _GSList GSList;
>struct _GSList {
> gpointer data;
> GSList *next;
>};
>
>GSList *monoeg_g_slist_alloc (void);
>GSList *monoeg_g_slist_append (GSList *list,
>          gpointer data);
>GSList *monoeg_g_slist_prepend (GSList *list,
>          gpointer data);
>void monoeg_g_slist_free (GSList *list);
>void monoeg_g_slist_free_1 (GSList *list);
>GSList *monoeg_g_slist_copy (GSList *list);
>GSList *monoeg_g_slist_concat (GSList *list1,
>          GSList *list2);
>void monoeg_g_slist_foreach (GSList *list,
>          GFunc func,
>          gpointer user_data);
>GSList *monoeg_g_slist_last (GSList *list);
>GSList *monoeg_g_slist_find (GSList *list,
>          gconstpointer data);
>GSList *monoeg_g_slist_find_custom (GSList *list,
>          gconstpointer data,
>          GCompareFunc func);
>GSList *monoeg_g_slist_remove (GSList *list,
>          gconstpointer data);
>GSList *monoeg_g_slist_remove_all (GSList *list,
>          gconstpointer data);
>GSList *monoeg_g_slist_reverse (GSList *list);
>guint monoeg_g_slist_length (GSList *list);
>GSList *monoeg_g_slist_remove_link (GSList *list,
>          GSList *link);
>GSList *monoeg_g_slist_delete_link (GSList *list,
>          GSList *link);
>GSList *monoeg_g_slist_insert_sorted (GSList *list,
>          gpointer data,
>          GCompareFunc func);
>GSList *monoeg_g_slist_insert_before (GSList *list,
>          GSList *sibling,
>          gpointer data);
>GSList *monoeg_g_slist_sort (GSList *list,
>          GCompareFunc func);
>gint monoeg_g_slist_index (GSList *list,
>          gconstpointer data);
>GSList *monoeg_g_slist_nth (GSList *list,
>          guint n);
>gpointer monoeg_g_slist_nth_data (GSList *list,
>          guint n);
>
>
>
>
>typedef struct _GList GList;
>struct _GList {
>  gpointer data;
>  GList *next;
>  GList *prev;
>};
>
>
>
>
>GList *monoeg_g_list_alloc (void);
>GList *monoeg_g_list_append (GList *list,
>        gpointer data);
>GList *monoeg_g_list_prepend (GList *list,
>        gpointer data);
>void monoeg_g_list_free (GList *list);
>void monoeg_g_list_free_1 (GList *list);
>GList *monoeg_g_list_copy (GList *list);
>guint monoeg_g_list_length (GList *list);
>gint monoeg_g_list_index (GList *list,
>        gconstpointer data);
>GList *monoeg_g_list_nth (GList *list,
>        guint n);
>gpointer monoeg_g_list_nth_data (GList *list,
>        guint n);
>GList *monoeg_g_list_last (GList *list);
>GList *monoeg_g_list_concat (GList *list1,
>        GList *list2);
>void monoeg_g_list_foreach (GList *list,
>        GFunc func,
>        gpointer user_data);
>GList *monoeg_g_list_first (GList *list);
>GList *monoeg_g_list_find (GList *list,
>        gconstpointer data);
>GList *monoeg_g_list_find_custom (GList *list,
>        gconstpointer data,
>        GCompareFunc func);
>GList *monoeg_g_list_remove (GList *list,
>        gconstpointer data);
>GList *monoeg_g_list_reverse (GList *list);
>GList *monoeg_g_list_remove_link (GList *list,
>        GList *link);
>GList *monoeg_g_list_delete_link (GList *list,
>        GList *link);
>GList *monoeg_g_list_insert_sorted (GList *list,
>        gpointer data,
>        GCompareFunc func);
>GList *monoeg_g_list_insert_before (GList *list,
>        GList *sibling,
>        gpointer data);
>GList *monoeg_g_list_sort (GList *sort,
>        GCompareFunc func);
>
>
>
>
>
>typedef struct _GByteArray GByteArray;
>struct _GByteArray {
> guint8 *data;
> gint len;
>};
>
>GByteArray *monoeg_g_byte_array_new (void);
>GByteArray* g_byte_array_append (GByteArray *array, const guint8 *data, guint len);
>guint8* monoeg_g_byte_array_free (GByteArray *array, gboolean free_segment);
>
>
>
>
>
>typedef struct _GArray GArray;
>struct _GArray {
> gchar *data;
> gint len;
>};
>
>GArray *monoeg_g_array_new (gboolean zero_terminated, gboolean clear_, guint element_size);
>gchar* monoeg_g_array_free (GArray *array, gboolean free_segment);
>GArray *monoeg_g_array_append_vals (GArray *array, gconstpointer data, guint len);
>GArray* monoeg_g_array_insert_vals (GArray *array, guint index_, gconstpointer data, guint len);
>GArray* monoeg_g_array_remove_index (GArray *array, guint index_);
>GArray* monoeg_g_array_remove_index_fast (GArray *array, guint index_);
># 495 "../../eglib/src/glib.h"
>typedef struct _GPtrArray GPtrArray;
>struct _GPtrArray {
> gpointer *pdata;
> guint len;
>};
>
>GPtrArray *monoeg_g_ptr_array_new (void);
>GPtrArray *monoeg_g_ptr_array_sized_new (guint reserved_size);
>void monoeg_g_ptr_array_add (GPtrArray *array, gpointer data);
>gboolean monoeg_g_ptr_array_remove (GPtrArray *array, gpointer data);
>gpointer monoeg_g_ptr_array_remove_index (GPtrArray *array, guint index);
>gboolean monoeg_g_ptr_array_remove_fast (GPtrArray *array, gpointer data);
>gpointer monoeg_g_ptr_array_remove_index_fast (GPtrArray *array, guint index);
>void monoeg_g_ptr_array_sort (GPtrArray *array, GCompareFunc compare_func);
>void monoeg_g_ptr_array_sort_with_data (GPtrArray *array, GCompareDataFunc compare_func, gpointer user_data);
>void monoeg_g_ptr_array_set_size (GPtrArray *array, gint length);
>gpointer *monoeg_g_ptr_array_free (GPtrArray *array, gboolean free_seg);
>void monoeg_g_ptr_array_foreach (GPtrArray *array, GFunc func, gpointer user_data);
>
>
>
>
>
>typedef struct {
> GList *head;
> GList *tail;
> guint length;
>} GQueue;
>
>gpointer monoeg_g_queue_pop_head (GQueue *queue);
>void monoeg_g_queue_push_head (GQueue *queue,
>       gpointer data);
>void monoeg_g_queue_push_tail (GQueue *queue,
>       gpointer data);
>gboolean monoeg_g_queue_is_empty (GQueue *queue);
>GQueue *monoeg_g_queue_new (void);
>void monoeg_g_queue_free (GQueue *queue);
>void monoeg_g_queue_foreach (GQueue *queue, GFunc func, gpointer user_data);
># 541 "../../eglib/src/glib.h"
>typedef enum {
> G_LOG_FLAG_RECURSION = 1 << 0,
> G_LOG_FLAG_FATAL = 1 << 1,
>
> G_LOG_LEVEL_ERROR = 1 << 2,
> G_LOG_LEVEL_CRITICAL = 1 << 3,
> G_LOG_LEVEL_WARNING = 1 << 4,
> G_LOG_LEVEL_MESSAGE = 1 << 5,
> G_LOG_LEVEL_INFO = 1 << 6,
> G_LOG_LEVEL_DEBUG = 1 << 7,
>
> G_LOG_LEVEL_MASK = ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL)
>} GLogLevelFlags;
>
>void monoeg_g_print (const gchar *format, ...);
>void monoeg_g_printerr (const gchar *format, ...);
>GLogLevelFlags monoeg_g_log_set_always_fatal (GLogLevelFlags fatal_mask);
>GLogLevelFlags monoeg_g_log_set_fatal_mask (const gchar *log_domain, GLogLevelFlags fatal_mask);
>void monoeg_g_logv (const gchar *log_domain, GLogLevelFlags log_level, const gchar *format, va_list args);
>void monoeg_g_log (const gchar *log_domain, GLogLevelFlags log_level, const gchar *format, ...);
>void monoeg_assertion_message (const gchar *format, ...) __attribute__((__noreturn__));
># 585 "../../eglib/src/glib.h"
>gpointer monoeg_g_convert_error_quark(void);
>
>
>
>
>
>
>
>typedef guint32 gunichar;
>
>typedef enum {
> G_UNICODE_CONTROL,
> G_UNICODE_FORMAT,
> G_UNICODE_UNASSIGNED,
> G_UNICODE_PRIVATE_USE,
> G_UNICODE_SURROGATE,
> G_UNICODE_LOWERCASE_LETTER,
> G_UNICODE_MODIFIER_LETTER,
> G_UNICODE_OTHER_LETTER,
> G_UNICODE_TITLECASE_LETTER,
> G_UNICODE_UPPERCASE_LETTER,
> G_UNICODE_COMBINING_MARK,
> G_UNICODE_ENCLOSING_MARK,
> G_UNICODE_NON_SPACING_MARK,
> G_UNICODE_DECIMAL_NUMBER,
> G_UNICODE_LETTER_NUMBER,
> G_UNICODE_OTHER_NUMBER,
> G_UNICODE_CONNECT_PUNCTUATION,
> G_UNICODE_DASH_PUNCTUATION,
> G_UNICODE_CLOSE_PUNCTUATION,
> G_UNICODE_FINAL_PUNCTUATION,
> G_UNICODE_INITIAL_PUNCTUATION,
> G_UNICODE_OTHER_PUNCTUATION,
> G_UNICODE_OPEN_PUNCTUATION,
> G_UNICODE_CURRENCY_SYMBOL,
> G_UNICODE_MODIFIER_SYMBOL,
> G_UNICODE_MATH_SYMBOL,
> G_UNICODE_OTHER_SYMBOL,
> G_UNICODE_LINE_SEPARATOR,
> G_UNICODE_PARAGRAPH_SEPARATOR,
> G_UNICODE_SPACE_SEPARATOR
>} GUnicodeType;
>
>gunichar monoeg_g_unichar_toupper (gunichar c);
>gunichar monoeg_g_unichar_tolower (gunichar c);
>gunichar monoeg_g_unichar_totitle (gunichar c);
>GUnicodeType monoeg_g_unichar_type (gunichar c);
>gboolean monoeg_g_unichar_isxdigit (gunichar c);
>gint monoeg_g_unichar_xdigit_value (gunichar c);
># 661 "../../eglib/src/glib.h"
>typedef enum {
> G_CONVERT_ERROR_NO_CONVERSION,
> G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
> G_CONVERT_ERROR_FAILED,
> G_CONVERT_ERROR_PARTIAL_INPUT,
> G_CONVERT_ERROR_BAD_URI,
> G_CONVERT_ERROR_NOT_ABSOLUTE_PATH
>} GConvertError;
>
>gchar* monoeg_g_utf8_strup (const gchar *str, gssize len);
>gchar* monoeg_g_utf8_strdown (const gchar *str, gssize len);
>gunichar2 *monoeg_g_utf8_to_utf16 (const gchar *str, glong len, glong *items_read, glong *items_written, GError **error);
>gchar *monoeg_g_utf16_to_utf8 (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **error);
>gunichar2 *monoeg_g_ucs4_to_utf16 (const gunichar *str, glong len, glong *items_read, glong *items_written, GError **error);
>gunichar *monoeg_g_utf16_to_ucs4 (const gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **error);
># 688 "../../eglib/src/glib.h"
>gchar *monoeg_g_build_path (const gchar *separator, const gchar *first_element, ...);
>
>gchar *monoeg_g_path_get_dirname (const gchar *filename);
>gchar *monoeg_g_path_get_basename (const char *filename);
>gchar *monoeg_g_find_program_in_path (const gchar *program);
>gchar *monoeg_g_get_current_dir (void);
>gboolean monoeg_g_path_is_absolute (const char *filename);
>
>const gchar *monoeg_g_get_home_dir (void);
>const gchar *monoeg_g_get_tmp_dir (void);
>const gchar *monoeg_g_get_user_name (void);
>gchar *monoeg_g_get_prgname (void);
>void monoeg_g_set_prgname (const gchar *prgname);
>
>
>
>
>
>gboolean monoeg_g_shell_parse_argv (const gchar *command_line, gint *argcp, gchar ***argvp, GError **error);
>gchar *monoeg_g_shell_unquote (const gchar *quoted_string, GError **error);
>gchar *monoeg_g_shell_quote (const gchar *unquoted_string);
>
>
>
>
>typedef enum {
> G_SPAWN_LEAVE_DESCRIPTORS_OPEN = 1,
> G_SPAWN_DO_NOT_REAP_CHILD = 1 << 1,
> G_SPAWN_SEARCH_PATH = 1 << 2,
> G_SPAWN_STDOUT_TO_DEV_NULL = 1 << 3,
> G_SPAWN_STDERR_TO_DEV_NULL = 1 << 4,
> G_SPAWN_CHILD_INHERITS_STDIN = 1 << 5,
> G_SPAWN_FILE_AND_ARGV_ZERO = 1 << 6
>} GSpawnFlags;
>
>typedef void (*GSpawnChildSetupFunc) (gpointer user_data);
>
>gboolean monoeg_g_spawn_command_line_sync (const gchar *command_line, gchar **standard_output, gchar **standard_error, gint *exit_status, GError **error);
>gboolean monoeg_g_spawn_async_with_pipes (const gchar *working_directory, gchar **argv, gchar **envp, GSpawnFlags flags, GSpawnChildSetupFunc child_setup,
>    gpointer user_data, GPid *child_pid, gint *standard_input, gint *standard_output, gint *standard_error, GError **error);
>
>
>
>
>
>typedef struct _GTimer GTimer;
>
>GTimer *monoeg_g_timer_new (void);
>void monoeg_g_timer_destroy (GTimer *timer);
>gdouble monoeg_g_timer_elapsed (GTimer *timer, gulong *microseconds);
>void monoeg_g_timer_stop (GTimer *timer);
>void monoeg_g_timer_start (GTimer *timer);
>
>
>
>
>typedef struct {
> glong tv_sec;
> glong tv_usec;
>} GTimeVal;
>
>void monoeg_g_get_current_time (GTimeVal *result);
>void monoeg_g_usleep (gulong microseconds);
>
>
>
>
>
>typedef enum {
> G_FILE_ERROR_EXIST,
> G_FILE_ERROR_ISDIR,
> G_FILE_ERROR_ACCES,
> G_FILE_ERROR_NAMETOOLONG,
> G_FILE_ERROR_NOENT,
> G_FILE_ERROR_NOTDIR,
> G_FILE_ERROR_NXIO,
> G_FILE_ERROR_NODEV,
> G_FILE_ERROR_ROFS,
> G_FILE_ERROR_TXTBSY,
> G_FILE_ERROR_FAULT,
> G_FILE_ERROR_LOOP,
> G_FILE_ERROR_NOSPC,
> G_FILE_ERROR_NOMEM,
> G_FILE_ERROR_MFILE,
> G_FILE_ERROR_NFILE,
> G_FILE_ERROR_BADF,
> G_FILE_ERROR_INVAL,
> G_FILE_ERROR_PIPE,
> G_FILE_ERROR_AGAIN,
> G_FILE_ERROR_INTR,
> G_FILE_ERROR_IO,
> G_FILE_ERROR_PERM,
> G_FILE_ERROR_NOSYS,
> G_FILE_ERROR_FAILED
>} GFileError;
>
>typedef enum {
> G_FILE_TEST_IS_REGULAR = 1 << 0,
> G_FILE_TEST_IS_SYMLINK = 1 << 1,
> G_FILE_TEST_IS_DIR = 1 << 2,
> G_FILE_TEST_IS_EXECUTABLE = 1 << 3,
> G_FILE_TEST_EXISTS = 1 << 4
>} GFileTest;
>
>
>gboolean monoeg_g_file_get_contents (const gchar *filename, gchar **contents, gsize *length, GError **error);
>GFileError monoeg_g_file_error_from_errno (gint err_no);
>gint monoeg_g_file_open_tmp (const gchar *tmpl, gchar **name_used, GError **error);
>gboolean monoeg_g_file_test (const gchar *filename, GFileTest test);
>
>
>
>
>typedef struct _GPatternSpec GPatternSpec;
>GPatternSpec * monoeg_g_pattern_spec_new (const gchar *pattern);
>void monoeg_g_pattern_spec_free (GPatternSpec *pspec);
>gboolean monoeg_g_pattern_match_string (GPatternSpec *pspec, const gchar *string);
>
>
>
>
>typedef struct _GDir GDir;
>GDir *monoeg_g_dir_open (const gchar *path, guint flags, GError **error);
>const gchar *monoeg_g_dir_read_name (GDir *dir);
>void monoeg_g_dir_rewind (GDir *dir);
>void monoeg_g_dir_close (GDir *dir);
>
>
>
>
>
>typedef struct _GMarkupParseContext GMarkupParseContext;
>
>typedef enum
>{
> G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1 << 0,
> G_MARKUP_TREAT_CDATA_AS_TEXT = 1 << 1
>} GMarkupParseFlags;
>
>typedef struct {
> void (*start_element) (GMarkupParseContext *context,
>    const gchar *element_name,
>    const gchar **attribute_names,
>    const gchar **attribute_values,
>    gpointer user_data,
>    GError **error);
>
> void (*end_element) (GMarkupParseContext *context,
>    const gchar *element_name,
>    gpointer user_data,
>    GError **error);
>
> void (*text) (GMarkupParseContext *context,
>    const gchar *text,
>    gsize text_len,
>    gpointer user_data,
>    GError **error);
>
> void (*passthrough) (GMarkupParseContext *context,
>    const gchar *passthrough_text,
>    gsize text_len,
>    gpointer user_data,
>    GError **error);
> void (*error) (GMarkupParseContext *context,
>    GError *error,
>    gpointer user_data);
>} GMarkupParser;
>
>GMarkupParseContext *monoeg_g_markup_parse_context_new (const GMarkupParser *parser,
>         GMarkupParseFlags flags,
>         gpointer user_data,
>         GDestroyNotify user_data_dnotify);
>void monoeg_g_markup_parse_context_free (GMarkupParseContext *context);
>gboolean monoeg_g_markup_parse_context_parse (GMarkupParseContext *context,
>         const gchar *text, gssize text_len,
>         GError **error);
>gboolean monoeg_g_markup_parse_context_end_parse (GMarkupParseContext *context,
>         GError **error);
># 877 "../../eglib/src/glib.h"
>extern const gchar monoeg_g_trailingBytesForUTF8[256];
>
>gboolean monoeg_g_get_charset (const char **charset);
>gchar *monoeg_g_locale_to_utf8 (const gchar *opsysstring, gssize len,
>    gsize *bytes_read, gsize *bytes_written,
>    GError **error);
>gchar *monoeg_g_locale_from_utf8 (const gchar *utf8string, gssize len, gsize *bytes_read,
>    gsize *bytes_written, GError **error);
>gchar *monoeg_g_filename_from_utf8 (const gchar *utf8string, gssize len, gsize *bytes_read,
>    gsize *bytes_written, GError **error);
>gchar *monoeg_g_convert (const gchar *str, gssize len,
>    const gchar *to_codeset, const gchar *from_codeset,
>    gsize *bytes_read, gsize *bytes_written, GError **error);
>gboolean monoeg_g_utf8_validate (const gchar *str, gssize max_len, const gchar **end);
>gunichar monoeg_g_utf8_get_char (const gchar *src);
>glong monoeg_g_utf8_strlen (const gchar *str, gssize max);
># 963 "../../eglib/src/glib.h"
>
># 5 "../../mono/metadata/mono-endian.h" 2
>
>typedef union {
> guint32 ival;
> float fval;
>} mono_rfloat;
>
>typedef union {
> guint64 ival;
> double fval;
> unsigned char cval [8];
>} mono_rdouble;
># 43 "method-to-ir.c" 2
># 1 "../../mono/metadata/tokentype.h" 1
># 9 "../../mono/metadata/tokentype.h"
>typedef enum {
> MONO_TOKEN_MODULE = 0x00000000,
> MONO_TOKEN_TYPE_REF = 0x01000000,
> MONO_TOKEN_TYPE_DEF = 0x02000000,
> MONO_TOKEN_FIELD_DEF = 0x04000000,
> MONO_TOKEN_METHOD_DEF = 0x06000000,
> MONO_TOKEN_PARAM_DEF = 0x08000000,
> MONO_TOKEN_INTERFACE_IMPL = 0x09000000,
> MONO_TOKEN_MEMBER_REF = 0x0a000000,
> MONO_TOKEN_CUSTOM_ATTRIBUTE = 0x0c000000,
> MONO_TOKEN_PERMISSION = 0x0e000000,
> MONO_TOKEN_SIGNATURE = 0x11000000,
> MONO_TOKEN_EVENT = 0x14000000,
> MONO_TOKEN_PROPERTY = 0x17000000,
> MONO_TOKEN_MODULE_REF = 0x1a000000,
> MONO_TOKEN_TYPE_SPEC = 0x1b000000,
> MONO_TOKEN_ASSEMBLY = 0x20000000,
> MONO_TOKEN_ASSEMBLY_REF = 0x23000000,
> MONO_TOKEN_FILE = 0x26000000,
> MONO_TOKEN_EXPORTED_TYPE = 0x27000000,
> MONO_TOKEN_MANIFEST_RESOURCE = 0x28000000,
> MONO_TOKEN_GENERIC_PARAM = 0x2a000000,
> MONO_TOKEN_METHOD_SPEC = 0x2b000000,
>
>
>
>
> MONO_TOKEN_STRING = 0x70000000,
> MONO_TOKEN_NAME = 0x71000000,
> MONO_TOKEN_BASE_TYPE = 0x72000000
>} MonoTokenType;
># 44 "method-to-ir.c" 2
>
># 1 "../../mono/metadata/marshal.h" 1
># 16 "../../mono/metadata/marshal.h"
># 1 "../../mono/metadata/object-internals.h" 1
>
>
>
>
># 1 "../../mono/metadata/threads.h" 1
># 16 "../../mono/metadata/threads.h"
># 1 "../../mono/metadata/appdomain.h" 1
># 16 "../../mono/metadata/appdomain.h"
># 1 "../../mono/metadata/reflection.h" 1
>
>
>
>
>
>
>
>typedef struct MonoTypeNameParse MonoTypeNameParse;
>
>typedef struct {
> MonoMethod *ctor;
> uint32_t data_size;
> const mono_byte* data;
>} MonoCustomAttrEntry;
>
>typedef struct {
> int num_attrs;
> int cached;
> MonoImage *image;
> MonoCustomAttrEntry attrs [0];
>} MonoCustomAttrInfo;
>
>
>
>
>
>
>
>typedef struct {
> char **param_names;
> MonoMarshalSpec **param_marshall;
> MonoCustomAttrInfo **param_cattr;
> uint8_t** param_defaults;
> uint32_t *param_default_types;
> char *dllentry, *dll;
>} MonoReflectionMethodAux;
>
>typedef enum {
> ResolveTokenError_OutOfRange,
> ResolveTokenError_BadTable,
> ResolveTokenError_Other
>} MonoResolveTokenError;
>
>int mono_reflection_parse_type (char *name, MonoTypeNameParse *info);
>MonoType* mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, mono_bool ignorecase, mono_bool *type_resolve);
>void mono_reflection_free_type_info (MonoTypeNameParse *info);
>MonoType* mono_reflection_type_from_name (char *name, MonoImage *image);
>uint32_t mono_reflection_get_token (MonoObject *obj);
>
>MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly);
>MonoReflectionModule* mono_module_get_object (MonoDomain *domain, MonoImage *image);
>MonoReflectionModule* mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index);
>MonoReflectionType* mono_type_get_object (MonoDomain *domain, MonoType *type);
>MonoReflectionMethod* mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refclass);
>MonoReflectionField* mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *field);
>MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property);
>MonoReflectionEvent* mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event);
>
>MonoArray* mono_param_get_objects (MonoDomain *domain, MonoMethod *method);
>MonoReflectionMethodBody* mono_method_body_get_object (MonoDomain *domain, MonoMethod *method);
>
>MonoObject *mono_get_dbnull_object (MonoDomain *domain);
>
>MonoArray* mono_reflection_get_custom_attrs_by_type (MonoObject *obj, MonoClass *attr_klass, MonoError *error);
>MonoArray* mono_reflection_get_custom_attrs (MonoObject *obj);
>MonoArray* mono_reflection_get_custom_attrs_data (MonoObject *obj);
>MonoArray* mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *porpValues, MonoArray *fields, MonoArray* fieldValues);
>
>MonoCustomAttrInfo* mono_reflection_get_custom_attrs_info (MonoObject *obj);
>MonoArray* mono_custom_attrs_construct (MonoCustomAttrInfo *cinfo);
>MonoCustomAttrInfo* mono_custom_attrs_from_index (MonoImage *image, uint32_t idx);
>MonoCustomAttrInfo* mono_custom_attrs_from_method (MonoMethod *method);
>MonoCustomAttrInfo* mono_custom_attrs_from_class (MonoClass *klass);
>MonoCustomAttrInfo* mono_custom_attrs_from_assembly (MonoAssembly *assembly);
>MonoCustomAttrInfo* mono_custom_attrs_from_property (MonoClass *klass, MonoProperty *property);
>MonoCustomAttrInfo* mono_custom_attrs_from_event (MonoClass *klass, MonoEvent *event);
>MonoCustomAttrInfo* mono_custom_attrs_from_field (MonoClass *klass, MonoClassField *field);
>MonoCustomAttrInfo* mono_custom_attrs_from_param (MonoMethod *method, uint32_t param);
>mono_bool mono_custom_attrs_has_attr (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass);
>MonoObject* mono_custom_attrs_get_attr (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass);
>void mono_custom_attrs_free (MonoCustomAttrInfo *ainfo);
>
>
>
>
>
>enum {
> MONO_DECLSEC_FLAG_REQUEST = 0x00000001,
> MONO_DECLSEC_FLAG_DEMAND = 0x00000002,
> MONO_DECLSEC_FLAG_ASSERT = 0x00000004,
> MONO_DECLSEC_FLAG_DENY = 0x00000008,
> MONO_DECLSEC_FLAG_PERMITONLY = 0x00000010,
> MONO_DECLSEC_FLAG_LINKDEMAND = 0x00000020,
> MONO_DECLSEC_FLAG_INHERITANCEDEMAND = 0x00000040,
> MONO_DECLSEC_FLAG_REQUEST_MINIMUM = 0x00000080,
> MONO_DECLSEC_FLAG_REQUEST_OPTIONAL = 0x00000100,
> MONO_DECLSEC_FLAG_REQUEST_REFUSE = 0x00000200,
> MONO_DECLSEC_FLAG_PREJIT_GRANT = 0x00000400,
> MONO_DECLSEC_FLAG_PREJIT_DENY = 0x00000800,
> MONO_DECLSEC_FLAG_NONCAS_DEMAND = 0x00001000,
> MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND = 0x00002000,
> MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND = 0x00004000,
> MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE = 0x00008000,
> MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE = 0x00010000,
> MONO_DECLSEC_FLAG_DEMAND_CHOICE = 0x00020000
>};
>
>uint32_t mono_declsec_flags_from_method (MonoMethod *method);
>uint32_t mono_declsec_flags_from_class (MonoClass *klass);
>uint32_t mono_declsec_flags_from_assembly (MonoAssembly *assembly);
>
>
>
>typedef struct {
> char *blob;
> uint32_t size;
> uint32_t index;
>} MonoDeclSecurityEntry;
>
>typedef struct {
> MonoDeclSecurityEntry demand;
> MonoDeclSecurityEntry noncasdemand;
> MonoDeclSecurityEntry demandchoice;
>} MonoDeclSecurityActions;
>
>MonoBoolean mono_declsec_get_demands (MonoMethod *callee, MonoDeclSecurityActions* demands);
>MonoBoolean mono_declsec_get_linkdemands (MonoMethod *callee, MonoDeclSecurityActions* klass, MonoDeclSecurityActions* cmethod);
>MonoBoolean mono_declsec_get_inheritdemands_class (MonoClass *klass, MonoDeclSecurityActions* demands);
>MonoBoolean mono_declsec_get_inheritdemands_method (MonoMethod *callee, MonoDeclSecurityActions* demands);
>
>MonoBoolean mono_declsec_get_method_action (MonoMethod *method, uint32_t action, MonoDeclSecurityEntry *entry);
>MonoBoolean mono_declsec_get_class_action (MonoClass *klass, uint32_t action, MonoDeclSecurityEntry *entry);
>MonoBoolean mono_declsec_get_assembly_action (MonoAssembly *assembly, uint32_t action, MonoDeclSecurityEntry *entry);
>
>
># 17 "../../mono/metadata/appdomain.h" 2
>
>
>
>typedef void (*MonoThreadStartCB) (intptr_t tid, void* stack_start,
>       void* func);
>typedef void (*MonoThreadAttachCB) (intptr_t tid, void* stack_start);
>
>typedef struct _MonoAppDomain MonoAppDomain;
>typedef struct _MonoJitInfo MonoJitInfo;
>
>typedef void (*MonoDomainFunc) (MonoDomain *domain, void* user_data);
>
>MonoDomain*
>mono_init (const char *filename);
>
>MonoDomain *
>mono_init_from_assembly (const char *domain_name, const char *filename);
>
>MonoDomain *
>mono_init_version (const char *domain_name, const char *version);
>
>MonoDomain*
>mono_get_root_domain (void);
>
>void
>mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb,
>       MonoThreadAttachCB attach_cb);
>
>void
>mono_runtime_cleanup (MonoDomain *domain);
>
>void
>mono_install_runtime_cleanup (MonoDomainFunc func);
>
>void
>mono_runtime_quit (void);
>
>void
>mono_runtime_set_shutting_down (void);
>
>mono_bool
>mono_runtime_is_shutting_down (void);
>
>const char*
>mono_check_corlib_version (void);
>
>MonoDomain *
>mono_domain_create (void);
>
>MonoDomain *
>mono_domain_create_appdomain (char *friendly_name, char *configuration_file);
>
>MonoDomain *
>mono_domain_get (void);
>
>MonoDomain *
>mono_domain_get_by_id (int32_t domainid);
>
>int32_t
>mono_domain_get_id (MonoDomain *domain);
>
>mono_bool
>mono_domain_set (MonoDomain *domain, mono_bool force);
>
>void
>mono_domain_set_internal (MonoDomain *domain);
>
>void
>mono_domain_unload (MonoDomain *domain);
>
>void
>mono_domain_try_unload (MonoDomain *domain, MonoObject **exc);
>
>mono_bool
>mono_domain_is_unloading (MonoDomain *domain);
>
>MonoDomain *
>mono_domain_from_appdomain (MonoAppDomain *appdomain);
>
>void
>mono_domain_foreach (MonoDomainFunc func, void* user_data);
>
>MonoAssembly *
>mono_domain_assembly_open (MonoDomain *domain, const char *name);
>
>mono_bool
>mono_domain_finalize (MonoDomain *domain, uint32_t timeout);
>
>void
>mono_domain_free (MonoDomain *domain, mono_bool force);
>
>mono_bool
>mono_domain_has_type_resolve (MonoDomain *domain);
>
>MonoReflectionAssembly *
>mono_domain_try_type_resolve (MonoDomain *domain, char *name, MonoObject *tb);
>
>mono_bool
>mono_domain_owns_vtable_slot (MonoDomain *domain, void* vtable_slot);
>
>void
>mono_context_init (MonoDomain *domain);
>
>void
>mono_context_set (MonoAppContext *new_context);
>
>MonoAppContext *
>mono_context_get (void);
>
>MonoJitInfo *
>mono_jit_info_table_find (MonoDomain *domain, char *addr);
>
>
>
>void*
>mono_jit_info_get_code_start (MonoJitInfo* ji);
>
>int
>mono_jit_info_get_code_size (MonoJitInfo* ji);
>
>MonoMethod*
>mono_jit_info_get_method (MonoJitInfo* ji);
>
>
>MonoImage*
>mono_get_corlib (void);
>
>MonoClass*
>mono_get_object_class (void);
>
>MonoClass*
>mono_get_byte_class (void);
>
>MonoClass*
>mono_get_void_class (void);
>
>MonoClass*
>mono_get_boolean_class (void);
>
>MonoClass*
>mono_get_sbyte_class (void);
>
>MonoClass*
>mono_get_int16_class (void);
>
>MonoClass*
>mono_get_uint16_class (void);
>
>MonoClass*
>mono_get_int32_class (void);
>
>MonoClass*
>mono_get_uint32_class (void);
>
>MonoClass*
>mono_get_intptr_class (void);
>
>MonoClass*
>mono_get_uintptr_class (void);
>
>MonoClass*
>mono_get_int64_class (void);
>
>MonoClass*
>mono_get_uint64_class (void);
>
>MonoClass*
>mono_get_single_class (void);
>
>MonoClass*
>mono_get_double_class (void);
>
>MonoClass*
>mono_get_char_class (void);
>
>MonoClass*
>mono_get_string_class (void);
>
>MonoClass*
>mono_get_enum_class (void);
>
>MonoClass*
>mono_get_array_class (void);
>
>MonoClass*
>mono_get_thread_class (void);
>
>MonoClass*
>mono_get_exception_class (void);
>
>void
>mono_security_enable_core_clr (void);
>
>typedef mono_bool (*MonoCoreClrPlatformCB) (const char *image_name);
>
>void
>mono_security_set_core_clr_platform_callback (MonoCoreClrPlatformCB callback);
>
>
># 17 "../../mono/metadata/threads.h" 2
>
>
>
>
>typedef mono_bool (*MonoThreadManageCallback) (MonoThread* thread);
>
>extern void mono_thread_init (MonoThreadStartCB start_cb,
>         MonoThreadAttachCB attach_cb);
>extern void mono_thread_cleanup (void);
>extern void mono_thread_manage(void);
>
>extern MonoThread *mono_thread_current (void);
>
>extern void mono_thread_set_main (MonoThread *thread);
>extern MonoThread *mono_thread_get_main (void);
>
>extern void mono_thread_stop (MonoThread *thread);
>
>extern void mono_thread_new_init (intptr_t tid, void* stack_start,
>      void* func);
>extern void mono_thread_create (MonoDomain *domain, void* func, void* arg);
>extern MonoThread *mono_thread_attach (MonoDomain *domain);
>extern void mono_thread_detach (MonoThread *thread);
>extern void mono_thread_exit (void);
>
>void mono_thread_set_manage_callback (MonoThread *thread, MonoThreadManageCallback func);
>
>extern void mono_threads_set_default_stacksize (uint32_t stacksize);
>extern uint32_t mono_threads_get_default_stacksize (void);
>
>void mono_threads_request_thread_dump (void);
>
>
># 6 "../../mono/metadata/object-internals.h" 2
>
># 1 "../../mono/metadata/mempool.h" 1
>
>
>
>
>
>
>
>typedef struct _MonoMemPool MonoMemPool;
>
>MonoMemPool *
>mono_mempool_new (void);
>
>MonoMemPool *
>mono_mempool_new_size (int initial_size);
>
>void
>mono_mempool_destroy (MonoMemPool *pool);
>
>void
>mono_mempool_invalidate (MonoMemPool *pool);
>
>void
>mono_mempool_empty (MonoMemPool *pool);
>
>void
>mono_mempool_stats (MonoMemPool *pool);
>
>void*
>mono_mempool_alloc (MonoMemPool *pool, unsigned int size);
>
>void*
>mono_mempool_alloc0 (MonoMemPool *pool, unsigned int size);
>
>mono_bool
>mono_mempool_contains_addr (MonoMemPool *pool, void* addr);
>
>char*
>mono_mempool_strdup (MonoMemPool *pool, const char *s);
>
>uint32_t
>mono_mempool_get_allocated (MonoMemPool *pool);
>
>
># 8 "../../mono/metadata/object-internals.h" 2
># 1 "../../mono/metadata/class-internals.h" 1
>
>
>
>
>
>
># 1 "../../mono/metadata/metadata-internals.h" 1
>
>
>
>
>
>
>
># 1 "../../mono/metadata/domain-internals.h" 1
># 9 "../../mono/metadata/domain-internals.h"
># 1 "../../mono/metadata/lock-tracer.h" 1
>
>
>
>
>
>
># 1 "../../mono/utils/mono-compiler.h" 1
>
>
>
>
>
>
>
># 1 "../../config.h" 1
># 9 "../../mono/utils/mono-compiler.h" 2
># 8 "../../mono/metadata/lock-tracer.h" 2
>
>
>
>typedef enum {
> InvalidLock = 0,
> LoaderLock,
> ImageDataLock,
> DomainLock,
> DomainAssembliesLock,
> DomainJitCodeHashLock,
>} RuntimeLocks;
># 46 "../../mono/metadata/lock-tracer.h"
>
># 10 "../../mono/metadata/domain-internals.h" 2
># 1 "../../mono/utils/mono-codeman.h" 1
>
>
>
>typedef struct _MonoCodeManager MonoCodeManager;
>
>MonoCodeManager* mono_code_manager_new (void);
>MonoCodeManager* mono_code_manager_new_dynamic (void);
>void mono_code_manager_destroy (MonoCodeManager *cman);
>void mono_code_manager_invalidate (MonoCodeManager *cman);
>void mono_code_manager_set_read_only (MonoCodeManager *cman);
>
>void* mono_code_manager_reserve_align (MonoCodeManager *cman, int size, int alignment);
>
>void* mono_code_manager_reserve (MonoCodeManager *cman, int size);
>void mono_code_manager_commit (MonoCodeManager *cman, void *data, int size, int newsize);
>int mono_code_manager_size (MonoCodeManager *cman, int *used_size);
>
>
>typedef int (*MonoCodeManagerFunc) (void *data, int csize, int size, void *user_data);
>void mono_code_manager_foreach (MonoCodeManager *cman, MonoCodeManagerFunc func, void *user_data);
># 11 "../../mono/metadata/domain-internals.h" 2
># 1 "../../mono/metadata/mono-hash.h" 1
># 38 "../../mono/metadata/mono-hash.h"
>
>
>typedef struct _MonoGHashTable MonoGHashTable;
>
>typedef gpointer (*MonoGRemapperFunc) (gpointer key, gpointer value,
>            gpointer user_data);
>
>
>typedef enum {
> MONO_HASH_CONSERVATIVE_GC,
> MONO_HASH_KEY_GC,
> MONO_HASH_VALUE_GC,
> MONO_HASH_KEY_VALUE_GC
>} MonoGHashGCType;
>
>
>
>MonoGHashTable* mono_g_hash_table_new (GHashFunc hash_func,
>         GEqualFunc key_equal_func);
>MonoGHashTable* mono_g_hash_table_new_type (GHashFunc hash_func,
>         GEqualFunc key_equal_func,
>         MonoGHashGCType type);
>MonoGHashTable* mono_g_hash_table_new_full (GHashFunc hash_func,
>         GEqualFunc key_equal_func,
>         GDestroyNotify key_destroy_func,
>         GDestroyNotify value_destroy_func);
>void mono_g_hash_table_destroy (MonoGHashTable *hash_table);
>void mono_g_hash_table_insert (MonoGHashTable *hash_table,
>         gpointer key,
>         gpointer value);
>void mono_g_hash_table_replace (MonoGHashTable *hash_table,
>         gpointer key,
>         gpointer value);
>gboolean mono_g_hash_table_remove (MonoGHashTable *hash_table,
>         gconstpointer key);
>gboolean mono_g_hash_table_steal (MonoGHashTable *hash_table,
>         gconstpointer key);
>gpointer mono_g_hash_table_lookup (MonoGHashTable *hash_table,
>         gconstpointer key);
>gboolean mono_g_hash_table_lookup_extended (MonoGHashTable *hash_table,
>         gconstpointer lookup_key,
>         gpointer *orig_key,
>         gpointer *value);
>void mono_g_hash_table_foreach (MonoGHashTable *hash_table,
>         GHFunc func,
>         gpointer user_data);
>guint mono_g_hash_table_foreach_remove (MonoGHashTable *hash_table,
>         GHRFunc func,
>         gpointer user_data);
>guint mono_g_hash_table_foreach_steal (MonoGHashTable *hash_table,
>         GHRFunc func,
>         gpointer user_data);
>gpointer mono_g_hash_table_find (MonoGHashTable *hash_table,
>         GHRFunc predicate,
>         gpointer user_data);
>guint mono_g_hash_table_size (MonoGHashTable *hash_table);
>
>void mono_g_hash_table_remap (MonoGHashTable *hash_table,
>          MonoGRemapperFunc func,
>          gpointer user_data);
>
>void mono_g_hash_table_print_stats (MonoGHashTable *table);
>
>
># 12 "../../mono/metadata/domain-internals.h" 2
>
># 1 "../../mono/utils/mono-internal-hash.h" 1
># 35 "../../mono/utils/mono-internal-hash.h"
>typedef struct _MonoInternalHashTable MonoInternalHashTable;
>
>typedef gpointer (*MonoInternalHashKeyExtractFunc) (gpointer value);
>typedef gpointer* (*MonoInternalHashNextValueFunc) (gpointer value);
>
>struct _MonoInternalHashTable
>{
> GHashFunc hash_func;
> MonoInternalHashKeyExtractFunc key_extract;
> MonoInternalHashNextValueFunc next_value;
> gint size;
> gint num_entries;
> gpointer *table;
>};
>
>void
>mono_internal_hash_table_init (MonoInternalHashTable *table,
>          GHashFunc hash_func,
>          MonoInternalHashKeyExtractFunc key_extract,
>          MonoInternalHashNextValueFunc next_value) __attribute__ ((visibility ("hidden")));
>
>void
>mono_internal_hash_table_destroy (MonoInternalHashTable *table) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_internal_hash_table_lookup (MonoInternalHashTable *table, gpointer key) __attribute__ ((visibility ("hidden")));
># 69 "../../mono/utils/mono-internal-hash.h"
>void
>mono_internal_hash_table_insert (MonoInternalHashTable *table,
>     gpointer key, gpointer value) __attribute__ ((visibility ("hidden")));
>
>void
>mono_internal_hash_table_remove (MonoInternalHashTable *table, gpointer key) __attribute__ ((visibility ("hidden")));
># 14 "../../mono/metadata/domain-internals.h" 2
># 1 "../../mono/io-layer/io-layer.h" 1
># 35 "../../mono/io-layer/io-layer.h"
># 1 "../../mono/io-layer/wapi.h" 1
># 13 "../../mono/io-layer/wapi.h"
># 1 "../../mono/io-layer/types.h" 1
># 15 "../../mono/io-layer/types.h"
>typedef union {
> struct {
>  guint32 LowPart;
>  gint32 HighPart;
> } u;
> guint64 QuadPart;
>} WapiLargeInteger;
>
>typedef union {
> struct {
>  guint32 LowPart;
>  guint32 HighPart;
> } u;
> guint64 QuadPart;
>} WapiULargeInteger;
># 14 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/macros.h" 1
># 15 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/handles.h" 1
># 15 "../../mono/io-layer/handles.h"
>
>
>extern gboolean CloseHandle (gpointer handle);
>extern gboolean DuplicateHandle (gpointer srcprocess, gpointer src, gpointer targetprocess, gpointer *target, guint32 access, gboolean inherit, guint32 options);
>
>
>extern void _wapi_cleanup (void);
>
>
># 16 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/io.h" 1
># 15 "../../mono/io-layer/io.h"
># 1 "../../mono/io-layer/wapi.h" 1
># 16 "../../mono/io-layer/io.h" 2
># 1 "../../mono/io-layer/timefuncs.h" 1
># 17 "../../mono/io-layer/timefuncs.h"
>
>
>
>
>
>typedef struct
>{
>
> guint32 dwHighDateTime;
> guint32 dwLowDateTime;
>
>
>
>
>} WapiFileTime;
>
>extern gboolean QueryPerformanceCounter(WapiLargeInteger *count);
>extern gboolean QueryPerformanceFrequency(WapiLargeInteger *freq);
>extern guint32 GetTickCount (void);
>
>
># 17 "../../mono/io-layer/io.h" 2
>
>
>
>typedef struct _WapiSecurityAttributes WapiSecurityAttributes;
>
>struct _WapiSecurityAttributes
>{
> guint32 nLength;
> gpointer lpSecurityDescriptor;
> gboolean bInheritHandle;
>};
>
>typedef struct _WapiOverlapped WapiOverlapped;
>
>struct _WapiOverlapped
>{
> guint32 Internal;
> guint32 InternalHigh;
> guint32 Offset;
> guint32 OffsetHigh;
> gpointer hEvent;
> gpointer handle1;
> gpointer handle2;
>};
>
>typedef void (*WapiOverlappedCB) (guint32 error, guint32 numbytes,
>      WapiOverlapped *overlapped);
># 90 "../../mono/io-layer/io.h"
>typedef enum {
> STD_INPUT_HANDLE=-10,
> STD_OUTPUT_HANDLE=-11,
> STD_ERROR_HANDLE=-12
>} WapiStdHandle;
>
>typedef enum {
> FILE_BEGIN=0,
> FILE_CURRENT=1,
> FILE_END=2
>} WapiSeekMethod;
>
>typedef enum {
> FILE_TYPE_UNKNOWN=0x0000,
> FILE_TYPE_DISK=0x0001,
> FILE_TYPE_CHAR=0x0002,
> FILE_TYPE_PIPE=0x0003,
> FILE_TYPE_REMOTE=0x8000
>} WapiFileType;
>
>typedef enum {
> DRIVE_UNKNOWN=0,
> DRIVE_NO_ROOT_DIR=1,
> DRIVE_REMOVABLE=2,
> DRIVE_FIXED=3,
> DRIVE_REMOTE=4,
> DRIVE_CDROM=5,
> DRIVE_RAMDISK=6
>} WapiDriveType;
>
>typedef enum {
> GetFileExInfoStandard=0x0000,
> GetFileExMaxInfoLevel=0x0001
>} WapiGetFileExInfoLevels;
>
>typedef struct
>{
> guint16 wYear;
> guint16 wMonth;
> guint16 wDayOfWeek;
> guint16 wDay;
> guint16 wHour;
> guint16 wMinute;
> guint16 wSecond;
> guint16 wMilliseconds;
>} WapiSystemTime;
>
>typedef struct
>{
> guint32 dwFileAttributes;
> WapiFileTime ftCreationTime;
> WapiFileTime ftLastAccessTime;
> WapiFileTime ftLastWriteTime;
> guint32 nFileSizeHigh;
> guint32 nFileSizeLow;
> guint32 dwReserved0;
> guint32 dwReserved1;
> gunichar2 cFileName [260];
> gunichar2 cAlternateFileName [14];
>} WapiFindData;
>
>typedef struct
>{
> guint32 dwFileAttributes;
> WapiFileTime ftCreationTime;
> WapiFileTime ftLastAccessTime;
> WapiFileTime ftLastWriteTime;
> guint32 nFileSizeHigh;
> guint32 nFileSizeLow;
>} WapiFileAttributesData;
>
>
>
>
>
>extern gpointer CreateFile(const gunichar2 *name, guint32 fileaccess,
>      guint32 sharemode,
>      WapiSecurityAttributes *security,
>      guint32 createmode,
>      guint32 attrs, gpointer tmplate);
>extern gboolean DeleteFile(const gunichar2 *name);
>extern gpointer GetStdHandle(WapiStdHandle stdhandle);
>extern gboolean ReadFile(gpointer handle, gpointer buffer, guint32 numbytes,
>    guint32 *bytesread, WapiOverlapped *overlapped);
>extern gboolean WriteFile(gpointer handle, gconstpointer buffer,
>     guint32 numbytes, guint32 *byteswritten,
>     WapiOverlapped *overlapped);
>extern gboolean FlushFileBuffers(gpointer handle);
>extern gboolean SetEndOfFile(gpointer handle);
>extern guint32 SetFilePointer(gpointer handle, gint32 movedistance,
>         gint32 *highmovedistance, WapiSeekMethod method);
>extern WapiFileType GetFileType(gpointer handle);
>extern guint32 GetFileSize(gpointer handle, guint32 *highsize);
>extern gboolean GetFileTime(gpointer handle, WapiFileTime *create_time,
>       WapiFileTime *last_access,
>       WapiFileTime *last_write);
>extern gboolean SetFileTime(gpointer handle, const WapiFileTime *create_time,
>       const WapiFileTime *last_access,
>       const WapiFileTime *last_write);
>extern gboolean FileTimeToSystemTime(const WapiFileTime *file_time,
>         WapiSystemTime *system_time);
>extern gpointer FindFirstFile (const gunichar2 *pattern,
>          WapiFindData *find_data);
>extern gboolean FindNextFile (gpointer handle, WapiFindData *find_data);
>extern gboolean FindClose (gpointer handle);
>extern gboolean CreateDirectory (const gunichar2 *name,
>     WapiSecurityAttributes *security);
>extern gboolean RemoveDirectory (const gunichar2 *name);
>extern gboolean MoveFile (const gunichar2 *name, const gunichar2 *dest_name);
>extern gboolean CopyFile (const gunichar2 *name, const gunichar2 *dest_name,
>     gboolean fail_if_exists);
>extern gboolean ReplaceFile (const gunichar2 *replacedFileName, const gunichar2 *replacementFileName,
>        const gunichar2 *backupFileName, guint32 replaceFlags,
>        gpointer exclude, gpointer reserved);
>extern guint32 GetFileAttributes (const gunichar2 *name);
>extern gboolean GetFileAttributesEx (const gunichar2 *name,
>         WapiGetFileExInfoLevels level,
>         gpointer info);
>extern gboolean SetFileAttributes (const gunichar2 *name, guint32 attrs);
>extern guint32 GetCurrentDirectory (guint32 length, gunichar2 *buffer);
>extern gboolean SetCurrentDirectory (const gunichar2 *path);
>extern gboolean CreatePipe (gpointer *readpipe, gpointer *writepipe,
>       WapiSecurityAttributes *security, guint32 size);
>extern guint32 GetTempPath (guint32 len, gunichar2 *buf);
>extern gint32 GetLogicalDriveStrings (guint32 len, gunichar2 *buf);
>extern gboolean GetDiskFreeSpaceEx(const gunichar2 *path_name, WapiULargeInteger *free_bytes_avail,
>       WapiULargeInteger *total_number_of_bytes,
>       WapiULargeInteger *total_number_of_free_bytes);
>extern guint32 GetDriveType(const gunichar2 *root_path_name);
>extern gboolean LockFile (gpointer handle, guint32 offset_low,
>     guint32 offset_high, guint32 length_low,
>     guint32 length_high);
>extern gboolean UnlockFile (gpointer handle, guint32 offset_low,
>       guint32 offset_high, guint32 length_low,
>       guint32 length_high);
>extern gboolean GetVolumeInformation (const gunichar2 *path, gunichar2 *volumename, int volumesize, int *outserial, int *maxcomp, int *fsflags, gunichar2 *fsbuffer, int fsbuffersize);
>
>
># 17 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/access.h" 1
># 18 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/atomic.h" 1
># 345 "../../mono/io-layer/atomic.h"
>static inline gint32
>InterlockedCompareExchange(volatile gint32 *dest,
>      gint32 exch, gint32 comp)
>{
> gint32 old;
>
> __asm__ __volatile__ ("\tLA\t1,%0\n"
>         "\tLR\t%1,%3\n"
>         "\tCS\t%1,%2,0(1)\n"
>         : "+m" (*dest), "=&r" (old)
>         : "r" (exch), "r" (comp)
>         : "1", "cc");
> return(old);
>}
># 376 "../../mono/io-layer/atomic.h"
>static inline gpointer
>InterlockedCompareExchangePointer(volatile gpointer *dest,
>      gpointer exch,
>             gpointer comp)
>{
> gpointer old;
>
> __asm__ __volatile__ ("\tLA\t1,%0\n"
>         "\tLGR\t%1,%3\n"
>         "\tCSG\t%1,%2,0(1)\n"
>         : "+m" (*dest), "=&r" (old)
>         : "r" (exch), "r" (comp)
>         : "1", "cc");
>
> return(old);
>}
># 413 "../../mono/io-layer/atomic.h"
>static inline gint32
>InterlockedIncrement(volatile gint32 *val)
>{
> gint32 tmp;
>
> __asm__ __volatile__ ("\tLA\t2,%1\n"
>         "0:\tLGF\t%0,%1\n"
>         "\tLGFR\t1,%0\n"
>         "\tAGHI\t1,1\n"
>         "\tCS\t%0,1,0(2)\n"
>         "\tJNZ\t0b\n"
>         "\tLGFR\t%0,1"
>         : "=r" (tmp), "+m" (*val)
>         : : "1", "2", "cc");
>
> return(tmp);
>}
># 451 "../../mono/io-layer/atomic.h"
>static inline gint32
>InterlockedDecrement(volatile gint32 *val)
>{
> gint32 tmp;
>
> __asm__ __volatile__ ("\tLA\t2,%1\n"
>         "0:\tLGF\t%0,%1\n"
>         "\tLGFR\t1,%0\n"
>         "\tAGHI\t1,-1\n"
>         "\tCS\t%0,1,0(2)\n"
>         "\tJNZ\t0b\n"
>         "\tLGFR\t%0,1"
>         : "=r" (tmp), "+m" (*val)
>         : : "1", "2", "cc");
>
> return(tmp);
>}
>
>
>static inline gint32
>InterlockedExchange(volatile gint32 *val, gint32 new_val)
>{
> gint32 ret;
>
> __asm__ __volatile__ ("\tLA\t1,%0\n"
>         "0:\tL\t%1,%0\n"
>         "\tCS\t%1,%2,0(1)\n"
>         "\tJNZ\t0b"
>         : "+m" (*val), "=&r" (ret)
>         : "r" (new_val)
>         : "1", "cc");
>
> return(ret);
>}
># 503 "../../mono/io-layer/atomic.h"
>static inline gpointer
>InterlockedExchangePointer(volatile gpointer *val, gpointer new_val)
>{
> gpointer ret;
>
> __asm__ __volatile__ ("\tLA\t1,%0\n"
>         "0:\tLG\t%1,%0\n"
>         "\tCSG\t%1,%2,0(1)\n"
>         "\tJNZ\t0b"
>         : "+m" (*val), "=&r" (ret)
>         : "r" (new_val)
>         : "1", "cc");
>
> return(ret);
>}
># 539 "../../mono/io-layer/atomic.h"
>static inline gint32
>InterlockedExchangeAdd(volatile gint32 *val, gint32 add)
>{
> gint32 ret;
>
> __asm__ __volatile__ ("\tLA\t2,%1\n"
>         "0:\tLGF\t%0,%1\n"
>         "\tLGFR\t1,%0\n"
>         "\tAGR\t1,%2\n"
>         "\tCS\t%0,1,0(2)\n"
>         "\tJNZ\t0b"
>         : "=&r" (ret), "+m" (*val)
>         : "r" (add)
>         : "1", "2", "cc");
>
> return(ret);
>}
># 19 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/context.h" 1
># 37 "../../mono/io-layer/context.h"
>typedef struct
>{
> guint32 ControlWord;
> guint32 StatusWord;
> guint32 TagWord;
> guint32 ErrorOffset;
> guint32 ErrorSelector;
> guint32 DataOffset;
> guint32 DataSelector;
> guint8 RegisterArea[80];
> guint32 Cr0NpxState;
>} WapiFloatingSaveArea;
>
>typedef struct
>{
> guint32 ContextFlags;
> guint32 Dr0;
> guint32 Dr1;
> guint32 Dr2;
> guint32 Dr3;
> guint32 Dr6;
> guint32 Dr7;
>
> WapiFloatingSaveArea FloatSave;
>
> guint32 SegGs;
> guint32 SegFs;
> guint32 SegEs;
> guint32 SegDs;
>
> guint32 Edi;
> guint32 Esi;
> guint32 Ebx;
> guint32 Edx;
> guint32 Ecx;
> guint32 Eax;
>
> guint32 Ebp;
> guint32 Eip;
> guint32 SegCs;
> guint32 EFlags;
> guint32 Esp;
> guint32 SegSs;
>
> guint8 ExtendedRegisters[512];
>} WapiContext;
>
>
>
>extern gboolean GetThreadContext(gpointer handle, WapiContext *context);
>
>
># 20 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/critical-sections.h" 1
># 14 "../../mono/io-layer/critical-sections.h"
># 1 "/usr/include/pthread.h" 1 3 4
># 23 "/usr/include/pthread.h" 3 4
># 1 "/usr/include/sched.h" 1 3 4
># 28 "/usr/include/sched.h" 3 4
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 29 "/usr/include/sched.h" 2 3 4
>
>
>
>
>
># 1 "/usr/include/time.h" 1 3 4
># 35 "/usr/include/sched.h" 2 3 4
># 43 "/usr/include/sched.h" 3 4
># 1 "/usr/include/bits/sched.h" 1 3 4
># 72 "/usr/include/bits/sched.h" 3 4
>struct sched_param
>  {
>    int __sched_priority;
>  };
>
>
>
>
>
>extern int clone (int (*__fn) (void *__arg), void *__child_stack,
>    int __flags, void *__arg, ...) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int unshare (int __flags) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_getcpu (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int setns (int __fd, int __nstype) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>
>
>
>struct __sched_param
>  {
>    int __sched_priority;
>  };
># 118 "/usr/include/bits/sched.h" 3 4
>typedef unsigned long int __cpu_mask;
>
>
>
>
>
>
>typedef struct
>{
>  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
>} cpu_set_t;
># 201 "/usr/include/bits/sched.h" 3 4
>
>
>extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
>  __attribute__ ((__nothrow__ , __leaf__));
>extern cpu_set_t *__sched_cpualloc (size_t __count) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern void __sched_cpufree (cpu_set_t *__set) __attribute__ ((__nothrow__ , __leaf__));
>
>
># 44 "/usr/include/sched.h" 2 3 4
>
>
>
>
>
>
>
>extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_getparam (__pid_t __pid, struct sched_param *__param) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_setscheduler (__pid_t __pid, int __policy,
>          const struct sched_param *__param) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_getscheduler (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_yield (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_get_priority_max (int __algorithm) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_get_priority_min (int __algorithm) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) __attribute__ ((__nothrow__ , __leaf__));
># 118 "/usr/include/sched.h" 3 4
>extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
>         const cpu_set_t *__cpuset) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
>         cpu_set_t *__cpuset) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 24 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/time.h" 1 3 4
># 29 "/usr/include/time.h" 3 4
>
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/s390x-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 38 "/usr/include/time.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 86 "/usr/include/bits/time.h" 3 4
># 1 "/usr/include/bits/timex.h" 1 3 4
># 25 "/usr/include/bits/timex.h" 3 4
>struct timex
>{
>  unsigned int modes;
>  __syscall_slong_t offset;
>  __syscall_slong_t freq;
>  __syscall_slong_t maxerror;
>  __syscall_slong_t esterror;
>  int status;
>  __syscall_slong_t constant;
>  __syscall_slong_t precision;
>  __syscall_slong_t tolerance;
>  struct timeval time;
>  __syscall_slong_t tick;
>  __syscall_slong_t ppsfreq;
>  __syscall_slong_t jitter;
>  int shift;
>  __syscall_slong_t stabil;
>  __syscall_slong_t jitcnt;
>  __syscall_slong_t calcnt;
>  __syscall_slong_t errcnt;
>  __syscall_slong_t stbcnt;
>
>  int tai;
>
>
>  int :32; int :32; int :32; int :32;
>  int :32; int :32; int :32; int :32;
>  int :32; int :32; int :32;
>};
># 87 "/usr/include/bits/time.h" 2 3 4
>
>
>
>
>extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) __attribute__ ((__nothrow__ , __leaf__));
>
>
># 42 "/usr/include/time.h" 2 3 4
># 131 "/usr/include/time.h" 3 4
>
>
>struct tm
>{
>  int tm_sec;
>  int tm_min;
>  int tm_hour;
>  int tm_mday;
>  int tm_mon;
>  int tm_year;
>  int tm_wday;
>  int tm_yday;
>  int tm_isdst;
>
>
>  long int tm_gmtoff;
>  const char *tm_zone;
>
>
>
>
>};
>
>
>
>
>
>
>
>
>struct itimerspec
>  {
>    struct timespec it_interval;
>    struct timespec it_value;
>  };
>
>
>struct sigevent;
># 186 "/usr/include/time.h" 3 4
>
>
>
>extern clock_t clock (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern time_t time (time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double difftime (time_t __time1, time_t __time0)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern time_t mktime (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern size_t strftime (char *__restrict __s, size_t __maxsize,
>   const char *__restrict __format,
>   const struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *strptime (const char *__restrict __s,
>         const char *__restrict __fmt, struct tm *__tp)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
>     const char *__restrict __format,
>     const struct tm *__restrict __tp,
>     __locale_t __loc) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern char *strptime_l (const char *__restrict __s,
>    const char *__restrict __fmt, struct tm *__tp,
>    __locale_t __loc) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern struct tm *gmtime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern struct tm *localtime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern struct tm *gmtime_r (const time_t *__restrict __timer,
>       struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern struct tm *localtime_r (const time_t *__restrict __timer,
>          struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *asctime (const struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern char *ctime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern char *asctime_r (const struct tm *__restrict __tp,
>   char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern char *ctime_r (const time_t *__restrict __timer,
>        char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern char *__tzname[2];
>extern int __daylight;
>extern long int __timezone;
>
>
>
>
>extern char *tzname[2];
>
>
>
>extern void tzset (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int daylight;
>extern long int timezone;
>
>
>
>
>
>extern int stime (const time_t *__when) __attribute__ ((__nothrow__ , __leaf__));
># 319 "/usr/include/time.h" 3 4
>extern time_t timegm (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern time_t timelocal (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int dysize (int __year) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
># 334 "/usr/include/time.h" 3 4
>extern int nanosleep (const struct timespec *__requested_time,
>        struct timespec *__remaining);
>
>
>
>extern int clock_getres (clockid_t __clock_id, struct timespec *__res) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int clock_nanosleep (clockid_t __clock_id, int __flags,
>       const struct timespec *__req,
>       struct timespec *__rem);
>
>
>extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int timer_create (clockid_t __clock_id,
>    struct sigevent *__restrict __evp,
>    timer_t *__restrict __timerid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int timer_delete (timer_t __timerid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int timer_settime (timer_t __timerid, int __flags,
>     const struct itimerspec *__restrict __value,
>     struct itimerspec *__restrict __ovalue) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int timer_getoverrun (timer_t __timerid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int timespec_get (struct timespec *__ts, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 403 "/usr/include/time.h" 3 4
>extern int getdate_err;
># 412 "/usr/include/time.h" 3 4
>extern struct tm *getdate (const char *__string);
># 426 "/usr/include/time.h" 3 4
>extern int getdate_r (const char *__restrict __string,
>        struct tm *__restrict __resbufp);
>
>
>
># 25 "/usr/include/pthread.h" 2 3 4
>
>
># 1 "/usr/include/bits/setjmp.h" 1 3 4
># 27 "/usr/include/bits/setjmp.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 28 "/usr/include/bits/setjmp.h" 2 3 4
>
>
>
>typedef struct __s390_jmp_buf
>{
>
>  long int __gregs[10];
>
>
>
>  long __fpregs[8];
>
>
>
>
>} __jmp_buf[1];
># 28 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/pthread.h" 2 3 4
>
>
>
>enum
>{
>  PTHREAD_CREATE_JOINABLE,
>
>  PTHREAD_CREATE_DETACHED
>
>};
>
>
>
>enum
>{
>  PTHREAD_MUTEX_TIMED_NP,
>  PTHREAD_MUTEX_RECURSIVE_NP,
>  PTHREAD_MUTEX_ERRORCHECK_NP,
>  PTHREAD_MUTEX_ADAPTIVE_NP
>
>  ,
>  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
>  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
>  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
>  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
>
>
>
>  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
>
>};
>
>
>
>
>enum
>{
>  PTHREAD_MUTEX_STALLED,
>  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
>  PTHREAD_MUTEX_ROBUST,
>  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
>};
>
>
>
>
>
>enum
>{
>  PTHREAD_PRIO_NONE,
>  PTHREAD_PRIO_INHERIT,
>  PTHREAD_PRIO_PROTECT
>};
># 116 "/usr/include/pthread.h" 3 4
>enum
>{
>  PTHREAD_RWLOCK_PREFER_READER_NP,
>  PTHREAD_RWLOCK_PREFER_WRITER_NP,
>  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
>  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
>};
># 157 "/usr/include/pthread.h" 3 4
>enum
>{
>  PTHREAD_INHERIT_SCHED,
>
>  PTHREAD_EXPLICIT_SCHED
>
>};
>
>
>
>enum
>{
>  PTHREAD_SCOPE_SYSTEM,
>
>  PTHREAD_SCOPE_PROCESS
>
>};
>
>
>
>enum
>{
>  PTHREAD_PROCESS_PRIVATE,
>
>  PTHREAD_PROCESS_SHARED
>
>};
># 192 "/usr/include/pthread.h" 3 4
>struct _pthread_cleanup_buffer
>{
>  void (*__routine) (void *);
>  void *__arg;
>  int __canceltype;
>  struct _pthread_cleanup_buffer *__prev;
>};
>
>
>enum
>{
>  PTHREAD_CANCEL_ENABLE,
>
>  PTHREAD_CANCEL_DISABLE
>
>};
>enum
>{
>  PTHREAD_CANCEL_DEFERRED,
>
>  PTHREAD_CANCEL_ASYNCHRONOUS
>
>};
># 230 "/usr/include/pthread.h" 3 4
>
>
>
>
>
>extern int pthread_create (pthread_t *__restrict __newthread,
>      const pthread_attr_t *__restrict __attr,
>      void *(*__start_routine) (void *),
>      void *__restrict __arg) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>
>extern int pthread_join (pthread_t __th, void **__thread_return);
>
>
>
>
>extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
>     const struct timespec *__abstime);
>
>
>
>
>
>
>extern int pthread_detach (pthread_t __th) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern pthread_t pthread_self (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
>  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>
>
>extern int pthread_attr_init (pthread_attr_t *__attr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_destroy (pthread_attr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
>     int *__detachstate)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
>     int __detachstate)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
>          size_t *__guardsize)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
>          size_t __guardsize)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
>           struct sched_param *__restrict __param)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
>           const struct sched_param *__restrict
>           __param) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
>     __attr, int *__restrict __policy)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
>      __attr, int *__restrict __inherit)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
>      int __inherit)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
>      int *__restrict __scope)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
>          __attr, void **__restrict __stackaddr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
>
>
>
>
>
>extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
>          void *__stackaddr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
>
>
>extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
>          __attr, size_t *__restrict __stacksize)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
>          size_t __stacksize)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
>      void **__restrict __stackaddr,
>      size_t *__restrict __stacksize)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
>extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
>      size_t __stacksize) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
>     size_t __cpusetsize,
>     const cpu_set_t *__cpuset)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
>     size_t __cpusetsize,
>     cpu_set_t *__cpuset)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>extern int pthread_getattr_default_np (pthread_attr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>
>extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
>      const struct sched_param *__param)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3)));
>
>
>extern int pthread_getschedparam (pthread_t __target_thread,
>      int *__restrict __policy,
>      struct sched_param *__restrict __param)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
>
>
>extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
>          size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int pthread_getconcurrency (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int pthread_setconcurrency (int __level) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern int pthread_yield (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
>       const cpu_set_t *__cpuset)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3)));
>
>
>extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
>       cpu_set_t *__cpuset)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3)));
># 496 "/usr/include/pthread.h" 3 4
>extern int pthread_once (pthread_once_t *__once_control,
>    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
># 508 "/usr/include/pthread.h" 3 4
>extern int pthread_setcancelstate (int __state, int *__oldstate);
>
>
>
>extern int pthread_setcanceltype (int __type, int *__oldtype);
>
>
>extern int pthread_cancel (pthread_t __th);
>
>
>
>
>extern void pthread_testcancel (void);
>
>
>
>
>typedef struct
>{
>  struct
>  {
>    __jmp_buf __cancel_jmp_buf;
>    int __mask_was_saved;
>  } __cancel_jmp_buf[1];
>  void *__pad[4];
>} __pthread_unwind_buf_t __attribute__ ((__aligned__));
># 542 "/usr/include/pthread.h" 3 4
>struct __pthread_cleanup_frame
>{
>  void (*__cancel_routine) (void *);
>  void *__cancel_arg;
>  int __do_it;
>  int __cancel_type;
>};
># 609 "/usr/include/pthread.h" 3 4
>extern __inline void
>__pthread_cleanup_routine (struct __pthread_cleanup_frame *__frame)
>{
>  if (__frame->__do_it)
>    __frame->__cancel_routine (__frame->__cancel_arg);
>}
># 744 "/usr/include/pthread.h" 3 4
>struct __jmp_buf_tag;
>extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int pthread_mutex_init (pthread_mutex_t *__mutex,
>          const pthread_mutexattr_t *__mutexattr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
>        const struct timespec *__restrict
>        __abstime) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
>      __restrict __mutex,
>      int *__restrict __prioceiling)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
>      int __prioceiling,
>      int *__restrict __old_ceiling)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 808 "/usr/include/pthread.h" 3 4
>extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
>      __restrict __attr,
>      int *__restrict __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
>      int __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
>          __attr, int *__restrict __kind)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
>       __restrict __attr,
>       int *__restrict __protocol)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
>       int __protocol)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
>          __restrict __attr,
>          int *__restrict __prioceiling)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
>          int __prioceiling)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
>     int *__robustness)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
>        int *__robustness)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
>     int __robustness)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
>        int __robustness)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 890 "/usr/include/pthread.h" 3 4
>extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
>    const pthread_rwlockattr_t *__restrict
>    __attr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
>  __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
>           const struct timespec *__restrict
>           __abstime) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
>           const struct timespec *__restrict
>           __abstime) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
>       __restrict __attr,
>       int *__restrict __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
>       int __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
>       __restrict __attr,
>       int *__restrict __pref)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
>       int __pref) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
>         const pthread_condattr_t *__restrict __cond_attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_destroy (pthread_cond_t *__cond)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_signal (pthread_cond_t *__cond)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_broadcast (pthread_cond_t *__cond)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
>         pthread_mutex_t *__restrict __mutex)
>     __attribute__ ((__nonnull__ (1, 2)));
># 1002 "/usr/include/pthread.h" 3 4
>extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
>       pthread_mutex_t *__restrict __mutex,
>       const struct timespec *__restrict __abstime)
>     __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
>extern int pthread_condattr_init (pthread_condattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_condattr_getpshared (const pthread_condattr_t *
>     __restrict __attr,
>     int *__restrict __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
>     int __pshared) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_condattr_getclock (const pthread_condattr_t *
>          __restrict __attr,
>          __clockid_t *__restrict __clock_id)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
>          __clockid_t __clock_id)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 1046 "/usr/include/pthread.h" 3 4
>extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_lock (pthread_spinlock_t *__lock)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
>     const pthread_barrierattr_t *__restrict
>     __attr, unsigned int __count)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
>        __restrict __attr,
>        int *__restrict __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
>        int __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 1113 "/usr/include/pthread.h" 3 4
>extern int pthread_key_create (pthread_key_t *__key,
>          void (*__destr_function) (void *))
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_key_delete (pthread_key_t __key) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void *pthread_getspecific (pthread_key_t __key) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int pthread_setspecific (pthread_key_t __key,
>    const void *__pointer) __attribute__ ((__nothrow__ , __leaf__)) ;
>
>
>
>
>extern int pthread_getcpuclockid (pthread_t __thread_id,
>      __clockid_t *__clock_id)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
># 1147 "/usr/include/pthread.h" 3 4
>extern int pthread_atfork (void (*__prepare) (void),
>      void (*__parent) (void),
>      void (*__child) (void)) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) pthread_equal (pthread_t __thread1, pthread_t __thread2)
>{
>  return __thread1 == __thread2;
>}
>
>
>
># 15 "../../mono/io-layer/critical-sections.h" 2
>
># 1 "../../mono/io-layer/mono-mutex.h" 1
># 20 "../../mono/io-layer/mono-mutex.h"
>
>
>
>
>typedef struct {
> pthread_mutex_t mutex;
> gboolean complete;
>} mono_once_t;
>
>
>
>int mono_once (mono_once_t *once, void (*once_init) (void));
># 119 "../../mono/io-layer/mono-mutex.h"
>typedef pthread_mutex_t mono_mutex_t;
>typedef pthread_mutexattr_t mono_mutexattr_t;
>typedef pthread_cond_t mono_cond_t;
># 157 "../../mono/io-layer/mono-mutex.h"
>__attribute__((__unused__))
>static inline int mono_mutex_unlock_in_cleanup (mono_mutex_t *mutex)
>{
> return(pthread_mutex_unlock (mutex));
>}
># 185 "../../mono/io-layer/mono-mutex.h"
>
># 17 "../../mono/io-layer/critical-sections.h" 2
>
>
>
>typedef struct _WapiCriticalSection WapiCriticalSection;
>
>struct _WapiCriticalSection
>{
> guint32 depth;
> mono_mutex_t mutex;
>};
>
>extern void InitializeCriticalSection(WapiCriticalSection *section);
>extern gboolean InitializeCriticalSectionAndSpinCount(WapiCriticalSection *section, guint32 spincount);
>extern void DeleteCriticalSection(WapiCriticalSection *section);
>extern guint32 SetCriticalSectionSpinCount(WapiCriticalSection *section, guint32 spincount);
>extern gboolean TryEnterCriticalSection(WapiCriticalSection *section);
># 50 "../../mono/io-layer/critical-sections.h"
>
># 21 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/error.h" 1
># 13 "../../mono/io-layer/error.h"
>typedef enum {
> ERROR_SUCCESS = 0,
> NO_ERROR = 0,
> ERROR_INVALID_FUNCTION = 1,
> ERROR_FILE_NOT_FOUND = 2,
> ERROR_PATH_NOT_FOUND = 3,
> ERROR_TOO_MANY_OPEN_FILES = 4,
> ERROR_ACCESS_DENIED = 5,
> ERROR_INVALID_HANDLE = 6,
> ERROR_ARENA_TRASHED = 7,
> ERROR_NOT_ENOUGH_MEMORY = 8,
> ERROR_INVALID_BLOCK = 9,
> ERROR_BAD_ENVIRONMENT = 10,
> ERROR_BAD_FORMAT = 11,
> ERROR_INVALID_ACCESS = 12,
> ERROR_INVALID_DATA = 13,
> ERROR_OUTOFMEMORY = 14,
> ERROR_INVALID_DRIVE = 15,
> ERROR_CURRENT_DIRECTORY = 16,
> ERROR_NOT_SAME_DEVICE = 17,
> ERROR_NO_MORE_FILES = 18,
> ERROR_WRITE_PROTECT = 19,
> ERROR_BAD_UNIT = 20,
> ERROR_NOT_READY = 21,
> ERROR_BAD_COMMAND = 22,
> ERROR_CRC = 23,
> ERROR_BAD_LENGTH = 24,
> ERROR_SEEK = 25,
> ERROR_NOT_DOS_DISK = 26,
> ERROR_SECTOR_NOT_FOUND = 27,
> ERROR_OUT_OF_PAPER = 28,
> ERROR_WRITE_FAULT = 29,
> ERROR_READ_FAULT = 30,
> ERROR_GEN_FAILURE = 31,
> ERROR_SHARING_VIOLATION = 32,
> ERROR_LOCK_VIOLATION = 33,
> ERROR_WRONG_DISK = 34,
> ERROR_SHARING_BUFFER_EXCEEDED = 36,
> ERROR_HANDLE_EOF = 38,
> ERROR_HANDLE_DISK_FULL = 39,
> ERROR_NOT_SUPPORTED = 50,
> ERROR_REM_NOT_LIST = 51,
> ERROR_DUP_NAME = 52,
> ERROR_BAD_NETPATH = 53,
> ERROR_NETWORK_BUSY = 54,
> ERROR_DEV_NOT_EXIST = 55,
> ERROR_TOO_MANY_CMDS = 56,
> ERROR_ADAP_HDW_ERR = 57,
> ERROR_BAD_NET_RESP = 58,
> ERROR_UNEXP_NET_ERR = 59,
> ERROR_BAD_REM_ADAP = 60,
> ERROR_PRINTQ_FULL = 61,
> ERROR_NO_SPOOL_SPACE = 62,
> ERROR_PRINT_CANCELLED = 63,
> ERROR_NETNAME_DELETED = 64,
> ERROR_NETWORK_ACCESS_DENIED = 65,
> ERROR_BAD_DEV_TYPE = 66,
> ERROR_BAD_NET_NAME = 67,
> ERROR_TOO_MANY_NAMES = 68,
> ERROR_TOO_MANY_SESS = 69,
> ERROR_SHARING_PAUSED = 70,
> ERROR_REQ_NOT_ACCEP = 71,
> ERROR_REDIR_PAUSED = 72,
> ERROR_FILE_EXISTS = 80,
> ERROR_CANNOT_MAKE = 82,
> ERROR_FAIL_I24 = 83,
> ERROR_OUT_OF_STRUCTURES = 84,
> ERROR_ALREADY_ASSIGNED = 85,
> ERROR_INVALID_PASSWORD = 86,
> ERROR_INVALID_PARAMETER = 87,
> ERROR_NET_WRITE_FAULT = 88,
> ERROR_NO_PROC_SLOTS = 89,
> ERROR_TOO_MANY_SEMAPHORES = 100,
> ERROR_EXCL_SEM_ALREADY_OWNED = 101,
> ERROR_SEM_IS_SET = 102,
> ERROR_TOO_MANY_SEM_REQUESTS = 103,
> ERROR_INVALID_AT_INTERRUPT_TIME = 104,
> ERROR_SEM_OWNER_DIED = 105,
> ERROR_SEM_USER_LIMIT = 106,
> ERROR_DISK_CHANGE = 107,
> ERROR_DRIVE_LOCKED = 108,
> ERROR_BROKEN_PIPE = 109,
> ERROR_OPEN_FAILED = 110,
> ERROR_BUFFER_OVERFLOW = 111,
> ERROR_DISK_FULL = 112,
> ERROR_NO_MORE_SEARCH_HANDLES = 113,
> ERROR_INVALID_TARGET_HANDLE = 114,
> ERROR_INVALID_CATEGORY = 117,
> ERROR_INVALID_VERIFY_SWITCH = 118,
> ERROR_BAD_DRIVER_LEVEL = 119,
> ERROR_CALL_NOT_IMPLEMENTED = 120,
> ERROR_SEM_TIMEOUT = 121,
> ERROR_INSUFFICIENT_BUFFER = 122,
> ERROR_INVALID_NAME = 123,
> ERROR_INVALID_LEVEL = 124,
> ERROR_NO_VOLUME_LABEL = 125,
> ERROR_MOD_NOT_FOUND = 126,
> ERROR_PROC_NOT_FOUND = 127,
> ERROR_WAIT_NO_CHILDREN = 128,
> ERROR_CHILD_NOT_COMPLETE = 129,
> ERROR_DIRECT_ACCESS_HANDLE = 130,
> ERROR_NEGATIVE_SEEK = 131,
> ERROR_SEEK_ON_DEVICE = 132,
> ERROR_IS_JOIN_TARGET = 133,
> ERROR_IS_JOINED = 134,
> ERROR_IS_SUBSTED = 135,
> ERROR_NOT_JOINED = 136,
> ERROR_NOT_SUBSTED = 137,
> ERROR_JOIN_TO_JOIN = 138,
> ERROR_SUBST_TO_SUBST = 139,
> ERROR_JOIN_TO_SUBST = 140,
> ERROR_SUBST_TO_JOIN = 141,
> ERROR_BUSY_DRIVE = 142,
> ERROR_SAME_DRIVE = 143,
> ERROR_DIR_NOT_ROOT = 144,
> ERROR_DIR_NOT_EMPTY = 145,
> ERROR_IS_SUBST_PATH = 146,
> ERROR_IS_JOIN_PATH = 147,
> ERROR_PATH_BUSY = 148,
> ERROR_IS_SUBST_TARGET = 149,
> ERROR_SYSTEM_TRACE = 150,
> ERROR_INVALID_EVENT_COUNT = 151,
> ERROR_TOO_MANY_MUXWAITERS = 152,
> ERROR_INVALID_LIST_FORMAT = 153,
> ERROR_LABEL_TOO_LONG = 154,
> ERROR_TOO_MANY_TCBS = 155,
> ERROR_SIGNAL_REFUSED = 156,
> ERROR_DISCARDED = 157,
> ERROR_NOT_LOCKED = 158,
> ERROR_BAD_THREADID_ADDR = 159,
> ERROR_BAD_ARGUMENTS = 160,
> ERROR_BAD_PATHNAME = 161,
> ERROR_SIGNAL_PENDING = 162,
> ERROR_MAX_THRDS_REACHED = 164,
> ERROR_LOCK_FAILED = 167,
> ERROR_BUSY = 170,
> ERROR_CANCEL_VIOLATION = 173,
> ERROR_ATOMIC_LOCKS_NOT_SUPPORTED = 174,
> ERROR_INVALID_SEGMENT_NUMBER = 180,
> ERROR_INVALID_ORDINAL = 182,
> ERROR_ALREADY_EXISTS = 183,
> ERROR_INVALID_FLAG_NUMBER = 186,
> ERROR_SEM_NOT_FOUND = 187,
> ERROR_INVALID_STARTING_CODESEG = 188,
> ERROR_INVALID_STACKSEG = 189,
> ERROR_INVALID_MODULETYPE = 190,
> ERROR_INVALID_EXE_SIGNATURE = 191,
> ERROR_EXE_MARKED_INVALID = 192,
> ERROR_BAD_EXE_FORMAT = 193,
> ERROR_ITERATED_DATA_EXCEEDS_64k = 194,
> ERROR_INVALID_MINALLOCSIZE = 195,
> ERROR_DYNLINK_FROM_INVALID_RING = 196,
> ERROR_IOPL_NOT_ENABLED = 197,
> ERROR_INVALID_SEGDPL = 198,
> ERROR_AUTODATASEG_EXCEEDS_64k = 199,
> ERROR_RING2SEG_MUST_BE_MOVABLE = 200,
> ERROR_RELOC_CHAIN_XEEDS_SEGLIM = 201,
> ERROR_INFLOOP_IN_RELOC_CHAIN = 202,
> ERROR_ENVVAR_NOT_FOUND = 203,
> ERROR_NO_SIGNAL_SENT = 205,
> ERROR_FILENAME_EXCED_RANGE = 206,
> ERROR_RING2_STACK_IN_USE = 207,
> ERROR_META_EXPANSION_TOO_LONG = 208,
> ERROR_INVALID_SIGNAL_NUMBER = 209,
> ERROR_THREAD_1_INACTIVE = 210,
> ERROR_LOCKED = 212,
> ERROR_TOO_MANY_MODULES = 214,
> ERROR_NESTING_NOT_ALLOWED = 215,
> ERROR_EXE_MACHINE_TYPE_MISMATCH = 216,
> ERROR_BAD_PIPE = 230,
> ERROR_PIPE_BUSY = 231,
> ERROR_NO_DATA = 232,
> ERROR_PIPE_NOT_CONNECTED = 233,
> ERROR_MORE_DATA = 234,
> ERROR_VC_DISCONNECTED = 240,
> ERROR_INVALID_EA_NAME = 254,
> ERROR_EA_LIST_INCONSISTENT = 255,
> WAIT_TIMEOUT = 258,
> ERROR_NO_MORE_ITEMS = 259,
> ERROR_CANNOT_COPY = 266,
> ERROR_DIRECTORY = 267,
> ERROR_EAS_DIDNT_FIT = 275,
> ERROR_EA_FILE_CORRUPT = 276,
> ERROR_EA_TABLE_FULL = 277,
> ERROR_INVALID_EA_HANDLE = 278,
> ERROR_EAS_NOT_SUPPORTED = 282,
> ERROR_NOT_OWNER = 288,
> ERROR_TOO_MANY_POSTS = 298,
> ERROR_PARTIAL_COPY = 299,
> ERROR_OPLOCK_NOT_GRANTED = 300,
> ERROR_INVALID_OPLOCK_PROTOCOL = 301,
> ERROR_DISK_TOO_FRAGMENTED = 302,
> ERROR_DELETE_PENDING = 303,
> ERROR_MR_MID_NOT_FOUND = 317,
> ERROR_INVALID_ADDRESS = 487,
> ERROR_ARITHMETIC_OVERFLOW = 534,
> ERROR_PIPE_CONNECTED = 535,
> ERROR_PIPE_LISTENING = 536,
> ERROR_EA_ACCESS_DENIED = 994,
> ERROR_OPERATION_ABORTED = 995,
> ERROR_IO_INCOMPLETE = 996,
> ERROR_IO_PENDING = 997,
> ERROR_NOACCESS = 998,
> ERROR_SWAPERROR = 999,
> ERROR_STACK_OVERFLOW = 1001,
> ERROR_INVALID_MESSAGE = 1002,
> ERROR_CAN_NOT_COMPLETE = 1003,
> ERROR_INVALID_FLAGS = 1004,
> ERROR_UNRECOGNIZED_VOLUME = 1005,
> ERROR_FILE_INVALID = 1006,
> ERROR_FULLSCREEN_MODE = 1007,
> ERROR_NO_TOKEN = 1008,
> ERROR_BADDB = 1009,
> ERROR_BADKEY = 1010,
> ERROR_CANTOPEN = 1011,
> ERROR_CANTREAD = 1012,
> ERROR_CANTWRITE = 1013,
> ERROR_REGISTRY_RECOVERED = 1014,
> ERROR_REGISTRY_CORRUPT = 1015,
> ERROR_REGISTRY_IO_FAILED = 1016,
> ERROR_NOT_REGISTRY_FILE = 1017,
> ERROR_KEY_DELETED = 1018,
> ERROR_NO_LOG_SPACE = 1019,
> ERROR_KEY_HAS_CHILDREN = 1020,
> ERROR_CHILD_MUST_BE_VOLATILE = 1021,
> ERROR_NOTIFY_ENUM_DIR = 1022,
> ERROR_DEPENDENT_SERVICES_RUNNING = 1051,
> ERROR_INVALID_SERVICE_CONTROL = 1052,
> ERROR_SERVICE_REQUEST_TIMEOUT = 1053,
> ERROR_SERVICE_NO_THREAD = 1054,
> ERROR_SERVICE_DATABASE_LOCKED = 1055,
> ERROR_SERVICE_ALREADY_RUNNING = 1056,
> ERROR_INVALID_SERVICE_ACCOUNT = 1057,
> ERROR_SERVICE_DISABLED = 1058,
> ERROR_CIRCULAR_DEPENDENCY = 1059,
> ERROR_SERVICE_DOES_NOT_EXIST = 1060,
> ERROR_SERVICE_CANNOT_ACCEPT_CTRL = 1061,
> ERROR_SERVICE_NOT_ACTIVE = 1062,
> ERROR_FAILED_SERVICE_CONTROLLER_CONNECT = 1063,
> ERROR_EXCEPTION_IN_SERVICE = 1064,
> ERROR_DATABASE_DOES_NOT_EXIST = 1065,
> ERROR_SERVICE_SPECIFIC_ERROR = 1066,
> ERROR_PROCESS_ABORTED = 1067,
> ERROR_SERVICE_DEPENDENCY_FAIL = 1068,
> ERROR_SERVICE_LOGON_FAILED = 1069,
> ERROR_SERVICE_START_HANG = 1070,
> ERROR_INVALID_SERVICE_LOCK = 1071,
> ERROR_SERVICE_MARKED_FOR_DELETE = 1072,
> ERROR_SERVICE_EXISTS = 1073,
> ERROR_ALREADY_RUNNING_LKG = 1074,
> ERROR_SERVICE_DEPENDENCY_DELETED = 1075,
> ERROR_BOOT_ALREADY_ACCEPTED = 1076,
> ERROR_SERVICE_NEVER_STARTED = 1077,
> ERROR_DUPLICATE_SERVICE_NAME = 1078,
> ERROR_DIFFERENT_SERVICE_ACCOUNT = 1079,
> ERROR_CANNOT_DETECT_DRIVER_FAILURE = 1080,
> ERROR_CANNOT_DETECT_PROCESS_ABORT = 1081,
> ERROR_NO_RECOVERY_PROGRAM = 1082,
> ERROR_SERVICE_NOT_IN_EXE = 1083,
> ERROR_NOT_SAFEBOOT_SERVICE = 1084,
> ERROR_END_OF_MEDIA = 1100,
> ERROR_FILEMARK_DETECTED = 1101,
> ERROR_BEGINNING_OF_MEDIA = 1102,
> ERROR_SETMARK_DETECTED = 1103,
> ERROR_NO_DATA_DETECTED = 1104,
> ERROR_PARTITION_FAILURE = 1105,
> ERROR_INVALID_BLOCK_LENGTH = 1106,
> ERROR_DEVICE_NOT_PARTITIONED = 1107,
> ERROR_UNABLE_TO_LOCK_MEDIA = 1108,
> ERROR_UNABLE_TO_UNLOAD_MEDIA = 1109,
> ERROR_MEDIA_CHANGED = 1110,
> ERROR_BUS_RESET = 1111,
> ERROR_NO_MEDIA_IN_DRIVE = 1112,
> ERROR_NO_UNICODE_TRANSLATION = 1113,
> ERROR_DLL_INIT_FAILED = 1114,
> ERROR_SHUTDOWN_IN_PROGRESS = 1115,
> ERROR_NO_SHUTDOWN_IN_PROGRESS = 1116,
> ERROR_IO_DEVICE = 1117,
> ERROR_SERIAL_NO_DEVICE = 1118,
> ERROR_IRQ_BUSY = 1119,
> ERROR_MORE_WRITES = 1120,
> ERROR_COUNTER_TIMEOUT = 1121,
> ERROR_FLOPPY_ID_MARK_NOT_FOUND = 1122,
> ERROR_FLOPPY_WRONG_CYLINDER = 1123,
> ERROR_FLOPPY_UNKNOWN_ERROR = 1124,
> ERROR_FLOPPY_BAD_REGISTERS = 1125,
> ERROR_DISK_RECALIBRATE_FAILED = 1126,
> ERROR_DISK_OPERATION_FAILED = 1127,
> ERROR_DISK_RESET_FAILED = 1128,
> ERROR_EOM_OVERFLOW = 1129,
> ERROR_NOT_ENOUGH_SERVER_MEMORY = 1130,
> ERROR_POSSIBLE_DEADLOCK = 1131,
> ERROR_MAPPED_ALIGNMENT = 1132,
> ERROR_SET_POWER_STATE_VETOED = 1140,
> ERROR_SET_POWER_STATE_FAILED = 1141,
> ERROR_TOO_MANY_LINKS = 1142,
> ERROR_OLD_WIN_VERSION = 1150,
> ERROR_APP_WRONG_OS = 1151,
> ERROR_SINGLE_INSTANCE_APP = 1152,
> ERROR_RMODE_APP = 1153,
> ERROR_INVALID_DLL = 1154,
> ERROR_NO_ASSOCIATION = 1155,
> ERROR_DDE_FAIL = 1156,
> ERROR_DLL_NOT_FOUND = 1157,
> ERROR_NO_MORE_USER_HANDLES = 1158,
> ERROR_MESSAGE_SYNC_ONLY = 1159,
> ERROR_SOURCE_ELEMENT_EMPTY = 1160,
> ERROR_DESTINATION_ELEMENT_FULL = 1161,
> ERROR_ILLEGAL_ELEMENT_ADDRESS = 1162,
> ERROR_MAGAZINE_NOT_PRESENT = 1163,
> ERROR_DEVICE_REINITIALIZATION_NEEDED = 1164,
> ERROR_DEVICE_REQUIRES_CLEANING = 1165,
> ERROR_DEVICE_DOOR_OPEN = 1166,
> ERROR_DEVICE_NOT_CONNECTED = 1167,
> ERROR_NOT_FOUND = 1168,
> ERROR_NO_MATCH = 1169,
> ERROR_SET_NOT_FOUND = 1170,
> ERROR_POINT_NOT_FOUND = 1171,
> ERROR_NO_TRACKING_SERVICE = 1172,
> ERROR_NO_VOLUME_ID = 1173,
> ERROR_UNABLE_TO_REMOVE_REPLACED = 1175,
> ERROR_UNABLE_TO_MOVE_REPLACEMENT = 1176,
> ERROR_UNABLE_TO_MOVE_REPLACEMENT_2 = 1177,
> ERROR_JOURNAL_DELETE_IN_PROGRESS = 1178,
> ERROR_JOURNAL_NOT_ACTIVE = 1179,
> ERROR_POTENTIAL_FILE_FOUND = 1180,
> ERROR_JOURNAL_ENTRY_DELETED = 1181,
> ERROR_BAD_DEVICE = 1200,
> ERROR_CONNECTION_UNAVAIL = 1201,
> ERROR_DEVICE_ALREADY_REMEMBERED = 1202,
> ERROR_NO_NET_OR_BAD_PATH = 1203,
> ERROR_BAD_PROVIDER = 1204,
> ERROR_CANNOT_OPEN_PROFILE = 1205,
> ERROR_BAD_PROFILE = 1206,
> ERROR_NOT_CONTAINER = 1207,
> ERROR_EXTENDED_ERROR = 1208,
> ERROR_INVALID_GROUPNAME = 1209,
> ERROR_INVALID_COMPUTERNAME = 1210,
> ERROR_INVALID_EVENTNAME = 1211,
> ERROR_INVALID_DOMAINNAME = 1212,
> ERROR_INVALID_SERVICENAME = 1213,
> ERROR_INVALID_NETNAME = 1214,
> ERROR_INVALID_SHARENAME = 1215,
> ERROR_INVALID_PASSWORDNAME = 1216,
> ERROR_INVALID_MESSAGENAME = 1217,
> ERROR_INVALID_MESSAGEDEST = 1218,
> ERROR_SESSION_CREDENTIAL_CONFLICT = 1219,
> ERROR_REMOTE_SESSION_LIMIT_EXCEEDED = 1220,
> ERROR_DUP_DOMAINNAME = 1221,
> ERROR_NO_NETWORK = 1222,
> ERROR_CANCELLED = 1223,
> ERROR_USER_MAPPED_FILE = 1224,
> ERROR_CONNECTION_REFUSED = 1225,
> ERROR_GRACEFUL_DISCONNECT = 1226,
> ERROR_ADDRESS_ALREADY_ASSOCIATED = 1227,
> ERROR_ADDRESS_NOT_ASSOCIATED = 1228,
> ERROR_CONNECTION_INVALID = 1229,
> ERROR_CONNECTION_ACTIVE = 1230,
> ERROR_NETWORK_UNREACHABLE = 1231,
> ERROR_HOST_UNREACHABLE = 1232,
> ERROR_PROTOCOL_UNREACHABLE = 1233,
> ERROR_PORT_UNREACHABLE = 1234,
> ERROR_REQUEST_ABORTED = 1235,
> ERROR_CONNECTION_ABORTED = 1236,
> ERROR_RETRY = 1237,
> ERROR_CONNECTION_COUNT_LIMIT = 1238,
> ERROR_LOGIN_TIME_RESTRICTION = 1239,
> ERROR_LOGIN_WKSTA_RESTRICTION = 1240,
> ERROR_INCORRECT_ADDRESS = 1241,
> ERROR_ALREADY_REGISTERED = 1242,
> ERROR_SERVICE_NOT_FOUND = 1243,
> ERROR_NOT_AUTHENTICATED = 1244,
> ERROR_NOT_LOGGED_ON = 1245,
> ERROR_CONTINUE = 1246,
> ERROR_ALREADY_INITIALIZED = 1247,
> ERROR_NO_MORE_DEVICES = 1248,
> ERROR_NO_SUCH_SITE = 1249,
> ERROR_DOMAIN_CONTROLLER_EXISTS = 1250,
> ERROR_ONLY_IF_CONNECTED = 1251,
> ERROR_OVERRIDE_NOCHANGES = 1252,
> ERROR_BAD_USER_PROFILE = 1253,
> ERROR_NOT_SUPPORTED_ON_SBS = 1254,
> ERROR_SERVER_SHUTDOWN_IN_PROGRESS = 1255,
> ERROR_HOST_DOWN = 1256,
> ERROR_NON_ACCOUNT_SID = 1257,
> ERROR_NON_DOMAIN_SID = 1258,
> ERROR_APPHELP_BLOCK = 1259,
> ERROR_ACCESS_DISABLED_BY_POLICY = 1260,
> ERROR_REG_NAT_CONSUMPTION = 1261,
> ERROR_CSCSHARE_OFFLINE = 1262,
> ERROR_PKINIT_FAILURE = 1263,
> ERROR_SMARTCARD_SUBSYSTEM_FAILURE = 1264,
> ERROR_DOWNGRADE_DETECTED = 1265,
> SEC_E_SMARTCARD_CERT_REVOKED = 1266,
> SEC_E_ISSUING_CA_UNTRUSTED = 1267,
> SEC_E_REVOCATION_OFFLINE_C = 1268,
> SEC_E_PKINIT_CLIENT_FAILUR = 1269,
> SEC_E_SMARTCARD_CERT_EXPIRED = 1270,
> ERROR_MACHINE_LOCKED = 1271,
> ERROR_CALLBACK_SUPPLIED_INVALID_DATA = 1273,
> ERROR_SYNC_FOREGROUND_REFRESH_REQUIRED = 1274,
> ERROR_DRIVER_BLOCKED = 1275,
> ERROR_INVALID_IMPORT_OF_NON_DLL = 1276,
> ERROR_NOT_ALL_ASSIGNED = 1300,
> ERROR_SOME_NOT_MAPPED = 1301,
> ERROR_NO_QUOTAS_FOR_ACCOUNT = 1302,
> ERROR_LOCAL_USER_SESSION_KEY = 1303,
> ERROR_NULL_LM_PASSWORD = 1304,
> ERROR_UNKNOWN_REVISION = 1305,
> ERROR_REVISION_MISMATCH = 1306,
> ERROR_INVALID_OWNER = 1307,
> ERROR_INVALID_PRIMARY_GROUP = 1308,
> ERROR_NO_IMPERSONATION_TOKEN = 1309,
> ERROR_CANT_DISABLE_MANDATORY = 1310,
> ERROR_NO_LOGON_SERVERS = 1311,
> ERROR_NO_SUCH_LOGON_SESSION = 1312,
> ERROR_NO_SUCH_PRIVILEGE = 1313,
> ERROR_PRIVILEGE_NOT_HELD = 1314,
> ERROR_INVALID_ACCOUNT_NAME = 1315,
> ERROR_USER_EXISTS = 1316,
> ERROR_NO_SUCH_USER = 1317,
> ERROR_GROUP_EXISTS = 1318,
> ERROR_NO_SUCH_GROUP = 1319,
> ERROR_MEMBER_IN_GROUP = 1320,
> ERROR_MEMBER_NOT_IN_GROUP = 1321,
> ERROR_LAST_ADMIN = 1322,
> ERROR_WRONG_PASSWORD = 1323,
> ERROR_ILL_FORMED_PASSWORD = 1324,
> ERROR_PASSWORD_RESTRICTION = 1325,
> ERROR_LOGON_FAILURE = 1326,
> ERROR_ACCOUNT_RESTRICTION = 1327,
> ERROR_INVALID_LOGON_HOURS = 1328,
> ERROR_INVALID_WORKSTATION = 1329,
> ERROR_PASSWORD_EXPIRED = 1330,
> ERROR_ACCOUNT_DISABLED = 1331,
> ERROR_NONE_MAPPED = 1332,
> ERROR_TOO_MANY_LUIDS_REQUESTED = 1333,
> ERROR_LUIDS_EXHAUSTED = 1334,
> ERROR_INVALID_SUB_AUTHORITY = 1335,
> ERROR_INVALID_ACL = 1336,
> ERROR_INVALID_SID = 1337,
> ERROR_INVALID_SECURITY_DESCR = 1338,
> ERROR_BAD_INHERITANCE_ACL = 1340,
> ERROR_SERVER_DISABLED = 1341,
> ERROR_SERVER_NOT_DISABLED = 1342,
> ERROR_INVALID_ID_AUTHORITY = 1343,
> ERROR_ALLOTTED_SPACE_EXCEEDED = 1344,
> ERROR_INVALID_GROUP_ATTRIBUTES = 1345,
> ERROR_BAD_IMPERSONATION_LEVEL = 1346,
> ERROR_CANT_OPEN_ANONYMOUS = 1347,
> ERROR_BAD_VALIDATION_CLASS = 1348,
> ERROR_BAD_TOKEN_TYPE = 1349,
> ERROR_NO_SECURITY_ON_OBJECT = 1350,
> ERROR_CANT_ACCESS_DOMAIN_INFO = 1351,
> ERROR_INVALID_SERVER_STATE = 1352,
> ERROR_INVALID_DOMAIN_STATE = 1353,
> ERROR_INVALID_DOMAIN_ROLE = 1354,
> ERROR_NO_SUCH_DOMAIN = 1355,
> ERROR_DOMAIN_EXISTS = 1356,
> ERROR_DOMAIN_LIMIT_EXCEEDED = 1357,
> ERROR_INTERNAL_DB_CORRUPTION = 1358,
> ERROR_INTERNAL_ERROR = 1359,
> ERROR_GENERIC_NOT_MAPPED = 1360,
> ERROR_BAD_DESCRIPTOR_FORMAT = 1361,
> ERROR_NOT_LOGON_PROCESS = 1362,
> ERROR_LOGON_SESSION_EXISTS = 1363,
> ERROR_NO_SUCH_PACKAGE = 1364,
> ERROR_BAD_LOGON_SESSION_STATE = 1365,
> ERROR_LOGON_SESSION_COLLISION = 1366,
> ERROR_INVALID_LOGON_TYPE = 1367,
> ERROR_CANNOT_IMPERSONATE = 1368,
> ERROR_RXACT_INVALID_STATE = 1369,
> ERROR_RXACT_COMMIT_FAILURE = 1370,
> ERROR_SPECIAL_ACCOUNT = 1371,
> ERROR_SPECIAL_GROUP = 1372,
> ERROR_SPECIAL_USER = 1373,
> ERROR_MEMBERS_PRIMARY_GROUP = 1374,
> ERROR_TOKEN_ALREADY_IN_USE = 1375,
> ERROR_NO_SUCH_ALIAS = 1376,
> ERROR_MEMBER_NOT_IN_ALIAS = 1377,
> ERROR_MEMBER_IN_ALIAS = 1378,
> ERROR_ALIAS_EXISTS = 1379,
> ERROR_LOGON_NOT_GRANTED = 1380,
> ERROR_TOO_MANY_SECRETS = 1381,
> ERROR_SECRET_TOO_LONG = 1382,
> ERROR_INTERNAL_DB_ERROR = 1383,
> ERROR_TOO_MANY_CONTEXT_IDS = 1384,
> ERROR_LOGON_TYPE_NOT_GRANTED = 1385,
> ERROR_NT_CROSS_ENCRYPTION_REQUIRED = 1386,
> ERROR_NO_SUCH_MEMBER = 1387,
> ERROR_INVALID_MEMBER = 1388,
> ERROR_TOO_MANY_SIDS = 1389,
> ERROR_LM_CROSS_ENCRYPTION_REQUIRED = 1390,
> ERROR_NO_INHERITANCE = 1391,
> ERROR_FILE_CORRUPT = 1392,
> ERROR_DISK_CORRUPT = 1393,
> ERROR_NO_USER_SESSION_KEY = 1394,
> ERROR_LICENSE_QUOTA_EXCEEDED = 1395,
> ERROR_WRONG_TARGET_NAME = 1396,
> ERROR_MUTUAL_AUTH_FAILED = 1397,
> ERROR_TIME_SKEW = 1398,
> ERROR_CURRENT_DOMAIN_NOT_ALLOWED = 1399,
> ERROR_INVALID_WINDOW_HANDLE = 1400,
> ERROR_INVALID_MENU_HANDLE = 1401,
> ERROR_INVALID_CURSOR_HANDLE = 1402,
> ERROR_INVALID_ACCEL_HANDLE = 1403,
> ERROR_INVALID_HOOK_HANDLE = 1404,
> ERROR_INVALID_DWP_HANDLE = 1405,
> ERROR_TLW_WITH_WSCHILD = 1406,
> ERROR_CANNOT_FIND_WND_CLASS = 1407,
> ERROR_WINDOW_OF_OTHER_THREAD = 1408,
> ERROR_HOTKEY_ALREADY_REGISTERED = 1409,
> ERROR_CLASS_ALREADY_EXISTS = 1410,
> ERROR_CLASS_DOES_NOT_EXIST = 1411,
> ERROR_CLASS_HAS_WINDOWS = 1412,
> ERROR_INVALID_INDEX = 1413,
> ERROR_INVALID_ICON_HANDLE = 1414,
> ERROR_PRIVATE_DIALOG_INDEX = 1415,
> ERROR_LISTBOX_ID_NOT_FOUND = 1416,
> ERROR_NO_WILDCARD_CHARACTERS = 1417,
> ERROR_CLIPBOARD_NOT_OPEN = 1418,
> ERROR_HOTKEY_NOT_REGISTERED = 1419,
> ERROR_WINDOW_NOT_DIALOG = 1420,
> ERROR_CONTROL_ID_NOT_FOUND = 1421,
> ERROR_INVALID_COMBOBOX_MESSAGE = 1422,
> ERROR_WINDOW_NOT_COMBOBOX = 1423,
> ERROR_INVALID_EDIT_HEIGHT = 1424,
> ERROR_DC_NOT_FOUND = 1425,
> ERROR_INVALID_HOOK_FILTER = 1426,
> ERROR_INVALID_FILTER_PROC = 1427,
> ERROR_HOOK_NEEDS_HMOD = 1428,
> ERROR_GLOBAL_ONLY_HOOK = 1429,
> ERROR_JOURNAL_HOOK_SET = 1430,
> ERROR_HOOK_NOT_INSTALLED = 1431,
> ERROR_INVALID_LB_MESSAGE = 1432,
> ERROR_SETCOUNT_ON_BAD_LB = 1433,
> ERROR_LB_WITHOUT_TABSTOPS = 1434,
> ERROR_DESTROY_OBJECT_OF_OTHER_THREAD = 1435,
> ERROR_CHILD_WINDOW_MENU = 1436,
> ERROR_NO_SYSTEM_MENU = 1437,
> ERROR_INVALID_MSGBOX_STYLE = 1438,
> ERROR_INVALID_SPI_VALUE = 1439,
> ERROR_SCREEN_ALREADY_LOCKED = 1440,
> ERROR_HWNDS_HAVE_DIFF_PARENT = 1441,
> ERROR_NOT_CHILD_WINDOW = 1442,
> ERROR_INVALID_GW_COMMAND = 1443,
> ERROR_INVALID_THREAD_ID = 1444,
> ERROR_NON_MDICHILD_WINDOW = 1445,
> ERROR_POPUP_ALREADY_ACTIVE = 1446,
> ERROR_NO_SCROLLBARS = 1447,
> ERROR_INVALID_SCROLLBAR_RANGE = 1448,
> ERROR_INVALID_SHOWWIN_COMMAND = 1449,
> ERROR_NO_SYSTEM_RESOURCES = 1450,
> ERROR_NONPAGED_SYSTEM_RESOURCES = 1451,
> ERROR_PAGED_SYSTEM_RESOURCES = 1452,
> ERROR_WORKING_SET_QUOTA = 1453,
> ERROR_PAGEFILE_QUOTA = 1454,
> ERROR_COMMITMENT_LIMIT = 1455,
> ERROR_MENU_ITEM_NOT_FOUND = 1456,
> ERROR_INVALID_KEYBOARD_HANDLE = 1457,
> ERROR_HOOK_TYPE_NOT_ALLOWED = 1458,
> ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION = 1459,
> ERROR_TIMEOUT = 1460,
> ERROR_INVALID_MONITOR_HANDLE = 1461,
> ERROR_EVENTLOG_FILE_CORRUPT = 1500,
> ERROR_EVENTLOG_CANT_START = 1501,
> ERROR_LOG_FILE_FULL = 1502,
> ERROR_EVENTLOG_FILE_CHANGED = 1503,
> ERROR_INSTALL_SERVICE_FAILURE = 1601,
> ERROR_INSTALL_USEREXIT = 1602,
> ERROR_INSTALL_FAILURE = 1603,
> ERROR_INSTALL_SUSPEND = 1604,
> ERROR_UNKNOWN_PRODUCT = 1605,
> ERROR_UNKNOWN_FEATURE = 1606,
> ERROR_UNKNOWN_COMPONENT = 1607,
> ERROR_UNKNOWN_PROPERTY = 1608,
> ERROR_INVALID_HANDLE_STATE = 1609,
> ERROR_BAD_CONFIGURATION = 1610,
> ERROR_INDEX_ABSENT = 1611,
> ERROR_INSTALL_SOURCE_ABSENT = 1612,
> ERROR_INSTALL_PACKAGE_VERSION = 1613,
> ERROR_PRODUCT_UNINSTALLED = 1614,
> ERROR_BAD_QUERY_SYNTAX = 1615,
> ERROR_INVALID_FIELD = 1616,
> ERROR_DEVICE_REMOVED = 1617,
> ERROR_INSTALL_ALREADY_RUNNING = 1618,
> ERROR_INSTALL_PACKAGE_OPEN_FAILED = 1619,
> ERROR_INSTALL_PACKAGE_INVALID = 1620,
> ERROR_INSTALL_UI_FAILURE = 1621,
> ERROR_INSTALL_LOG_FAILURE = 1622,
> ERROR_INSTALL_LANGUAGE_UNSUPPORTED = 1623,
> ERROR_INSTALL_TRANSFORM_FAILURE = 1624,
> ERROR_INSTALL_PACKAGE_REJECTED = 1625,
> ERROR_FUNCTION_NOT_CALLED = 1626,
> ERROR_FUNCTION_FAILED = 1627,
> ERROR_INVALID_TABLE = 1628,
> ERROR_DATATYPE_MISMATCH = 1629,
> ERROR_UNSUPPORTED_TYPE = 1630,
> ERROR_CREATE_FAILED = 1631,
> ERROR_INSTALL_TEMP_UNWRITABLE = 1632,
> ERROR_INSTALL_PLATFORM_UNSUPPORTED = 1633,
> ERROR_INSTALL_NOTUSED = 1634,
> ERROR_PATCH_PACKAGE_OPEN_FAILED = 1635,
> ERROR_PATCH_PACKAGE_INVALID = 1636,
> ERROR_PATCH_PACKAGE_UNSUPPORTED = 1637,
> ERROR_PRODUCT_VERSION = 1638,
> ERROR_INVALID_COMMAND_LINE = 1639,
> ERROR_INSTALL_REMOTE_DISALLOWED = 1640,
> ERROR_SUCCESS_REBOOT_INITIATED = 1641,
> ERROR_PATCH_TARGET_NOT_FOUND = 1642,
> ERROR_PATCH_PACKAGE_REJECTED = 1643,
> ERROR_INSTALL_TRANSFORM_REJECTED = 1644,
> RPC_S_INVALID_STRING_BINDING = 1700,
> RPC_S_WRONG_KIND_OF_BINDING = 1701,
> RPC_S_INVALID_BINDING = 1702,
> RPC_S_PROTSEQ_NOT_SUPPORTED = 1703,
> RPC_S_INVALID_RPC_PROTSEQ = 1704,
> RPC_S_INVALID_STRING_UUID = 1705,
> RPC_S_INVALID_ENDPOINT_FORMAT = 1706,
> RPC_S_INVALID_NET_ADDR = 1707,
> RPC_S_NO_ENDPOINT_FOUND = 1708,
> RPC_S_INVALID_TIMEOUT = 1709,
> RPC_S_OBJECT_NOT_FOUND = 1710,
> RPC_S_ALREADY_REGISTERED = 1711,
> RPC_S_TYPE_ALREADY_REGISTERED = 1712,
> RPC_S_ALREADY_LISTENING = 1713,
> RPC_S_NO_PROTSEQS_REGISTERED = 1714,
> RPC_S_NOT_LISTENING = 1715,
> RPC_S_UNKNOWN_MGR_TYPE = 1716,
> RPC_S_UNKNOWN_IF = 1717,
> RPC_S_NO_BINDINGS = 1718,
> RPC_S_NO_PROTSEQS = 1719,
> RPC_S_CANT_CREATE_ENDPOINT = 1720,
> RPC_S_OUT_OF_RESOURCES = 1721,
> RPC_S_SERVER_UNAVAILABLE = 1722,
> RPC_S_SERVER_TOO_BUSY = 1723,
> RPC_S_INVALID_NETWORK_OPTIONS = 1724,
> RPC_S_NO_CALL_ACTIVE = 1725,
> RPC_S_CALL_FAILED = 1726,
> RPC_S_CALL_FAILED_DNE = 1727,
> RPC_S_PROTOCOL_ERROR = 1728,
> RPC_S_UNSUPPORTED_TRANS_SYN = 1730,
> RPC_S_UNSUPPORTED_TYPE = 1732,
> RPC_S_INVALID_TAG = 1733,
> RPC_S_INVALID_BOUND = 1734,
> RPC_S_NO_ENTRY_NAME = 1735,
> RPC_S_INVALID_NAME_SYNTAX = 1736,
> RPC_S_UNSUPPORTED_NAME_SYNTAX = 1737,
> RPC_S_UUID_NO_ADDRESS = 1739,
> RPC_S_DUPLICATE_ENDPOINT = 1740,
> RPC_S_UNKNOWN_AUTHN_TYPE = 1741,
> RPC_S_MAX_CALLS_TOO_SMALL = 1742,
> RPC_S_STRING_TOO_LONG = 1743,
> RPC_S_PROTSEQ_NOT_FOUND = 1744,
> RPC_S_PROCNUM_OUT_OF_RANGE = 1745,
> RPC_S_BINDING_HAS_NO_AUTH = 1746,
> RPC_S_UNKNOWN_AUTHN_SERVICE = 1747,
> RPC_S_UNKNOWN_AUTHN_LEVEL = 1748,
> RPC_S_INVALID_AUTH_IDENTITY = 1749,
> RPC_S_UNKNOWN_AUTHZ_SERVICE = 1750,
> EPT_S_INVALID_ENTRY = 1751,
> EPT_S_CANT_PERFORM_OP = 1752,
> EPT_S_NOT_REGISTERED = 1753,
> RPC_S_NOTHING_TO_EXPORT = 1754,
> RPC_S_INCOMPLETE_NAME = 1755,
> RPC_S_INVALID_VERS_OPTION = 1756,
> RPC_S_NO_MORE_MEMBERS = 1757,
> RPC_S_NOT_ALL_OBJS_UNEXPORTED = 1758,
> RPC_S_INTERFACE_NOT_FOUND = 1759,
> RPC_S_ENTRY_ALREADY_EXISTS = 1760,
> RPC_S_ENTRY_NOT_FOUND = 1761,
> RPC_S_NAME_SERVICE_UNAVAILABLE = 1762,
> RPC_S_INVALID_NAF_ID = 1763,
> RPC_S_CANNOT_SUPPORT = 1764,
> RPC_S_NO_CONTEXT_AVAILABLE = 1765,
> RPC_S_INTERNAL_ERROR = 1766,
> RPC_S_ZERO_DIVIDE = 1767,
> RPC_S_ADDRESS_ERROR = 1768,
> RPC_S_FP_DIV_ZERO = 1769,
> RPC_S_FP_UNDERFLOW = 1770,
> RPC_S_FP_OVERFLOW = 1771,
> RPC_X_NO_MORE_ENTRIES = 1772,
> RPC_X_SS_CHAR_TRANS_OPEN_FAIL = 1773,
> RPC_X_SS_CHAR_TRANS_SHORT_FILE = 1774,
> RPC_X_SS_IN_NULL_CONTEXT = 1775,
> RPC_X_SS_CONTEXT_DAMAGED = 1777,
> RPC_X_SS_HANDLES_MISMATCH = 1778,
> RPC_X_SS_CANNOT_GET_CALL_HANDLE = 1779,
> RPC_X_NULL_REF_POINTER = 1780,
> RPC_X_ENUM_VALUE_OUT_OF_RANGE = 1781,
> RPC_X_BYTE_COUNT_TOO_SMALL = 1782,
> RPC_X_BAD_STUB_DATA = 1783,
> ERROR_INVALID_USER_BUFFER = 1784,
> ERROR_UNRECOGNIZED_MEDIA = 1785,
> ERROR_NO_TRUST_LSA_SECRET = 1786,
> ERROR_NO_TRUST_SAM_ACCOUNT = 1787,
> ERROR_TRUSTED_DOMAIN_FAILURE = 1788,
> ERROR_TRUSTED_RELATIONSHIP_FAILURE = 1789,
> ERROR_TRUST_FAILURE = 1790,
> RPC_S_CALL_IN_PROGRESS = 1791,
> ERROR_NETLOGON_NOT_STARTED = 1792,
> ERROR_ACCOUNT_EXPIRED = 1793,
> ERROR_REDIRECTOR_HAS_OPEN_HANDLES = 1794,
> ERROR_PRINTER_DRIVER_ALREADY_INSTALLED = 1795,
> ERROR_UNKNOWN_PORT = 1796,
> ERROR_UNKNOWN_PRINTER_DRIVER = 1797,
> ERROR_UNKNOWN_PRINTPROCESSOR = 1798,
> ERROR_INVALID_SEPARATOR_FILE = 1799,
> ERROR_INVALID_PRIORITY = 1800,
> ERROR_INVALID_PRINTER_NAME = 1801,
> ERROR_PRINTER_ALREADY_EXISTS = 1802,
> ERROR_INVALID_PRINTER_COMMAND = 1803,
> ERROR_INVALID_DATATYPE = 1804,
> ERROR_INVALID_ENVIRONMENT = 1805,
> RPC_S_NO_MORE_BINDINGS = 1806,
> ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT = 1807,
> ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT = 1808,
> ERROR_NOLOGON_SERVER_TRUST_ACCOUNT = 1809,
> ERROR_DOMAIN_TRUST_INCONSISTENT = 1810,
> ERROR_SERVER_HAS_OPEN_HANDLES = 1811,
> ERROR_RESOURCE_DATA_NOT_FOUND = 1812,
> ERROR_RESOURCE_TYPE_NOT_FOUND = 1813,
> ERROR_RESOURCE_NAME_NOT_FOUND = 1814,
> ERROR_RESOURCE_LANG_NOT_FOUND = 1815,
> ERROR_NOT_ENOUGH_QUOTA = 1816,
> RPC_S_NO_INTERFACES = 1817,
> RPC_S_CALL_CANCELLED = 1818,
> RPC_S_BINDING_INCOMPLETE = 1819,
> RPC_S_COMM_FAILURE = 1820,
> RPC_S_UNSUPPORTED_AUTHN_LEVEL = 1821,
> RPC_S_NO_PRINC_NAME = 1822,
> RPC_S_NOT_RPC_ERROR = 1823,
> RPC_S_UUID_LOCAL_ONLY = 1824,
> RPC_S_SEC_PKG_ERROR = 1825,
> RPC_S_NOT_CANCELLED = 1826,
> RPC_X_INVALID_ES_ACTION = 1827,
> RPC_X_WRONG_ES_VERSION = 1828,
> RPC_X_WRONG_STUB_VERSION = 1829,
> RPC_X_INVALID_PIPE_OBJECT = 1830,
> RPC_X_WRONG_PIPE_ORDER = 1831,
> RPC_X_WRONG_PIPE_VERSION = 1832,
> RPC_S_GROUP_MEMBER_NOT_FOUND = 1898,
> EPT_S_CANT_CREATE = 1899,
> RPC_S_INVALID_OBJECT = 1900,
> ERROR_INVALID_TIME = 1901,
> ERROR_INVALID_FORM_NAME = 1902,
> ERROR_INVALID_FORM_SIZE = 1903,
> ERROR_ALREADY_WAITING = 1904,
> ERROR_PRINTER_DELETED = 1905,
> ERROR_INVALID_PRINTER_STATE = 1906,
> ERROR_PASSWORD_MUST_CHANGE = 1907,
> ERROR_DOMAIN_CONTROLLER_NOT_FOUND = 1908,
> ERROR_ACCOUNT_LOCKED_OUT = 1909,
> OR_INVALID_OXID = 1910,
> OR_INVALID_OID = 1911,
> OR_INVALID_SET = 1912,
> RPC_S_SEND_INCOMPLETE = 1913,
> RPC_S_INVALID_ASYNC_HANDLE = 1914,
> RPC_S_INVALID_ASYNC_CALL = 1915,
> RPC_X_PIPE_CLOSED = 1916,
> RPC_X_PIPE_DISCIPLINE_ERROR = 1917,
> RPC_X_PIPE_EMPTY = 1918,
> ERROR_NO_SITENAME = 1919,
> ERROR_CANT_ACCESS_FILE = 1920,
> ERROR_CANT_RESOLVE_FILENAME = 1921,
> RPC_S_ENTRY_TYPE_MISMATCH = 1922,
> RPC_S_NOT_ALL_OBJS_EXPORTED = 1923,
> RPC_S_INTERFACE_NOT_EXPORTED = 1924,
> RPC_S_PROFILE_NOT_ADDED = 1925,
> RPC_S_PRF_ELT_NOT_ADDED = 1926,
> RPC_S_PRF_ELT_NOT_REMOVED = 1927,
> RPC_S_GRP_ELT_NOT_ADDED = 1928,
> RPC_S_GRP_ELT_NOT_REMOVED = 1929,
> ERROR_KM_DRIVER_BLOCKED = 1930,
> ERROR_CONTEXT_EXPIRED = 1931,
> ERROR_INVALID_PIXEL_FORMAT = 2000,
> ERROR_BAD_DRIVER = 2001,
> ERROR_INVALID_WINDOW_STYLE = 2002,
> ERROR_METAFILE_NOT_SUPPORTED = 2003,
> ERROR_TRANSFORM_NOT_SUPPORTED = 2004,
> ERROR_CLIPPING_NOT_SUPPORTED = 2005,
> ERROR_INVALID_CMM = 2010,
> ERROR_INVALID_PROFILE = 2011,
> ERROR_TAG_NOT_FOUND = 2012,
> ERROR_TAG_NOT_PRESENT = 2013,
> ERROR_DUPLICATE_TAG = 2014,
> ERROR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE = 2015,
> ERROR_PROFILE_NOT_FOUND = 2016,
> ERROR_INVALID_COLORSPACE = 2017,
> ERROR_ICM_NOT_ENABLED = 2018,
> ERROR_DELETING_ICM_XFORM = 2019,
> ERROR_INVALID_TRANSFORM = 2020,
> ERROR_COLORSPACE_MISMATCH = 2021,
> ERROR_INVALID_COLORINDEX = 2022,
> ERROR_CONNECTED_OTHER_PASSWORD = 2108,
> ERROR_CONNECTED_OTHER_PASSWORD_DEFAULT = 2109,
> ERROR_BAD_USERNAME = 2202,
> ERROR_NOT_CONNECTED = 2250,
> ERROR_OPEN_FILES = 2401,
> ERROR_ACTIVE_CONNECTIONS = 2402,
> ERROR_DEVICE_IN_USE = 2404,
> ERROR_UNKNOWN_PRINT_MONITOR = 3000,
> ERROR_PRINTER_DRIVER_IN_USE = 3001,
> ERROR_SPOOL_FILE_NOT_FOUND = 3002,
> ERROR_SPL_NO_STARTDOC = 3003,
> ERROR_SPL_NO_ADDJOB = 3004,
> ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED = 3005,
> ERROR_PRINT_MONITOR_ALREADY_INSTALLED = 3006,
> ERROR_INVALID_PRINT_MONITOR = 3007,
> ERROR_PRINT_MONITOR_IN_USE = 3008,
> ERROR_PRINTER_HAS_JOBS_QUEUED = 3009,
> ERROR_SUCCESS_REBOOT_REQUIRED = 3010,
> ERROR_SUCCESS_RESTART_REQUIRED = 3011,
> ERROR_PRINTER_NOT_FOUND = 3012,
> ERROR_PRINTER_DRIVER_WARNED = 3013,
> ERROR_PRINTER_DRIVER_BLOCKED = 3014,
> ERROR_WINS_INTERNAL = 4000,
> ERROR_CAN_NOT_DEL_LOCAL_WINS = 4001,
> ERROR_STATIC_INIT = 4002,
> ERROR_INC_BACKUP = 4003,
> ERROR_FULL_BACKUP = 4004,
> ERROR_REC_NON_EXISTENT = 4005,
> ERROR_RPL_NOT_ALLOWED = 4006,
> ERROR_DHCP_ADDRESS_CONFLICT = 4100,
> ERROR_WMI_GUID_NOT_FOUND = 4200,
> ERROR_WMI_INSTANCE_NOT_FOUND = 4201,
> ERROR_WMI_ITEMID_NOT_FOUND = 4202,
> ERROR_WMI_TRY_AGAIN = 4203,
> ERROR_WMI_DP_NOT_FOUND = 4204,
> ERROR_WMI_UNRESOLVED_INSTANCE_REF = 4205,
> ERROR_WMI_ALREADY_ENABLED = 4206,
> ERROR_WMI_GUID_DISCONNECTED = 4207,
> ERROR_WMI_SERVER_UNAVAILABLE = 4208,
> ERROR_WMI_DP_FAILED = 4209,
> ERROR_WMI_INVALID_MOF = 4210,
> ERROR_WMI_INVALID_REGINFO = 4211,
> ERROR_WMI_ALREADY_DISABLED = 4212,
> ERROR_WMI_READ_ONLY = 4213,
> ERROR_WMI_SET_FAILURE = 4214,
> ERROR_INVALID_MEDIA = 4300,
> ERROR_INVALID_LIBRARY = 4301,
> ERROR_INVALID_MEDIA_POOL = 4302,
> ERROR_DRIVE_MEDIA_MISMATCH = 4303,
> ERROR_MEDIA_OFFLINE = 4304,
> ERROR_LIBRARY_OFFLINE = 4305,
> ERROR_EMPTY = 4306,
> ERROR_NOT_EMPTY = 4307,
> ERROR_MEDIA_UNAVAILABLE = 4308,
> ERROR_RESOURCE_DISABLED = 4309,
> ERROR_INVALID_CLEANER = 4310,
> ERROR_UNABLE_TO_CLEAN = 4311,
> ERROR_OBJECT_NOT_FOUND = 4312,
> ERROR_DATABASE_FAILURE = 4313,
> ERROR_DATABASE_FULL = 4314,
> ERROR_MEDIA_INCOMPATIBLE = 4315,
> ERROR_RESOURCE_NOT_PRESENT = 4316,
> ERROR_INVALID_OPERATION = 4317,
> ERROR_MEDIA_NOT_AVAILABLE = 4318,
> ERROR_DEVICE_NOT_AVAILABLE = 4319,
> ERROR_REQUEST_REFUSED = 4320,
> ERROR_INVALID_DRIVE_OBJECT = 4321,
> ERROR_LIBRARY_FULL = 4322,
> ERROR_MEDIUM_NOT_ACCESSIBLE = 4323,
> ERROR_UNABLE_TO_LOAD_MEDIUM = 4324,
> ERROR_UNABLE_TO_INVENTORY_DRIVE = 4325,
> ERROR_UNABLE_TO_INVENTORY_SLOT = 4326,
> ERROR_UNABLE_TO_INVENTORY_TRANSPORT = 4327,
> ERROR_TRANSPORT_FULL = 4328,
> ERROR_CONTROLLING_IEPORT = 4329,
> ERROR_UNABLE_TO_EJECT_MOUNTED_MEDIA = 4330,
> ERROR_CLEANER_SLOT_SET = 4331,
> ERROR_CLEANER_SLOT_NOT_SET = 4332,
> ERROR_CLEANER_CARTRIDGE_SPENT = 4333,
> ERROR_UNEXPECTED_OMID = 4334,
> ERROR_CANT_DELETE_LAST_ITEM = 4335,
> ERROR_MESSAGE_EXCEEDS_MAX_SIZE = 4336,
> ERROR_VOLUME_CONTAINS_SYS_FILES = 4337,
> ERROR_INDIGENOUS_TYPE = 4338,
> ERROR_NO_SUPPORTING_DRIVES = 4339,
> ERROR_CLEANER_CARTRIDGE_INSTALLED = 4340,
> ERROR_FILE_OFFLINE = 4350,
> ERROR_REMOTE_STORAGE_NOT_ACTIVE = 4351,
> ERROR_REMOTE_STORAGE_MEDIA_ERROR = 4352,
> ERROR_NOT_A_REPARSE_POINT = 4390,
> ERROR_REPARSE_ATTRIBUTE_CONFLICT = 4391,
> ERROR_INVALID_REPARSE_DATA = 4392,
> ERROR_REPARSE_TAG_INVALID = 4393,
> ERROR_REPARSE_TAG_MISMATCH = 4394,
> ERROR_VOLUME_NOT_SIS_ENABLED = 4500,
> ERROR_DEPENDENT_RESOURCE_EXISTS = 5001,
> ERROR_DEPENDENCY_NOT_FOUND = 5002,
> ERROR_DEPENDENCY_ALREADY_EXISTS = 5003,
> ERROR_RESOURCE_NOT_ONLINE = 5004,
> ERROR_HOST_NODE_NOT_AVAILABLE = 5005,
> ERROR_RESOURCE_NOT_AVAILABLE = 5006,
> ERROR_RESOURCE_NOT_FOUND = 5007,
> ERROR_SHUTDOWN_CLUSTER = 5008,
> ERROR_CANT_EVICT_ACTIVE_NODE = 5009,
> ERROR_OBJECT_ALREADY_EXISTS = 5010,
> ERROR_OBJECT_IN_LIST = 5011,
> ERROR_GROUP_NOT_AVAILABLE = 5012,
> ERROR_GROUP_NOT_FOUND = 5013,
> ERROR_GROUP_NOT_ONLINE = 5014,
> ERROR_HOST_NODE_NOT_RESOURCE_OWNER = 5015,
> ERROR_HOST_NODE_NOT_GROUP_OWNER = 5016,
> ERROR_RESMON_CREATE_FAILED = 5017,
> ERROR_RESMON_ONLINE_FAILED = 5018,
> ERROR_RESOURCE_ONLINE = 5019,
> ERROR_QUORUM_RESOURCE = 5020,
> ERROR_NOT_QUORUM_CAPABLE = 5021,
> ERROR_CLUSTER_SHUTTING_DOWN = 5022,
> ERROR_INVALID_STATE = 5023,
> ERROR_RESOURCE_PROPERTIES_STORED = 5024,
> ERROR_NOT_QUORUM_CLASS = 5025,
> ERROR_CORE_RESOURCE = 5026,
> ERROR_QUORUM_RESOURCE_ONLINE_FAILED = 5027,
> ERROR_QUORUMLOG_OPEN_FAILED = 5028,
> ERROR_CLUSTERLOG_CORRUPT = 5029,
> ERROR_CLUSTERLOG_RECORD_EXCEEDS_MAXSIZE = 5030,
> ERROR_CLUSTERLOG_EXCEEDS_MAXSIZE = 5031,
> ERROR_CLUSTERLOG_CHKPOINT_NOT_FOUND = 5032,
> ERROR_CLUSTERLOG_NOT_ENOUGH_SPACE = 5033,
> ERROR_QUORUM_OWNER_ALIVE = 5034,
> ERROR_NETWORK_NOT_AVAILABLE = 5035,
> ERROR_NODE_NOT_AVAILABLE = 5036,
> ERROR_ALL_NODES_NOT_AVAILABLE = 5037,
> ERROR_RESOURCE_FAILED = 5038,
> ERROR_CLUSTER_INVALID_NODE = 5039,
> ERROR_CLUSTER_NODE_EXISTS = 5040,
> ERROR_CLUSTER_JOIN_IN_PROGRESS = 5041,
> ERROR_CLUSTER_NODE_NOT_FOUND = 5042,
> ERROR_CLUSTER_LOCAL_NODE_NOT_FOUND = 5043,
> ERROR_CLUSTER_NETWORK_EXISTS = 5044,
> ERROR_CLUSTER_NETWORK_NOT_FOUND = 5045,
> ERROR_CLUSTER_NETINTERFACE_EXISTS = 5046,
> ERROR_CLUSTER_NETINTERFACE_NOT_FOUND = 5047,
> ERROR_CLUSTER_INVALID_REQUEST = 5048,
> ERROR_CLUSTER_INVALID_NETWORK_PROVIDER = 5049,
> ERROR_CLUSTER_NODE_DOWN = 5050,
> ERROR_CLUSTER_NODE_UNREACHABLE = 5051,
> ERROR_CLUSTER_NODE_NOT_MEMBER = 5052,
> ERROR_CLUSTER_JOIN_NOT_IN_PROGRESS = 5053,
> ERROR_CLUSTER_INVALID_NETWORK = 5054,
> ERROR_CLUSTER_NODE_UP = 5056,
> ERROR_CLUSTER_IPADDR_IN_USE = 5057,
> ERROR_CLUSTER_NODE_NOT_PAUSED = 5058,
> ERROR_CLUSTER_NO_SECURITY_CONTEXT = 5059,
> ERROR_CLUSTER_NETWORK_NOT_INTERNAL = 5060,
> ERROR_CLUSTER_NODE_ALREADY_UP = 5061,
> ERROR_CLUSTER_NODE_ALREADY_DOWN = 5062,
> ERROR_CLUSTER_NETWORK_ALREADY_ONLINE = 5063,
> ERROR_CLUSTER_NETWORK_ALREADY_OFFLINE = 5064,
> ERROR_CLUSTER_NODE_ALREADY_MEMBER = 5065,
> ERROR_CLUSTER_LAST_INTERNAL_NETWORK = 5066,
> ERROR_CLUSTER_NETWORK_HAS_DEPENDENTS = 5067,
> ERROR_INVALID_OPERATION_ON_QUORUM = 5068,
> ERROR_DEPENDENCY_NOT_ALLOWED = 5069,
> ERROR_CLUSTER_NODE_PAUSED = 5070,
> ERROR_NODE_CANT_HOST_RESOURCE = 5071,
> ERROR_CLUSTER_NODE_NOT_READY = 5072,
> ERROR_CLUSTER_NODE_SHUTTING_DOWN = 5073,
> ERROR_CLUSTER_JOIN_ABORTED = 5074,
> ERROR_CLUSTER_INCOMPATIBLE_VERSIONS = 5075,
> ERROR_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDED = 5076,
> ERROR_CLUSTER_SYSTEM_CONFIG_CHANGED = 5077,
> ERROR_CLUSTER_RESOURCE_TYPE_NOT_FOUND = 5078,
> ERROR_CLUSTER_RESTYPE_NOT_SUPPORTED = 5079,
> ERROR_CLUSTER_RESNAME_NOT_FOUND = 5080,
> ERROR_CLUSTER_NO_RPC_PACKAGES_REGISTERED = 5081,
> ERROR_CLUSTER_OWNER_NOT_IN_PREFLIST = 5082,
> ERROR_CLUSTER_DATABASE_SEQMISMATCH = 5083,
> ERROR_RESMON_INVALID_STATE = 5084,
> ERROR_CLUSTER_GUM_NOT_LOCKER = 5085,
> ERROR_QUORUM_DISK_NOT_FOUND = 5086,
> ERROR_DATABASE_BACKUP_CORRUPT = 5087,
> ERROR_CLUSTER_NODE_ALREADY_HAS_DFS_ROOT = 5088,
> ERROR_RESOURCE_PROPERTY_UNCHANGEABLE = 5089,
> ERROR_CLUSTER_MEMBERSHIP_INVALID_STATE = 5890,
> ERROR_CLUSTER_QUORUMLOG_NOT_FOUND = 5891,
> ERROR_CLUSTER_MEMBERSHIP_HALT = 5892,
> ERROR_CLUSTER_INSTANCE_ID_MISMATCH = 5893,
> ERROR_CLUSTER_NETWORK_NOT_FOUND_FOR_IP = 5894,
> ERROR_CLUSTER_PROPERTY_DATA_TYPE_MISMATCH = 5895,
> ERROR_CLUSTER_EVICT_WITHOUT_CLEANUP = 5896,
> ERROR_CLUSTER_PARAMETER_MISMATCH = 5897,
> ERROR_NODE_CANNOT_BE_CLUSTERED = 5898,
> ERROR_CLUSTER_WRONG_OS_VERSION = 5899,
> ERROR_CLUSTER_CANT_CREATE_DUP_CLUSTER_NAME = 5900,
> ERROR_ENCRYPTION_FAILED = 6000,
> ERROR_DECRYPTION_FAILED = 6001,
> ERROR_FILE_ENCRYPTED = 6002,
> ERROR_NO_RECOVERY_POLICY = 6003,
> ERROR_NO_EFS = 6004,
> ERROR_WRONG_EFS = 6005,
> ERROR_NO_USER_KEYS = 6006,
> ERROR_FILE_NOT_ENCRYPTED = 6007,
> ERROR_NOT_EXPORT_FORMAT = 6008,
> ERROR_FILE_READ_ONLY = 6009,
> ERROR_DIR_EFS_DISALLOWED = 6010,
> ERROR_EFS_SERVER_NOT_TRUSTED = 6011,
> ERROR_BAD_RECOVERY_POLICY = 6012,
> ERROR_EFS_ALG_BLOB_TOO_BIG = 6013,
> ERROR_VOLUME_NOT_SUPPORT_EFS = 6014,
> ERROR_EFS_DISABLED = 6015,
> ERROR_EFS_VERSION_NOT_SUPPORT = 6016,
> ERROR_NO_BROWSER_SERVERS_FOUND = 6118,
> SCHED_E_SERVICE_NOT_LOCALSYSTEM = 6200,
> ERROR_CTX_WINSTATION_NAME_INVALID = 7001,
> ERROR_CTX_INVALID_PD = 7002,
> ERROR_CTX_PD_NOT_FOUND = 7003,
> ERROR_CTX_WD_NOT_FOUND = 7004,
> ERROR_CTX_CANNOT_MAKE_EVENTLOG_ENTRY = 7005,
> ERROR_CTX_SERVICE_NAME_COLLISION = 7006,
> ERROR_CTX_CLOSE_PENDING = 7007,
> ERROR_CTX_NO_OUTBUF = 7008,
> ERROR_CTX_MODEM_INF_NOT_FOUND = 7009,
> ERROR_CTX_INVALID_MODEMNAME = 7010,
> ERROR_CTX_MODEM_RESPONSE_ERROR = 7011,
> ERROR_CTX_MODEM_RESPONSE_TIMEOUT = 7012,
> ERROR_CTX_MODEM_RESPONSE_NO_CARRIER = 7013,
> ERROR_CTX_MODEM_RESPONSE_NO_DIALTONE = 7014,
> ERROR_CTX_MODEM_RESPONSE_BUSY = 7015,
> ERROR_CTX_MODEM_RESPONSE_VOICE = 7016,
> ERROR_CTX_TD_ERROR = 7017,
> ERROR_CTX_WINSTATION_NOT_FOUND = 7022,
> ERROR_CTX_WINSTATION_ALREADY_EXISTS = 7023,
> ERROR_CTX_WINSTATION_BUSY = 7024,
> ERROR_CTX_BAD_VIDEO_MODE = 7025,
> ERROR_CTX_GRAPHICS_INVALID = 7035,
> ERROR_CTX_LOGON_DISABLED = 7037,
> ERROR_CTX_NOT_CONSOLE = 7038,
> ERROR_CTX_CLIENT_QUERY_TIMEOUT = 7040,
> ERROR_CTX_CONSOLE_DISCONNECT = 7041,
> ERROR_CTX_CONSOLE_CONNECT = 7042,
> ERROR_CTX_SHADOW_DENIED = 7044,
> ERROR_CTX_WINSTATION_ACCESS_DENIED = 7045,
> ERROR_CTX_INVALID_WD = 7049,
> ERROR_CTX_SHADOW_INVALID = 7050,
> ERROR_CTX_SHADOW_DISABLED = 7051,
> ERROR_CTX_CLIENT_LICENSE_IN_USE = 7052,
> ERROR_CTX_CLIENT_LICENSE_NOT_SET = 7053,
> ERROR_CTX_LICENSE_NOT_AVAILABLE = 7054,
> ERROR_CTX_LICENSE_CLIENT_INVALID = 7055,
> ERROR_CTX_LICENSE_EXPIRED = 7056,
> ERROR_CTX_SHADOW_NOT_RUNNING = 7057,
> ERROR_CTX_SHADOW_ENDED_BY_MODE_CHANGE = 7058,
> FRS_ERR_INVALID_API_SEQUENCE = 8001,
> FRS_ERR_STARTING_SERVICE = 8002,
> FRS_ERR_STOPPING_SERVICE = 8003,
> FRS_ERR_INTERNAL_API = 8004,
> FRS_ERR_INTERNAL = 8005,
> FRS_ERR_SERVICE_COMM = 8006,
> FRS_ERR_INSUFFICIENT_PRIV = 8007,
> FRS_ERR_AUTHENTICATION = 8008,
> FRS_ERR_PARENT_INSUFFICIENT_PRIV = 8009,
> FRS_ERR_PARENT_AUTHENTICATION = 8010,
> FRS_ERR_CHILD_TO_PARENT_COMM = 8011,
> FRS_ERR_PARENT_TO_CHILD_COMM = 8012,
> FRS_ERR_SYSVOL_POPULATE = 8013,
> FRS_ERR_SYSVOL_POPULATE_TIMEOUT = 8014,
> FRS_ERR_SYSVOL_IS_BUSY = 8015,
> FRS_ERR_SYSVOL_DEMOTE = 8016,
> FRS_ERR_INVALID_SERVICE_PARAMETER = 8017,
> ERROR_DS_NOT_INSTALLED = 8200,
> ERROR_DS_MEMBERSHIP_EVALUATED_LOCALLY = 8201,
> ERROR_DS_NO_ATTRIBUTE_OR_VALUE = 8202,
> ERROR_DS_INVALID_ATTRIBUTE_SYNTAX = 8203,
> ERROR_DS_ATTRIBUTE_TYPE_UNDEFINED = 8204,
> ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS = 8205,
> ERROR_DS_BUSY = 8206,
> ERROR_DS_UNAVAILABLE = 8207,
> ERROR_DS_NO_RIDS_ALLOCATED = 8208,
> ERROR_DS_NO_MORE_RIDS = 8209,
> ERROR_DS_INCORRECT_ROLE_OWNER = 8210,
> ERROR_DS_RIDMGR_INIT_ERROR = 8211,
> ERROR_DS_OBJ_CLASS_VIOLATION = 8212,
> ERROR_DS_CANT_ON_NON_LEAF = 8213,
> ERROR_DS_CANT_ON_RDN = 8214,
> ERROR_DS_CANT_MOD_OBJ_CLASS = 8215,
> ERROR_DS_CROSS_DOM_MOVE_ERROR = 8216,
> ERROR_DS_GC_NOT_AVAILABLE = 8217,
> ERROR_SHARED_POLICY = 8218,
> ERROR_POLICY_OBJECT_NOT_FOUND = 8219,
> ERROR_POLICY_ONLY_IN_DS = 8220,
> ERROR_PROMOTION_ACTIVE = 8221,
> ERROR_NO_PROMOTION_ACTIVE = 8222,
> ERROR_DS_OPERATIONS_ERROR = 8224,
> ERROR_DS_PROTOCOL_ERROR = 8225,
> ERROR_DS_TIMELIMIT_EXCEEDED = 8226,
> ERROR_DS_SIZELIMIT_EXCEEDED = 8227,
> ERROR_DS_ADMIN_LIMIT_EXCEEDED = 8228,
> ERROR_DS_COMPARE_FALSE = 8229,
> ERROR_DS_COMPARE_TRUE = 8230,
> ERROR_DS_AUTH_METHOD_NOT_SUPPORTED = 8231,
> ERROR_DS_STRONG_AUTH_REQUIRED = 8232,
> ERROR_DS_INAPPROPRIATE_AUTH = 8233,
> ERROR_DS_AUTH_UNKNOWN = 8234,
> ERROR_DS_REFERRAL = 8235,
> ERROR_DS_UNAVAILABLE_CRIT_EXTENSION = 8236,
> ERROR_DS_CONFIDENTIALITY_REQUIRED = 8237,
> ERROR_DS_INAPPROPRIATE_MATCHING = 8238,
> ERROR_DS_CONSTRAINT_VIOLATION = 8239,
> ERROR_DS_NO_SUCH_OBJECT = 8240,
> ERROR_DS_ALIAS_PROBLEM = 8241,
> ERROR_DS_INVALID_DN_SYNTAX = 8242,
> ERROR_DS_IS_LEAF = 8243,
> ERROR_DS_ALIAS_DEREF_PROBLEM = 8244,
> ERROR_DS_UNWILLING_TO_PERFORM = 8245,
> ERROR_DS_LOOP_DETECT = 8246,
> ERROR_DS_NAMING_VIOLATION = 8247,
> ERROR_DS_OBJECT_RESULTS_TOO_LARGE = 8248,
> ERROR_DS_AFFECTS_MULTIPLE_DSAS = 8249,
> ERROR_DS_SERVER_DOWN = 8250,
> ERROR_DS_LOCAL_ERROR = 8251,
> ERROR_DS_ENCODING_ERROR = 8252,
> ERROR_DS_DECODING_ERROR = 8253,
> ERROR_DS_FILTER_UNKNOWN = 8254,
> ERROR_DS_PARAM_ERROR = 8255,
> ERROR_DS_NOT_SUPPORTED = 8256,
> ERROR_DS_NO_RESULTS_RETURNED = 8257,
> ERROR_DS_CONTROL_NOT_FOUND = 8258,
> ERROR_DS_CLIENT_LOOP = 8259,
> ERROR_DS_REFERRAL_LIMIT_EXCEEDED = 8260,
> ERROR_DS_SORT_CONTROL_MISSING = 8261,
> ERROR_DS_OFFSET_RANGE_ERROR = 8262,
> ERROR_DS_ROOT_MUST_BE_NC = 8301,
> ERROR_DS_ADD_REPLICA_INHIBITED = 8302,
> ERROR_DS_ATT_NOT_DEF_IN_SCHEMA = 8303,
> ERROR_DS_MAX_OBJ_SIZE_EXCEEDED = 8304,
> ERROR_DS_OBJ_STRING_NAME_EXISTS = 8305,
> ERROR_DS_NO_RDN_DEFINED_IN_SCHEMA = 8306,
> ERROR_DS_RDN_DOESNT_MATCH_SCHEMA = 8307,
> ERROR_DS_NO_REQUESTED_ATTS_FOUND = 8308,
> ERROR_DS_USER_BUFFER_TO_SMALL = 8309,
> ERROR_DS_ATT_IS_NOT_ON_OBJ = 8310,
> ERROR_DS_ILLEGAL_MOD_OPERATION = 8311,
> ERROR_DS_OBJ_TOO_LARGE = 8312,
> ERROR_DS_BAD_INSTANCE_TYPE = 8313,
> ERROR_DS_MASTERDSA_REQUIRED = 8314,
> ERROR_DS_OBJECT_CLASS_REQUIRED = 8315,
> ERROR_DS_MISSING_REQUIRED_ATT = 8316,
> ERROR_DS_ATT_NOT_DEF_FOR_CLASS = 8317,
> ERROR_DS_ATT_ALREADY_EXISTS = 8318,
> ERROR_DS_CANT_ADD_ATT_VALUES = 8320,
> ERROR_DS_SINGLE_VALUE_CONSTRAINT = 8321,
> ERROR_DS_RANGE_CONSTRAINT = 8322,
> ERROR_DS_ATT_VAL_ALREADY_EXISTS = 8323,
> ERROR_DS_CANT_REM_MISSING_ATT = 8324,
> ERROR_DS_CANT_REM_MISSING_ATT_VAL = 8325,
> ERROR_DS_ROOT_CANT_BE_SUBREF = 8326,
> ERROR_DS_NO_CHAINING = 8327,
> ERROR_DS_NO_CHAINED_EVAL = 8328,
> ERROR_DS_NO_PARENT_OBJECT = 8329,
> ERROR_DS_PARENT_IS_AN_ALIAS = 8330,
> ERROR_DS_CANT_MIX_MASTER_AND_REPS = 8331,
> ERROR_DS_CHILDREN_EXIST = 8332,
> ERROR_DS_OBJ_NOT_FOUND = 8333,
> ERROR_DS_ALIASED_OBJ_MISSING = 8334,
> ERROR_DS_BAD_NAME_SYNTAX = 8335,
> ERROR_DS_ALIAS_POINTS_TO_ALIAS = 8336,
> ERROR_DS_CANT_DEREF_ALIAS = 8337,
> ERROR_DS_OUT_OF_SCOPE = 8338,
> ERROR_DS_OBJECT_BEING_REMOVED = 8339,
> ERROR_DS_CANT_DELETE_DSA_OBJ = 8340,
> ERROR_DS_GENERIC_ERROR = 8341,
> ERROR_DS_DSA_MUST_BE_INT_MASTER = 8342,
> ERROR_DS_CLASS_NOT_DSA = 8343,
> ERROR_DS_INSUFF_ACCESS_RIGHTS = 8344,
> ERROR_DS_ILLEGAL_SUPERIOR = 8345,
> ERROR_DS_ATTRIBUTE_OWNED_BY_SAM = 8346,
> ERROR_DS_NAME_TOO_MANY_PARTS = 8347,
> ERROR_DS_NAME_TOO_LONG = 8348,
> ERROR_DS_NAME_VALUE_TOO_LONG = 8349,
> ERROR_DS_NAME_UNPARSEABLE = 8350,
> ERROR_DS_NAME_TYPE_UNKNOWN = 8351,
> ERROR_DS_NOT_AN_OBJECT = 8352,
> ERROR_DS_SEC_DESC_TOO_SHORT = 8353,
> ERROR_DS_SEC_DESC_INVALID = 8354,
> ERROR_DS_NO_DELETED_NAME = 8355,
> ERROR_DS_SUBREF_MUST_HAVE_PARENT = 8356,
> ERROR_DS_NCNAME_MUST_BE_NC = 8357,
> ERROR_DS_CANT_ADD_SYSTEM_ONLY = 8358,
> ERROR_DS_CLASS_MUST_BE_CONCRETE = 8359,
> ERROR_DS_INVALID_DMD = 8360,
> ERROR_DS_OBJ_GUID_EXISTS = 8361,
> ERROR_DS_NOT_ON_BACKLINK = 8362,
> ERROR_DS_NO_CROSSREF_FOR_NC = 8363,
> ERROR_DS_SHUTTING_DOWN = 8364,
> ERROR_DS_UNKNOWN_OPERATION = 8365,
> ERROR_DS_INVALID_ROLE_OWNER = 8366,
> ERROR_DS_COULDNT_CONTACT_FSMO = 8367,
> ERROR_DS_CROSS_NC_DN_RENAME = 8368,
> ERROR_DS_CANT_MOD_SYSTEM_ONLY = 8369,
> ERROR_DS_REPLICATOR_ONLY = 8370,
> ERROR_DS_OBJ_CLASS_NOT_DEFINED = 8371,
> ERROR_DS_OBJ_CLASS_NOT_SUBCLASS = 8372,
> ERROR_DS_NAME_REFERENCE_INVALID = 8373,
> ERROR_DS_CROSS_REF_EXISTS = 8374,
> ERROR_DS_CANT_DEL_MASTER_CROSSREF = 8375,
> ERROR_DS_SUBTREE_NOTIFY_NOT_NC_HEAD = 8376,
> ERROR_DS_NOTIFY_FILTER_TOO_COMPLEX = 8377,
> ERROR_DS_DUP_RDN = 8378,
> ERROR_DS_DUP_OID = 8379,
> ERROR_DS_DUP_MAPI_ID = 8380,
> ERROR_DS_DUP_SCHEMA_ID_GUID = 8381,
> ERROR_DS_DUP_LDAP_DISPLAY_NAME = 8382,
> ERROR_DS_SEMANTIC_ATT_TEST = 8383,
> ERROR_DS_SYNTAX_MISMATCH = 8384,
> ERROR_DS_EXISTS_IN_MUST_HAVE = 8385,
> ERROR_DS_EXISTS_IN_MAY_HAVE = 8386,
> ERROR_DS_NONEXISTENT_MAY_HAVE = 8387,
> ERROR_DS_NONEXISTENT_MUST_HAVE = 8388,
> ERROR_DS_AUX_CLS_TEST_FAIL = 8389,
> ERROR_DS_NONEXISTENT_POSS_SUP = 8390,
> ERROR_DS_SUB_CLS_TEST_FAIL = 8391,
> ERROR_DS_BAD_RDN_ATT_ID_SYNTAX = 8392,
> ERROR_DS_EXISTS_IN_AUX_CLS = 8393,
> ERROR_DS_EXISTS_IN_SUB_CLS = 8394,
> ERROR_DS_EXISTS_IN_POSS_SUP = 8395,
> ERROR_DS_RECALCSCHEMA_FAILED = 8396,
> ERROR_DS_TREE_DELETE_NOT_FINISHED = 8397,
> ERROR_DS_CANT_DELETE = 8398,
> ERROR_DS_ATT_SCHEMA_REQ_ID = 8399,
> ERROR_DS_BAD_ATT_SCHEMA_SYNTAX = 8400,
> ERROR_DS_CANT_CACHE_ATT = 8401,
> ERROR_DS_CANT_CACHE_CLASS = 8402,
> ERROR_DS_CANT_REMOVE_ATT_CACHE = 8403,
> ERROR_DS_CANT_REMOVE_CLASS_CACHE = 8404,
> ERROR_DS_CANT_RETRIEVE_DN = 8405,
> ERROR_DS_MISSING_SUPREF = 8406,
> ERROR_DS_CANT_RETRIEVE_INSTANCE = 8407,
> ERROR_DS_CODE_INCONSISTENCY = 8408,
> ERROR_DS_DATABASE_ERROR = 8409,
> ERROR_DS_GOVERNSID_MISSING = 8410,
> ERROR_DS_MISSING_EXPECTED_ATT = 8411,
> ERROR_DS_NCNAME_MISSING_CR_REF = 8412,
> ERROR_DS_SECURITY_CHECKING_ERROR = 8413,
> ERROR_DS_SCHEMA_NOT_LOADED = 8414,
> ERROR_DS_SCHEMA_ALLOC_FAILED = 8415,
> ERROR_DS_ATT_SCHEMA_REQ_SYNTAX = 8416,
> ERROR_DS_GCVERIFY_ERROR = 8417,
> ERROR_DS_DRA_SCHEMA_MISMATCH = 8418,
> ERROR_DS_CANT_FIND_DSA_OBJ = 8419,
> ERROR_DS_CANT_FIND_EXPECTED_NC = 8420,
> ERROR_DS_CANT_FIND_NC_IN_CACHE = 8421,
> ERROR_DS_CANT_RETRIEVE_CHILD = 8422,
> ERROR_DS_SECURITY_ILLEGAL_MODIFY = 8423,
> ERROR_DS_CANT_REPLACE_HIDDEN_REC = 8424,
> ERROR_DS_BAD_HIERARCHY_FILE = 8425,
> ERROR_DS_BUILD_HIERARCHY_TABLE_FAILED = 8426,
> ERROR_DS_CONFIG_PARAM_MISSING = 8427,
> ERROR_DS_COUNTING_AB_INDICES_FAILED = 8428,
> ERROR_DS_HIERARCHY_TABLE_MALLOC_FAILED = 8429,
> ERROR_DS_INTERNAL_FAILURE = 8430,
> ERROR_DS_UNKNOWN_ERROR = 8431,
> ERROR_DS_ROOT_REQUIRES_CLASS_TOP = 8432,
> ERROR_DS_REFUSING_FSMO_ROLES = 8433,
> ERROR_DS_MISSING_FSMO_SETTINGS = 8434,
> ERROR_DS_UNABLE_TO_SURRENDER_ROLES = 8435,
> ERROR_DS_DRA_GENERIC = 8436,
> ERROR_DS_DRA_INVALID_PARAMETER = 8437,
> ERROR_DS_DRA_BUSY = 8438,
> ERROR_DS_DRA_BAD_DN = 8439,
> ERROR_DS_DRA_BAD_NC = 8440,
> ERROR_DS_DRA_DN_EXISTS = 8441,
> ERROR_DS_DRA_INTERNAL_ERROR = 8442,
> ERROR_DS_DRA_INCONSISTENT_DIT = 8443,
> ERROR_DS_DRA_CONNECTION_FAILED = 8444,
> ERROR_DS_DRA_BAD_INSTANCE_TYPE = 8445,
> ERROR_DS_DRA_OUT_OF_MEM = 8446,
> ERROR_DS_DRA_MAIL_PROBLEM = 8447,
> ERROR_DS_DRA_REF_ALREADY_EXISTS = 8448,
> ERROR_DS_DRA_REF_NOT_FOUND = 8449,
> ERROR_DS_DRA_OBJ_IS_REP_SOURCE = 8450,
> ERROR_DS_DRA_DB_ERROR = 8451,
> ERROR_DS_DRA_NO_REPLICA = 8452,
> ERROR_DS_DRA_ACCESS_DENIED = 8453,
> ERROR_DS_DRA_NOT_SUPPORTED = 8454,
> ERROR_DS_DRA_RPC_CANCELLED = 8455,
> ERROR_DS_DRA_SOURCE_DISABLED = 8456,
> ERROR_DS_DRA_SINK_DISABLED = 8457,
> ERROR_DS_DRA_NAME_COLLISION = 8458,
> ERROR_DS_DRA_SOURCE_REINSTALLED = 8459,
> ERROR_DS_DRA_MISSING_PARENT = 8460,
> ERROR_DS_DRA_PREEMPTED = 8461,
> ERROR_DS_DRA_ABANDON_SYNC = 8462,
> ERROR_DS_DRA_SHUTDOWN = 8463,
> ERROR_DS_DRA_INCOMPATIBLE_PARTIAL_SET = 8464,
> ERROR_DS_DRA_SOURCE_IS_PARTIAL_REPLICA = 8465,
> ERROR_DS_DRA_EXTN_CONNECTION_FAILED = 8466,
> ERROR_DS_INSTALL_SCHEMA_MISMATCH = 8467,
> ERROR_DS_DUP_LINK_ID = 8468,
> ERROR_DS_NAME_ERROR_RESOLVING = 8469,
> ERROR_DS_NAME_ERROR_NOT_FOUND = 8470,
> ERROR_DS_NAME_ERROR_NOT_UNIQUE = 8471,
> ERROR_DS_NAME_ERROR_NO_MAPPING = 8472,
> ERROR_DS_NAME_ERROR_DOMAIN_ONLY = 8473,
> ERROR_DS_NAME_ERROR_NO_SYNTACTICAL_MAPPING = 8474,
> ERROR_DS_CONSTRUCTED_ATT_MOD = 8475,
> ERROR_DS_WRONG_OM_OBJ_CLASS = 8476,
> ERROR_DS_DRA_REPL_PENDING = 8477,
> ERROR_DS_DS_REQUIRED = 8478,
> ERROR_DS_INVALID_LDAP_DISPLAY_NAME = 8479,
> ERROR_DS_NON_BASE_SEARCH = 8480,
> ERROR_DS_CANT_RETRIEVE_ATTS = 8481,
> ERROR_DS_BACKLINK_WITHOUT_LINK = 8482,
> ERROR_DS_EPOCH_MISMATCH = 8483,
> ERROR_DS_SRC_NAME_MISMATCH = 8484,
> ERROR_DS_SRC_AND_DST_NC_IDENTICAL = 8485,
> ERROR_DS_DST_NC_MISMATCH = 8486,
> ERROR_DS_NOT_AUTHORITIVE_FOR_DST_NC = 8487,
> ERROR_DS_SRC_GUID_MISMATCH = 8488,
> ERROR_DS_CANT_MOVE_DELETED_OBJECT = 8489,
> ERROR_DS_PDC_OPERATION_IN_PROGRESS = 8490,
> ERROR_DS_CROSS_DOMAIN_CLEANUP_REQD = 8491,
> ERROR_DS_ILLEGAL_XDOM_MOVE_OPERATION = 8492,
> ERROR_DS_CANT_WITH_ACCT_GROUP_MEMBERSHPS = 8493,
> ERROR_DS_NC_MUST_HAVE_NC_PARENT = 8494,
> ERROR_DS_DST_DOMAIN_NOT_NATIVE = 8496,
> ERROR_DS_MISSING_INFRASTRUCTURE_CONTAINER = 8497,
> ERROR_DS_CANT_MOVE_ACCOUNT_GROUP = 8498,
> ERROR_DS_CANT_MOVE_RESOURCE_GROUP = 8499,
> ERROR_DS_INVALID_SEARCH_FLAG = 8500,
> ERROR_DS_NO_TREE_DELETE_ABOVE_NC = 8501,
> ERROR_DS_COULDNT_LOCK_TREE_FOR_DELETE = 8502,
> ERROR_DS_COULDNT_IDENTIFY_OBJECTS_FOR_TREE_DELETE = 8503,
> ERROR_DS_SAM_INIT_FAILURE = 8504,
> ERROR_DS_SENSITIVE_GROUP_VIOLATION = 8505,
> ERROR_DS_CANT_MOD_PRIMARYGROUPID = 8506,
> ERROR_DS_ILLEGAL_BASE_SCHEMA_MOD = 8507,
> ERROR_DS_NONSAFE_SCHEMA_CHANGE = 8508,
> ERROR_DS_SCHEMA_UPDATE_DISALLOWED = 8509,
> ERROR_DS_CANT_CREATE_UNDER_SCHEMA = 8510,
> ERROR_DS_INSTALL_NO_SRC_SCH_VERSION = 8511,
> ERROR_DS_INSTALL_NO_SCH_VERSION_IN_INIFILE = 8512,
> ERROR_DS_INVALID_GROUP_TYPE = 8513,
> ERROR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN = 8514,
> ERROR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN = 8515,
> ERROR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER = 8516,
> ERROR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER = 8517,
> ERROR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER = 8518,
> ERROR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER = 8519,
> ERROR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER = 8520,
> ERROR_DS_HAVE_PRIMARY_MEMBERS = 8521,
> ERROR_DS_STRING_SD_CONVERSION_FAILED = 8522,
> ERROR_DS_NAMING_MASTER_GC = 8523,
> ERROR_DS_LOOKUP_FAILURE = 8524,
> ERROR_DS_COULDNT_UPDATE_SPNS = 8525,
> ERROR_DS_CANT_RETRIEVE_SD = 8526,
> ERROR_DS_KEY_NOT_UNIQUE = 8527,
> ERROR_DS_WRONG_LINKED_ATT_SYNTAX = 8528,
> ERROR_DS_SAM_NEED_BOOTKEY_PASSWORD = 8529,
> ERROR_DS_SAM_NEED_BOOTKEY_FLOPPY = 8530,
> ERROR_DS_CANT_START = 8531,
> ERROR_DS_INIT_FAILURE = 8532,
> ERROR_DS_NO_PKT_PRIVACY_ON_CONNECTION = 8533,
> ERROR_DS_SOURCE_DOMAIN_IN_FOREST = 8534,
> ERROR_DS_DESTINATION_DOMAIN_NOT_IN_FOREST = 8535,
> ERROR_DS_DESTINATION_AUDITING_NOT_ENABLED = 8536,
> ERROR_DS_CANT_FIND_DC_FOR_SRC_DOMAIN = 8537,
> ERROR_DS_SRC_OBJ_NOT_GROUP_OR_USER = 8538,
> ERROR_DS_SRC_SID_EXISTS_IN_FOREST = 8539,
> ERROR_DS_SRC_AND_DST_OBJECT_CLASS_MISMATCH = 8540,
> ERROR_SAM_INIT_FAILURE = 8541,
> ERROR_DS_DRA_SCHEMA_INFO_SHIP = 8542,
> ERROR_DS_DRA_SCHEMA_CONFLICT = 8543,
> ERROR_DS_DRA_EARLIER_SCHEMA_CONLICT = 8544,
> ERROR_DS_DRA_OBJ_NC_MISMATCH = 8545,
> ERROR_DS_NC_STILL_HAS_DSAS = 8546,
> ERROR_DS_GC_REQUIRED = 8547,
> ERROR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY = 8548,
> ERROR_DS_NO_FPO_IN_UNIVERSAL_GROUPS = 8549,
> ERROR_DS_CANT_ADD_TO_GC = 8550,
> ERROR_DS_NO_CHECKPOINT_WITH_PDC = 8551,
> ERROR_DS_SOURCE_AUDITING_NOT_ENABLED = 8552,
> ERROR_DS_CANT_CREATE_IN_NONDOMAIN_NC = 8553,
> ERROR_DS_INVALID_NAME_FOR_SPN = 8554,
> ERROR_DS_FILTER_USES_CONTRUCTED_ATTRS = 8555,
> ERROR_DS_UNICODEPWD_NOT_IN_QUOTES = 8556,
> ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED = 8557,
> ERROR_DS_MUST_BE_RUN_ON_DST_DC = 8558,
> ERROR_DS_SRC_DC_MUST_BE_SP4_OR_GREATER = 8559,
> ERROR_DS_CANT_TREE_DELETE_CRITICAL_OBJ = 8560,
> ERROR_DS_INIT_FAILURE_CONSOLE = 8561,
> ERROR_DS_SAM_INIT_FAILURE_CONSOLE = 8562,
> ERROR_DS_FOREST_VERSION_TOO_HIGH = 8563,
> ERROR_DS_DOMAIN_VERSION_TOO_HIGH = 8564,
> ERROR_DS_FOREST_VERSION_TOO_LOW = 8565,
> ERROR_DS_DOMAIN_VERSION_TOO_LOW = 8566,
> ERROR_DS_INCOMPATIBLE_VERSION = 8567,
> ERROR_DS_LOW_DSA_VERSION = 8568,
> ERROR_DS_NO_BEHAVIOR_VERSION_IN_MIXEDDOMAIN = 8569,
> ERROR_DS_NOT_SUPPORTED_SORT_ORDER = 8570,
> ERROR_DS_NAME_NOT_UNIQUE = 8571,
> ERROR_DS_MACHINE_ACCOUNT_CREATED_PRENT4 = 8572,
> ERROR_DS_OUT_OF_VERSION_STORE = 8573,
> ERROR_DS_INCOMPATIBLE_CONTROLS_USED = 8574,
> ERROR_DS_NO_REF_DOMAIN = 8575,
> ERROR_DS_RESERVED_LINK_ID = 8576,
> ERROR_DS_LINK_ID_NOT_AVAILABLE = 8577,
> ERROR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER = 8578,
> ERROR_DS_MODIFYDN_DISALLOWED_BY_INSTANCE_TYPE = 8579,
> ERROR_DS_NO_OBJECT_MOVE_IN_SCHEMA_NC = 8580,
> ERROR_DS_MODIFYDN_DISALLOWED_BY_FLAG = 8581,
> ERROR_DS_MODIFYDN_WRONG_GRANDPARENT = 8582,
> ERROR_DS_NAME_ERROR_TRUST_REFERRAL = 8583,
> ERROR_NOT_SUPPORTED_ON_STANDARD_SERVER = 8584,
> ERROR_DS_CANT_ACCESS_REMOTE_PART_OF_AD = 8585,
> ERROR_DS_CR_IMPOSSIBLE_TO_VALIDATE = 8586,
> ERROR_DS_THREAD_LIMIT_EXCEEDED = 8587,
> ERROR_DS_NOT_CLOSEST = 8588,
> ERROR_DS_CANT_DERIVE_SPN_WITHOUT_SERVER_REF = 8589,
> ERROR_DS_SINGLE_USER_MODE_FAILED = 8590,
> ERROR_DS_NTDSCRIPT_SYNTAX_ERROR = 8591,
> ERROR_DS_NTDSCRIPT_PROCESS_ERROR = 8592,
> ERROR_DS_DIFFERENT_REPL_EPOCHS = 8593,
> ERROR_DS_DRS_EXTENSIONS_CHANGED = 8594,
> ERROR_DS_REPLICA_SET_CHANGE_NOT_ALLOWED_ON_DISABLED_CR = 8595,
> ERROR_DS_NO_MSDS_INTID = 8596,
> ERROR_DS_DUP_MSDS_INTID = 8597,
> ERROR_DS_EXISTS_IN_RDNATTID = 8598,
> ERROR_DS_AUTHORIZATION_FAILED = 8599,
> ERROR_DS_INVALID_SCRIPT = 8600,
> ERROR_DS_REMOTE_CROSSREF_OP_FAILED = 8601,
> DNS_ERROR_RCODE_FORMAT_ERROR = 9001,
> DNS_ERROR_RCODE_SERVER_FAILURE = 9002,
> DNS_ERROR_RCODE_NAME_ERROR = 9003,
> DNS_ERROR_RCODE_NOT_IMPLEMENTED = 9004,
> DNS_ERROR_RCODE_REFUSED = 9005,
> DNS_ERROR_RCODE_YXDOMAIN = 9006,
> DNS_ERROR_RCODE_YXRRSET = 9007,
> DNS_ERROR_RCODE_NXRRSET = 9008,
> DNS_ERROR_RCODE_NOTAUTH = 9009,
> DNS_ERROR_RCODE_NOTZONE = 9010,
> DNS_ERROR_RCODE_BADSIG = 9016,
> DNS_ERROR_RCODE_BADKEY = 9017,
> DNS_ERROR_RCODE_BADTIME = 9018,
> DNS_INFO_NO_RECORDS = 9501,
> DNS_ERROR_BAD_PACKET = 9502,
> DNS_ERROR_NO_PACKET = 9503,
> DNS_ERROR_RCODE = 9504,
> DNS_ERROR_UNSECURE_PACKET = 9505,
> DNS_ERROR_INVALID_TYPE = 9551,
> DNS_ERROR_INVALID_IP_ADDRESS = 9552,
> DNS_ERROR_INVALID_PROPERTY = 9553,
> DNS_ERROR_TRY_AGAIN_LATER = 9554,
> DNS_ERROR_NOT_UNIQUE = 9555,
> DNS_ERROR_NON_RFC_NAME = 9556,
> DNS_STATUS_FQDN = 9557,
> DNS_STATUS_DOTTED_NAME = 9558,
> DNS_STATUS_SINGLE_PART_NAME = 9559,
> DNS_ERROR_INVALID_NAME_CHAR = 9560,
> DNS_ERROR_NUMERIC_NAME = 9561,
> DNS_ERROR_NOT_ALLOWED_ON_ROOT_SERVER = 9562,
> DNS_ERROR_ZONE_DOES_NOT_EXIST = 9601,
> DNS_ERROR_NO_ZONE_INFO = 9602,
> DNS_ERROR_INVALID_ZONE_OPERATION = 9603,
> DNS_ERROR_ZONE_CONFIGURATION_ERROR = 9604,
> DNS_ERROR_ZONE_HAS_NO_SOA_RECORD = 9605,
> DNS_ERROR_ZONE_HAS_NO_NS_RECORDS = 9606,
> DNS_ERROR_ZONE_LOCKED = 9607,
> DNS_ERROR_ZONE_CREATION_FAILED = 9608,
> DNS_ERROR_ZONE_ALREADY_EXISTS = 9609,
> DNS_ERROR_AUTOZONE_ALREADY_EXISTS = 9610,
> DNS_ERROR_INVALID_ZONE_TYPE = 9611,
> DNS_ERROR_SECONDARY_REQUIRES_MASTER_IP = 9612,
> DNS_ERROR_ZONE_NOT_SECONDARY = 9613,
> DNS_ERROR_NEED_SECONDARY_ADDRESSES = 9614,
> DNS_ERROR_WINS_INIT_FAILED = 9615,
> DNS_ERROR_NEED_WINS_SERVERS = 9616,
> DNS_ERROR_NBSTAT_INIT_FAILED = 9617,
> DNS_ERROR_SOA_DELETE_INVALID = 9618,
> DNS_ERROR_FORWARDER_ALREADY_EXISTS = 9619,
> DNS_ERROR_ZONE_REQUIRES_MASTER_IP = 9620,
> DNS_ERROR_ZONE_IS_SHUTDOWN = 9621,
> DNS_ERROR_PRIMARY_REQUIRES_DATAFILE = 9651,
> DNS_ERROR_INVALID_DATAFILE_NAME = 9652,
> DNS_ERROR_DATAFILE_OPEN_FAILURE = 9653,
> DNS_ERROR_FILE_WRITEBACK_FAILED = 9654,
> DNS_ERROR_DATAFILE_PARSING = 9655,
> DNS_ERROR_RECORD_DOES_NOT_EXIST = 9701,
> DNS_ERROR_RECORD_FORMAT = 9702,
> DNS_ERROR_NODE_CREATION_FAILED = 9703,
> DNS_ERROR_UNKNOWN_RECORD_TYPE = 9704,
> DNS_ERROR_RECORD_TIMED_OUT = 9705,
> DNS_ERROR_NAME_NOT_IN_ZONE = 9706,
> DNS_ERROR_CNAME_LOOP = 9707,
> DNS_ERROR_NODE_IS_CNAME = 9708,
> DNS_ERROR_CNAME_COLLISION = 9709,
> DNS_ERROR_RECORD_ONLY_AT_ZONE_ROOT = 9710,
> DNS_ERROR_RECORD_ALREADY_EXISTS = 9711,
> DNS_ERROR_SECONDARY_DATA = 9712,
> DNS_ERROR_NO_CREATE_CACHE_DATA = 9713,
> DNS_ERROR_NAME_DOES_NOT_EXIST = 9714,
> DNS_WARNING_PTR_CREATE_FAILED = 9715,
> DNS_WARNING_DOMAIN_UNDELETED = 9716,
> DNS_ERROR_DS_UNAVAILABLE = 9717,
> DNS_ERROR_DS_ZONE_ALREADY_EXISTS = 9718,
> DNS_ERROR_NO_BOOTFILE_IF_DS_ZONE = 9719,
> DNS_INFO_AXFR_COMPLETE = 9751,
> DNS_ERROR_AXFR = 9752,
> DNS_INFO_ADDED_LOCAL_WINS = 9753,
> DNS_STATUS_CONTINUE_NEEDED = 9801,
> DNS_ERROR_NO_TCPIP = 9851,
> DNS_ERROR_NO_DNS_SERVERS = 9852,
> DNS_ERROR_DP_DOES_NOT_EXIST = 9901,
> DNS_ERROR_DP_ALREADY_EXISTS = 9902,
> DNS_ERROR_DP_NOT_ENLISTED = 9903,
> DNS_ERROR_DP_ALREADY_ENLISTED = 9904,
> WSAEINTR = 10004,
> WSAEBADF = 10009,
> WSAEACCES = 10013,
> WSAEFAULT = 10014,
> WSAEINVAL = 10022,
> WSAEMFILE = 10024,
> WSAEWOULDBLOCK = 10035,
> WSAEINPROGRESS = 10036,
> WSAEALREADY = 10037,
> WSAENOTSOCK = 10038,
> WSAEDESTADDRREQ = 10039,
> WSAEMSGSIZE = 10040,
> WSAEPROTOTYPE = 10041,
> WSAENOPROTOOPT = 10042,
> WSAEPROTONOSUPPORT = 10043,
> WSAESOCKTNOSUPPORT = 10044,
> WSAEOPNOTSUPP = 10045,
> WSAEPFNOSUPPORT = 10046,
> WSAEAFNOSUPPORT = 10047,
> WSAEADDRINUSE = 10048,
> WSAEADDRNOTAVAIL = 10049,
> WSAENETDOWN = 10050,
> WSAENETUNREACH = 10051,
> WSAENETRESET = 10052,
> WSAECONNABORTED = 10053,
> WSAECONNRESET = 10054,
> WSAENOBUFS = 10055,
> WSAEISCONN = 10056,
> WSAENOTCONN = 10057,
> WSAESHUTDOWN = 10058,
> WSAETOOMANYREFS = 10059,
> WSAETIMEDOUT = 10060,
> WSAECONNREFUSED = 10061,
> WSAELOOP = 10062,
> WSAENAMETOOLONG = 10063,
> WSAEHOSTDOWN = 10064,
> WSAEHOSTUNREACH = 10065,
> WSAENOTEMPTY = 10066,
> WSAEPROCLIM = 10067,
> WSAEUSERS = 10068,
> WSAEDQUOT = 10069,
> WSAESTALE = 10070,
> WSAEREMOTE = 10071,
> WSASYSNOTREADY = 10091,
> WSAVERNOTSUPPORTED = 10092,
> WSANOTINITIALISED = 10093,
> WSAEDISCON = 10101,
> WSAENOMORE = 10102,
> WSAECANCELLED = 10103,
> WSAEINVALIDPROCTABLE = 10104,
> WSAEINVALIDPROVIDER = 10105,
> WSAEPROVIDERFAILEDINIT = 10106,
> WSASYSCALLFAILURE = 10107,
> WSASERVICE_NOT_FOUND = 10108,
> WSATYPE_NOT_FOUND = 10109,
> WSA_E_NO_MORE = 10110,
> WSA_E_CANCELLED = 10111,
> WSAEREFUSED = 10112,
> WSAHOST_NOT_FOUND = 11001,
> WSATRY_AGAIN = 11002,
> WSANO_RECOVERY = 11003,
> WSANO_DATA = 11004,
> WSA_QOS_RECEIVERS = 11005,
> WSA_QOS_SENDERS = 11006,
> WSA_QOS_NO_SENDERS = 11007,
> WSA_QOS_NO_RECEIVERS = 11008,
> WSA_QOS_REQUEST_CONFIRMED = 11009,
> WSA_QOS_ADMISSION_FAILURE = 11010,
> WSA_QOS_POLICY_FAILURE = 11011,
> WSA_QOS_BAD_STYLE = 11012,
> WSA_QOS_BAD_OBJECT = 11013,
> WSA_QOS_TRAFFIC_CTRL_ERROR = 11014,
> WSA_QOS_GENERIC_ERROR = 11015,
> WSA_QOS_ESERVICETYPE = 11016,
> WSA_QOS_EFLOWSPEC = 11017,
> WSA_QOS_EPROVSPECBUF = 11018,
> WSA_QOS_EFILTERSTYLE = 11019,
> WSA_QOS_EFILTERTYPE = 11020,
> WSA_QOS_EFILTERCOUNT = 11021,
> WSA_QOS_EOBJLENGTH = 11022,
> WSA_QOS_EFLOWCOUNT = 11023,
> WSA_QOS_EUNKNOWNPSOBJ = 11024,
> WSA_QOS_EPOLICYOBJ = 11025,
> WSA_QOS_EFLOWDESC = 11026,
> WSA_QOS_EPSFLOWSPEC = 11027,
> WSA_QOS_EPSFILTERSPEC = 11028,
> WSA_QOS_ESDMODEOBJ = 11029,
> WSA_QOS_ESHAPERATEOBJ = 11030,
> WSA_QOS_RESERVED_PETYPE = 11031,
> ERROR_IPSEC_QM_POLICY_EXISTS = 13000,
> ERROR_IPSEC_QM_POLICY_NOT_FOUND = 13001,
> ERROR_IPSEC_QM_POLICY_IN_USE = 13002,
> ERROR_IPSEC_MM_POLICY_EXISTS = 13003,
> ERROR_IPSEC_MM_POLICY_NOT_FOUND = 13004,
> ERROR_IPSEC_MM_POLICY_IN_USE = 13005,
> ERROR_IPSEC_MM_FILTER_EXISTS = 13006,
> ERROR_IPSEC_MM_FILTER_NOT_FOUND = 13007,
> ERROR_IPSEC_TRANSPORT_FILTER_EXISTS = 13008,
> ERROR_IPSEC_TRANSPORT_FILTER_NOT_FOUND = 13009,
> ERROR_IPSEC_MM_AUTH_EXISTS = 13010,
> ERROR_IPSEC_MM_AUTH_NOT_FOUND = 13011,
> ERROR_IPSEC_MM_AUTH_IN_USE = 13012,
> ERROR_IPSEC_DEFAULT_MM_POLICY_NOT_FOUND = 13013,
> ERROR_IPSEC_DEFAULT_MM_AUTH_NOT_FOUND = 13014,
> ERROR_IPSEC_DEFAULT_QM_POLICY_NOT_FOUND = 13015,
> ERROR_IPSEC_TUNNEL_FILTER_EXISTS = 13016,
> ERROR_IPSEC_TUNNEL_FILTER_NOT_FOUND = 13017,
> ERROR_IPSEC_MM_FILTER_PENDING_DELETION = 13018,
> ERROR_IPSEC_TRANSPORT_FILTER_PENDING_DELETION = 13019,
> ERROR_IPSEC_TUNNEL_FILTER_PENDING_DELETION = 13020,
> ERROR_IPSEC_MM_POLICY_PENDING_DELETION = 13021,
> ERROR_IPSEC_MM_AUTH_PENDING_DELETION = 13022,
> ERROR_IPSEC_QM_POLICY_PENDING_DELETION = 13023,
> ERROR_IPSEC_IKE_AUTH_FAIL = 13801,
> ERROR_IPSEC_IKE_ATTRIB_FAIL = 13802,
> ERROR_IPSEC_IKE_NEGOTIATION_PENDING = 13803,
> ERROR_IPSEC_IKE_GENERAL_PROCESSING_ERROR = 13804,
> ERROR_IPSEC_IKE_TIMED_OUT = 13805,
> ERROR_IPSEC_IKE_NO_CERT = 13806,
> ERROR_IPSEC_IKE_SA_DELETED = 13807,
> ERROR_IPSEC_IKE_SA_REAPED = 13808,
> ERROR_IPSEC_IKE_MM_ACQUIRE_DROP = 13809,
> ERROR_IPSEC_IKE_QM_ACQUIRE_DROP = 13810,
> ERROR_IPSEC_IKE_QUEUE_DROP_MM = 13811,
> ERROR_IPSEC_IKE_QUEUE_DROP_NO_MM = 13812,
> ERROR_IPSEC_IKE_DROP_NO_RESPONSE = 13813,
> ERROR_IPSEC_IKE_MM_DELAY_DROP = 13814,
> ERROR_IPSEC_IKE_QM_DELAY_DROP = 13815,
> ERROR_IPSEC_IKE_ERROR = 13816,
> ERROR_IPSEC_IKE_CRL_FAILED = 13817,
> ERROR_IPSEC_IKE_INVALID_KEY_USAGE = 13818,
> ERROR_IPSEC_IKE_INVALID_CERT_TYPE = 13819,
> ERROR_IPSEC_IKE_NO_PRIVATE_KEY = 13820,
> ERROR_IPSEC_IKE_DH_FAIL = 13822,
> ERROR_IPSEC_IKE_INVALID_HEADER = 13824,
> ERROR_IPSEC_IKE_NO_POLICY = 13825,
> ERROR_IPSEC_IKE_INVALID_SIGNATURE = 13826,
> ERROR_IPSEC_IKE_KERBEROS_ERROR = 13827,
> ERROR_IPSEC_IKE_NO_PUBLIC_KEY = 13828,
> ERROR_IPSEC_IKE_PROCESS_ERR = 13829,
> ERROR_IPSEC_IKE_PROCESS_ERR_SA = 13830,
> ERROR_IPSEC_IKE_PROCESS_ERR_PROP = 13831,
> ERROR_IPSEC_IKE_PROCESS_ERR_TRANS = 13832,
> ERROR_IPSEC_IKE_PROCESS_ERR_KE = 13833,
> ERROR_IPSEC_IKE_PROCESS_ERR_ID = 13834,
> ERROR_IPSEC_IKE_PROCESS_ERR_CERT = 13835,
> ERROR_IPSEC_IKE_PROCESS_ERR_CERT_REQ = 13836,
> ERROR_IPSEC_IKE_PROCESS_ERR_HASH = 13837,
> ERROR_IPSEC_IKE_PROCESS_ERR_SIG = 13838,
> ERROR_IPSEC_IKE_PROCESS_ERR_NONCE = 13839,
> ERROR_IPSEC_IKE_PROCESS_ERR_NOTIFY = 13840,
> ERROR_IPSEC_IKE_PROCESS_ERR_DELETE = 13841,
> ERROR_IPSEC_IKE_PROCESS_ERR_VENDOR = 13842,
> ERROR_IPSEC_IKE_INVALID_PAYLOAD = 13843,
> ERROR_IPSEC_IKE_LOAD_SOFT_SA = 13844,
> ERROR_IPSEC_IKE_SOFT_SA_TORN_DOWN = 13845,
> ERROR_IPSEC_IKE_INVALID_COOKIE = 13846,
> ERROR_IPSEC_IKE_NO_PEER_CERT = 13847,
> ERROR_IPSEC_IKE_PEER_CRL_FAILED = 13848,
> ERROR_IPSEC_IKE_POLICY_CHANGE = 13849,
> ERROR_IPSEC_IKE_NO_MM_POLICY = 13850,
> ERROR_IPSEC_IKE_NOTCBPRIV = 13851,
> ERROR_IPSEC_IKE_SECLOADFAIL = 13852,
> ERROR_IPSEC_IKE_FAILSSPINIT = 13853,
> ERROR_IPSEC_IKE_FAILQUERYSSP = 13854,
> ERROR_IPSEC_IKE_SRVACQFAIL = 13855,
> ERROR_IPSEC_IKE_SRVQUERYCRED = 13856,
> ERROR_IPSEC_IKE_GETSPIFAIL = 13857,
> ERROR_IPSEC_IKE_INVALID_FILTER = 13858,
> ERROR_IPSEC_IKE_OUT_OF_MEMORY = 13859,
> ERROR_IPSEC_IKE_ADD_UPDATE_KEY_FAILED = 13860,
> ERROR_IPSEC_IKE_INVALID_POLICY = 13861,
> ERROR_IPSEC_IKE_UNKNOWN_DOI = 13862,
> ERROR_IPSEC_IKE_INVALID_SITUATION = 13863,
> ERROR_IPSEC_IKE_DH_FAILURE = 13864,
> ERROR_IPSEC_IKE_INVALID_GROUP = 13865,
> ERROR_IPSEC_IKE_ENCRYPT = 13866,
> ERROR_IPSEC_IKE_DECRYPT = 13867,
> ERROR_IPSEC_IKE_POLICY_MATCH = 13868,
> ERROR_IPSEC_IKE_UNSUPPORTED_ID = 13869,
> ERROR_IPSEC_IKE_INVALID_HASH = 13870,
> ERROR_IPSEC_IKE_INVALID_HASH_ALG = 13871,
> ERROR_IPSEC_IKE_INVALID_HASH_SIZE = 13872,
> ERROR_IPSEC_IKE_INVALID_ENCRYPT_ALG = 13873,
> ERROR_IPSEC_IKE_INVALID_AUTH_ALG = 13874,
> ERROR_IPSEC_IKE_INVALID_SIG = 13875,
> ERROR_IPSEC_IKE_LOAD_FAILED = 13876,
> ERROR_IPSEC_IKE_RPC_DELETE = 13877,
> ERROR_IPSEC_IKE_BENIGN_REINIT = 13878,
> ERROR_IPSEC_IKE_INVALID_RESPONDER_LIFETIME_NOTIFY = 13879,
> ERROR_IPSEC_IKE_INVALID_CERT_KEYLEN = 13881,
> ERROR_IPSEC_IKE_MM_LIMIT = 13882,
> ERROR_IPSEC_IKE_NEGOTIATION_DISABLED = 13883,
> ERROR_IPSEC_IKE_NEG_STATUS_END = 13884,
> ERROR_SXS_SECTION_NOT_FOUND = 14000,
> ERROR_SXS_CANT_GEN_ACTCTX = 14001,
> ERROR_SXS_INVALID_ACTCTXDATA_FORMAT = 14002,
> ERROR_SXS_ASSEMBLY_NOT_FOUND = 14003,
> ERROR_SXS_MANIFEST_FORMAT_ERROR = 14004,
> ERROR_SXS_MANIFEST_PARSE_ERROR = 14005,
> ERROR_SXS_ACTIVATION_CONTEXT_DISABLED = 14006,
> ERROR_SXS_KEY_NOT_FOUND = 14007,
> ERROR_SXS_VERSION_CONFLICT = 14008,
> ERROR_SXS_WRONG_SECTION_TYPE = 14009,
> ERROR_SXS_THREAD_QUERIES_DISABLED = 14010,
> ERROR_SXS_PROCESS_DEFAULT_ALREADY_SET = 14011,
> ERROR_SXS_UNKNOWN_ENCODING_GROUP = 14012,
> ERROR_SXS_UNKNOWN_ENCODING = 14013,
> ERROR_SXS_INVALID_XML_NAMESPACE_URI = 14014,
> ERROR_SXS_ROOT_MANIFEST_DEPENDENCY_NOT_INSTALLED = 14015,
> ERROR_SXS_LEAF_MANIFEST_DEPENDENCY_NOT_INSTALLED = 14016,
> ERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE = 14017,
> ERROR_SXS_MANIFEST_MISSING_REQUIRED_DEFAULT_NAMESPACE = 14018,
> ERROR_SXS_MANIFEST_INVALID_REQUIRED_DEFAULT_NAMESPACE = 14019,
> ERROR_SXS_PRIVATE_MANIFEST_CROSS_PATH_WITH_REPARSE_POINT = 14020,
> ERROR_SXS_DUPLICATE_DLL_NAME = 14021,
> ERROR_SXS_DUPLICATE_WINDOWCLASS_NAME = 14022,
> ERROR_SXS_DUPLICATE_CLSID = 14023,
> ERROR_SXS_DUPLICATE_IID = 14024,
> ERROR_SXS_DUPLICATE_TLBID = 14025,
> ERROR_SXS_DUPLICATE_PROGID = 14026,
> ERROR_SXS_DUPLICATE_ASSEMBLY_NAME = 14027,
> ERROR_SXS_FILE_HASH_MISMATCH = 14028,
> ERROR_SXS_POLICY_PARSE_ERROR = 14029,
> ERROR_SXS_XML_E_MISSINGQUOTE = 14030,
> ERROR_SXS_XML_E_COMMENTSYNTAX = 14031,
> ERROR_SXS_XML_E_BADSTARTNAMECHAR = 14032,
> ERROR_SXS_XML_E_BADNAMECHAR = 14033,
> ERROR_SXS_XML_E_BADCHARINSTRING = 14034,
> ERROR_SXS_XML_E_XMLDECLSYNTAX = 14035,
> ERROR_SXS_XML_E_BADCHARDATA = 14036,
> ERROR_SXS_XML_E_MISSINGWHITESPACE = 14037,
> ERROR_SXS_XML_E_EXPECTINGTAGEND = 14038,
> ERROR_SXS_XML_E_MISSINGSEMICOLON = 14039,
> ERROR_SXS_XML_E_UNBALANCEDPAREN = 14040,
> ERROR_SXS_XML_E_INTERNALERROR = 14041,
> ERROR_SXS_XML_E_UNEXPECTED_WHITESPACE = 14042,
> ERROR_SXS_XML_E_INCOMPLETE_ENCODING = 14043,
> ERROR_SXS_XML_E_MISSING_PAREN = 14044,
> ERROR_SXS_XML_E_EXPECTINGCLOSEQUOTE = 14045,
> ERROR_SXS_XML_E_MULTIPLE_COLONS = 14046,
> ERROR_SXS_XML_E_INVALID_DECIMAL = 14047,
> ERROR_SXS_XML_E_INVALID_HEXIDECIMAL = 14048,
> ERROR_SXS_XML_E_INVALID_UNICODE = 14049,
> ERROR_SXS_XML_E_WHITESPACEORQUESTIONMARK = 14050,
> ERROR_SXS_XML_E_UNEXPECTEDENDTAG = 14051,
> ERROR_SXS_XML_E_UNCLOSEDTAG = 14052,
> ERROR_SXS_XML_E_DUPLICATEATTRIBUTE = 14053,
> ERROR_SXS_XML_E_MULTIPLEROOTS = 14054,
> ERROR_SXS_XML_E_INVALIDATROOTLEVEL = 14055,
> ERROR_SXS_XML_E_BADXMLDECL = 14056,
> ERROR_SXS_XML_E_MISSINGROOT = 14057,
> ERROR_SXS_XML_E_UNEXPECTEDEOF = 14058,
> ERROR_SXS_XML_E_BADPEREFINSUBSET = 14059,
> ERROR_SXS_XML_E_UNCLOSEDSTARTTAG = 14060,
> ERROR_SXS_XML_E_UNCLOSEDENDTAG = 14061,
> ERROR_SXS_XML_E_UNCLOSEDSTRING = 14062,
> ERROR_SXS_XML_E_UNCLOSEDCOMMENT = 14063,
> ERROR_SXS_XML_E_UNCLOSEDDECL = 14064,
> ERROR_SXS_XML_E_UNCLOSEDCDATA = 14065,
> ERROR_SXS_XML_E_RESERVEDNAMESPACE = 14066,
> ERROR_SXS_XML_E_INVALIDENCODING = 14067,
> ERROR_SXS_XML_E_INVALIDSWITCH = 14068,
> ERROR_SXS_XML_E_BADXMLCASE = 14069,
> ERROR_SXS_XML_E_INVALID_STANDALONE = 14070,
> ERROR_SXS_XML_E_UNEXPECTED_STANDALONE = 14071,
> ERROR_SXS_XML_E_INVALID_VERSION = 14072,
> ERROR_SXS_XML_E_MISSINGEQUALS = 14073,
> ERROR_SXS_PROTECTION_RECOVERY_FAILED = 14074,
> ERROR_SXS_PROTECTION_PUBLIC_KEY_TOO_SHORT = 14075,
> ERROR_SXS_PROTECTION_CATALOG_NOT_VALID = 14076,
> ERROR_SXS_UNTRANSLATABLE_HRESULT = 14077,
> ERROR_SXS_PROTECTION_CATALOG_FILE_MISSING = 14078,
> ERROR_SXS_MISSING_ASSEMBLY_IDENTITY_ATTRIBUTE = 14079,
> ERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME = 14080
>} WapiError;
>
>
>
>guint32 GetLastError (void);
>void SetLastError (guint32 code);
>guint32 errno_to_WSA (guint32 code, const char *function_name);
>gint _wapi_get_win32_file_error (gint err);
>void _wapi_error_cleanup (void);
>
>
># 22 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/events.h" 1
># 15 "../../mono/io-layer/events.h"
>
>
>extern gpointer CreateEvent (WapiSecurityAttributes *security, gboolean manual,
>        gboolean initial, const gunichar2 *name);
>extern gboolean PulseEvent (gpointer handle);
>extern gboolean ResetEvent (gpointer handle);
>extern gboolean SetEvent (gpointer handle);
>extern gpointer OpenEvent (guint32 access, gboolean inherit,
>      const gunichar2 *name);
>
>
># 23 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/messages.h" 1
># 16 "../../mono/io-layer/messages.h"
>typedef enum {
> FORMAT_MESSAGE_MAX_WIDTH_MASK = 0x000000FF,
> FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x00000100,
> FORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200,
> FORMAT_MESSAGE_FROM_STRING = 0x00000400,
> FORMAT_MESSAGE_FROM_HMODULE = 0x00000800,
> FORMAT_MESSAGE_FROM_SYSTEM = 0x00001000,
> FORMAT_MESSAGE_ARGUMENT_ARRAY = 0x00002000,
>} WapiFormatMessageFlags;
>
>
>extern guint32 FormatMessage (guint32 flags, gconstpointer source,
>         guint32 messageid, guint32 languageid,
>         gunichar2 *buf, guint32 size, ...);
># 24 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/mutexes.h" 1
># 15 "../../mono/io-layer/mutexes.h"
>
>
>extern gpointer CreateMutex (WapiSecurityAttributes *security, gboolean owned,
>        const gunichar2 *name);
>extern gboolean ReleaseMutex (gpointer handle);
>extern gpointer OpenMutex (guint32 access, gboolean inherit,
>      const gunichar2 *name);
>
>
># 25 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/processes.h" 1
># 17 "../../mono/io-layer/processes.h"
># 1 "../../mono/io-layer/versioninfo.h" 1
># 83 "../../mono/io-layer/versioninfo.h"
>typedef struct
>{
> guint32 dwSignature;
>
> guint32 dwStrucVersion;
> guint32 dwFileVersionMS;
> guint32 dwFileVersionLS;
> guint32 dwProductVersionMS;
> guint32 dwProductVersionLS;
> guint32 dwFileFlagsMask;
> guint32 dwFileFlags;
> guint32 dwFileOS;
> guint32 dwFileType;
> guint32 dwFileSubtype;
> guint32 dwFileDateMS;
> guint32 dwFileDateLS;
>} WapiFixedFileInfo;
># 111 "../../mono/io-layer/versioninfo.h"
>typedef struct
>{
> gpointer lpBaseOfDll;
> guint32 SizeOfImage;
> gpointer EntryPoint;
>} WapiModuleInfo;
># 154 "../../mono/io-layer/versioninfo.h"
>typedef struct
>{
> guint16 e_magic;
> guint16 e_cblp;
> guint16 e_cp;
> guint16 e_crlc;
> guint16 e_cparhdr;
> guint16 e_minalloc;
> guint16 e_maxalloc;
> guint16 e_ss;
> guint16 e_sp;
> guint16 e_csum;
> guint16 e_ip;
> guint16 e_cs;
> guint16 e_lfarlc;
> guint16 e_ovno;
> guint16 e_res[4];
> guint16 e_oemid;
> guint16 e_oeminfo;
> guint16 e_res2[10];
> guint32 e_lfanew;
>} WapiImageDosHeader;
>
>typedef struct
>{
> guint16 Machine;
> guint16 NumberOfSections;
> guint32 TimeDateStamp;
> guint32 PointerToSymbolTable;
> guint32 NumberOfSymbols;
> guint16 SizeOfOptionalHeader;
> guint16 Characteristics;
>} WapiImageFileHeader;
>
>typedef struct
>{
> guint32 VirtualAddress;
> guint32 Size;
>} WapiImageDataDirectory;
>
>typedef struct
>{
> guint16 Magic;
> guint8 MajorLinkerVersion;
> guint8 MinorLinkerVersion;
> guint32 SizeOfCode;
> guint32 SizeOfInitializedData;
> guint32 SizeOfUninitializedData;
> guint32 AddressOfEntryPoint;
> guint32 BaseOfCode;
> guint32 BaseOfData;
> guint32 ImageBase;
> guint32 SectionAlignment;
> guint32 FileAlignment;
> guint16 MajorOperatingSystemVersion;
> guint16 MinorOperatingSystemVersion;
> guint16 MajorImageVersion;
> guint16 MinorImageVersion;
> guint16 MajorSubsystemVersion;
> guint16 MinorSubsystemVersion;
> guint32 Win32VersionValue;
> guint32 SizeOfImage;
> guint32 SizeOfHeaders;
> guint32 CheckSum;
> guint16 Subsystem;
> guint16 DllCharacteristics;
> guint32 SizeOfStackReserve;
> guint32 SizeOfStackCommit;
> guint32 SizeOfHeapReserve;
> guint32 SizeOfHeapCommit;
> guint32 LoaderFlags;
> guint32 NumberOfRvaAndSizes;
> WapiImageDataDirectory DataDirectory[16];
>} WapiImageOptionalHeader32;
>
>typedef struct
>{
> guint16 Magic;
> guint8 MajorLinkerVersion;
> guint8 MinorLinkerVersion;
> guint32 SizeOfCode;
> guint32 SizeOfInitializedData;
> guint32 SizeOfUninitializedData;
> guint32 AddressOfEntryPoint;
> guint32 BaseOfCode;
> guint64 ImageBase;
> guint32 SectionAlignment;
> guint32 FileAlignment;
> guint16 MajorOperatingSystemVersion;
> guint16 MinorOperatingSystemVersion;
> guint16 MajorImageVersion;
> guint16 MinorImageVersion;
> guint16 MajorSubsystemVersion;
> guint16 MinorSubsystemVersion;
> guint32 Win32VersionValue;
> guint32 SizeOfImage;
> guint32 SizeOfHeaders;
> guint32 CheckSum;
> guint16 Subsystem;
> guint16 DllCharacteristics;
> guint64 SizeOfStackReserve;
> guint64 SizeOfStackCommit;
> guint64 SizeOfHeapReserve;
> guint64 SizeOfHeapCommit;
> guint32 LoaderFlags;
> guint32 NumberOfRvaAndSizes;
> WapiImageDataDirectory DataDirectory[16];
>} WapiImageOptionalHeader64;
>
>
>typedef WapiImageOptionalHeader64 WapiImageOptionalHeader;
>
>
>
>
>typedef struct
>{
> guint32 Signature;
> WapiImageFileHeader FileHeader;
> WapiImageOptionalHeader32 OptionalHeader;
>} WapiImageNTHeaders32;
>
>typedef struct
>{
> guint32 Signature;
> WapiImageFileHeader FileHeader;
> WapiImageOptionalHeader64 OptionalHeader;
>} WapiImageNTHeaders64;
>
>
>typedef WapiImageNTHeaders64 WapiImageNTHeaders;
>
>
>
>
>typedef struct
>{
> guint8 Name[8];
> union
> {
>  guint32 PhysicalAddress;
>  guint32 VirtualSize;
> } Misc;
> guint32 VirtualAddress;
> guint32 SizeOfRawData;
> guint32 PointerToRawData;
> guint32 PointerToRelocations;
> guint32 PointerToLinenumbers;
> guint16 NumberOfRelocations;
> guint16 NumberOfLinenumbers;
> guint32 Characteristics;
>} WapiImageSectionHeader;
># 333 "../../mono/io-layer/versioninfo.h"
>typedef struct
>{
> guint32 Characteristics;
> guint32 TimeDateStamp;
> guint16 MajorVersion;
> guint16 MinorVersion;
> guint16 NumberOfNamedEntries;
> guint16 NumberOfIdEntries;
>} WapiImageResourceDirectory;
>
>typedef struct
>{
> union
> {
>  struct
>  {
>
>   guint32 NameIsString:1;
>   guint32 NameOffset:31;
>
>
>
>
>  };
>  guint32 Name;
>
>  struct
>  {
>   guint16 __wapi_big_endian_padding;
>   guint16 Id;
>  };
>
>
>
> };
> union
> {
>  guint32 OffsetToData;
>  struct
>  {
>
>   guint32 DataIsDirectory:1;
>   guint32 OffsetToDirectory:31;
>
>
>
>
>  };
> };
>} WapiImageResourceDirectoryEntry;
>
>typedef struct
>{
> guint32 OffsetToData;
> guint32 Size;
> guint32 CodePage;
> guint32 Reserved;
>} WapiImageResourceDataEntry;
># 443 "../../mono/io-layer/versioninfo.h"
>extern guint32 GetFileVersionInfoSize (gunichar2 *filename, guint32 *handle);
>extern gboolean GetFileVersionInfo (gunichar2 *filename, guint32 handle,
>        guint32 len, gpointer data);
>extern gboolean VerQueryValue (gconstpointer datablock,
>          const gunichar2 *subblock, gpointer *buffer,
>          guint32 *len);
>extern guint32 VerLanguageName (guint32 lang, gunichar2 *lang_out,
>    guint32 lang_len);
># 18 "../../mono/io-layer/processes.h" 2
>
>
>
>typedef enum {
> STARTF_USESHOWWINDOW=0x001,
> STARTF_USESIZE=0x002,
> STARTF_USEPOSITION=0x004,
> STARTF_USECOUNTCHARS=0x008,
> STARTF_USEFILLATTRIBUTE=0x010,
> STARTF_RUNFULLSCREEN=0x020,
> STARTF_FORCEONFEEDBACK=0x040,
> STARTF_FORCEOFFFEEDBACK=0x080,
> STARTF_USESTDHANDLES=0x100
>} WapiStartupFlags;
>
>
>typedef struct _WapiStartupInfo WapiStartupInfo;
>
>struct _WapiStartupInfo
>{
> guint32 cb;
> guchar *lpReserved;
> guchar *lpDesktop;
> guchar *lpTitle;
> guint32 dwX;
> guint32 dwY;
> guint32 dwXSize;
> guint32 dwYSize;
> guint32 dwXCountChars;
> guint32 dwYCountChars;
> guint32 dwFillAttribute;
> WapiStartupFlags dwFlags;
> guint16 wShowWindow;
> guint16 cbReserved2;
> guint8 *lpReserved2;
> gpointer hStdInput;
> gpointer hStdOutput;
> gpointer hStdError;
>};
>
>typedef struct _WapiProcessInformation WapiProcessInformation;
>
>struct _WapiProcessInformation
>{
> gpointer hProcess;
> gpointer hThread;
> guint32 dwProcessId;
> guint32 dwThreadId;
>};
>
>typedef enum {
> SEE_MASK_CLASSNAME = 0x01,
> SEE_MASK_CLASSKEY = 0x03,
> SEE_MASK_IDLIST = 0x04,
> SEE_MASK_INVOKEIDLIST = 0x0c,
> SEE_MASK_ICON = 0x10,
> SEE_MASK_HOTKEY = 0x20,
> SEE_MASK_NOCLOSEPROCESS = 0x40,
> SEE_MASK_CONNECTNETDRV = 0x80,
> SEE_MASK_FLAG_DDEWAIT = 0x100,
> SEE_MASK_DOENVSUBST = 0x200,
> SEE_MASK_FLAG_NO_UI = 0x400,
> SEE_MASK_NO_CONSOLE = 0x8000,
> SEE_MASK_UNICODE = 0x10000,
> SEE_MASK_HMONITOR = 0x200000,
>
>
>} WapiShellExecuteInfoFlags;
>
>typedef enum {
> SW_HIDE = 0,
> SW_SHOWNORMAL = 1,
> SW_SHOWMINIMIZED = 2,
> SW_MAXIMIZE = 3,
> SW_SHOWMAXIMIZED = 3,
> SW_SHOWNOACTIVATE = 4,
> SW_SHOW = 5,
> SW_MINIMIZE = 6,
> SW_SHOWMINNOACTIVE = 7,
> SW_SHOWNA = 8,
> SW_RESTORE = 9,
> SW_SHOWDEFAULT = 10,
>} WapiShellExecuteShowFlags;
>
>typedef struct _WapiShellExecuteInfo WapiShellExecuteInfo;
>
>struct _WapiShellExecuteInfo
>{
> guint32 cbSize;
> WapiShellExecuteInfoFlags fMask;
> gpointer hwnd;
> const gunichar2 *lpVerb;
> const gunichar2 *lpFile;
> const gunichar2 *lpParameters;
> const gunichar2 *lpDirectory;
> WapiShellExecuteShowFlags nShow;
> gpointer hInstApp;
> gpointer lpIDList;
> const gunichar2 *lpClass;
> gpointer hkeyClass;
> guint32 dwHotKey;
> union
> {
>  gpointer hIcon;
>  gpointer hMonitor;
> } u;
> gpointer hProcess;
>};
># 166 "../../mono/io-layer/processes.h"
>extern gboolean ShellExecuteEx (WapiShellExecuteInfo *sei);
>extern gboolean CreateProcess (const gunichar2 *appname,
>          const gunichar2 *cmdline,
>          WapiSecurityAttributes *process_attrs,
>          WapiSecurityAttributes *thread_attrs,
>          gboolean inherit_handles, guint32 create_flags,
>          gpointer environ, const gunichar2 *cwd,
>          WapiStartupInfo *startup,
>          WapiProcessInformation *process_info);
>extern gboolean CreateProcessWithLogonW (const gunichar2 *username,
>      const gunichar2 *domain,
>      const gunichar2 *password,
>      const guint32 logonFlags,
>      const gunichar2 *appname,
>      const gunichar2 *cmdline,
>      guint32 create_flags,
>      gpointer environ,
>      const gunichar2 *cwd,
>      WapiStartupInfo *startup,
>      WapiProcessInformation *process_info);
>
>
>
>extern gpointer GetCurrentProcess (void);
>extern guint32 GetProcessId (gpointer handle);
>extern guint32 GetCurrentProcessId (void);
>extern gboolean EnumProcesses (guint32 *pids, guint32 len, guint32 *needed);
>extern gboolean CloseProcess (gpointer handle);
>extern gpointer OpenProcess (guint32 access, gboolean inherit, guint32 pid);
>extern gboolean GetExitCodeProcess (gpointer process, guint32 *code);
>extern gboolean GetProcessTimes (gpointer process, WapiFileTime *create_time,
>     WapiFileTime *exit_time,
>     WapiFileTime *kernel_time,
>     WapiFileTime *user_time);
>extern gboolean EnumProcessModules (gpointer process, gpointer *modules,
>        guint32 size, guint32 *needed);
>extern guint32 GetModuleBaseName (gpointer process, gpointer module,
>      gunichar2 *basename, guint32 size);
>extern guint32 GetModuleFileNameEx (gpointer process, gpointer module,
>        gunichar2 *filename, guint32 size);
>extern gboolean GetModuleInformation (gpointer process, gpointer module,
>          WapiModuleInfo *modinfo, guint32 size);
>extern gboolean GetProcessWorkingSetSize (gpointer process, size_t *min,
>       size_t *max);
>extern gboolean SetProcessWorkingSetSize (gpointer process, size_t min,
>       size_t max);
>
>extern gboolean TerminateProcess (gpointer process, gint32 exitCode);
>
>extern guint32 GetPriorityClass (gpointer process);
>extern gboolean SetPriorityClass (gpointer process, guint32 priority_class);
>
>
>
># 26 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/security.h" 1
># 15 "../../mono/io-layer/security.h"
>
>
>extern gboolean ImpersonateLoggedOnUser (gpointer handle);
>extern gboolean RevertToSelf (void);
>
>
># 27 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/semaphores.h" 1
># 15 "../../mono/io-layer/semaphores.h"
>
>
>extern gpointer CreateSemaphore(WapiSecurityAttributes *security,
>    gint32 initial, gint32 max,
>    const gunichar2 *name);
>extern gboolean ReleaseSemaphore(gpointer handle, gint32 count,
>     gint32 *prevcount);
>extern gpointer OpenSemaphore (guint32 access, gboolean inherit,
>          const gunichar2 *name);
>
>
># 28 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/sockets.h" 1
># 15 "../../mono/io-layer/sockets.h"
>
>
>
>
>
>typedef struct
>{
> guint16 wVersion;
> guint16 wHighVersion;
> char szDescription[256 +1];
> char szSystemStatus[128 +1];
> guint16 iMaxSockets;
> guint16 iMaxUdpDg;
> guchar *lpVendorInfo;
>} WapiWSAData;
>
>
>
>
>
>
>
>typedef struct
>{
> guint32 Data1;
> guint16 Data2;
> guint16 Data3;
> guint8 Data4[8];
>} WapiGuid;
>
>typedef struct
>{
> gpointer Head;
> guint32 HeadLength;
> gpointer Tail;
> guint32 TailLength;
>} WapiTransmitFileBuffers;
>
>typedef enum {
> TF_USE_DEFAULT_WORKER = 0,
> TF_DISCONNECT = 0x01,
> TF_REUSE_SOCKET = 0x02,
> TF_WRITE_BEHIND = 0x04,
> TF_USE_SYSTEM_THREAD = 0x10,
> TF_USE_KERNEL_APC = 0x20
>} WapiTransmitFileFlags;
>
>typedef struct
>{
> guint32 len;
> gpointer buf;
>} WapiWSABuf;
>
>
>
>
>
>
>typedef gboolean (*WapiDisconnectExFn)(guint32, WapiOverlapped *, guint32,
>     WapiTransmitFileFlags);
>typedef gboolean (*WapiTransmitFileFn)(guint32, gpointer, guint32, guint32,
>     WapiOverlapped *,
>     WapiTransmitFileBuffers *,
>     WapiTransmitFileFlags);
>
>
>extern int WSAStartup(guint32 requested, WapiWSAData *data);
>extern int WSACleanup(void);
>extern void WSASetLastError(int error);
>extern int WSAGetLastError(void);
>extern int closesocket(guint32 handle);
>
>extern int ioctlsocket(guint32 handle, gint32 command, gpointer arg);
>extern int WSAIoctl (guint32 handle, gint32 command,
>       gchar *input, gint i_len,
>       gchar *output, gint o_len, glong *written,
>       void *unused1, void *unused2);
>extern int WSARecv (guint32 handle, WapiWSABuf *buffers, guint32 count,
>      guint32 *received, guint32 *flags,
>      WapiOverlapped *overlapped, WapiOverlappedCB *complete);
>extern int WSASend (guint32 handle, WapiWSABuf *buffers, guint32 count,
>      guint32 *sent, guint32 flags,
>      WapiOverlapped *overlapped, WapiOverlappedCB *complete);
>
>gboolean TransmitFile (guint32 socket, gpointer file, guint32 bytes_to_write, guint32 bytes_per_send, WapiOverlapped *ol,
>   WapiTransmitFileBuffers *tb, guint32 flags);
>
># 29 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/status.h" 1
># 13 "../../mono/io-layer/status.h"
>typedef enum {
> STATUS_WAIT_0 = (int) 0x00000000,
> STATUS_ABANDONED_WAIT_0 = (int) 0x00000080,
> STATUS_USER_APC = (int) 0x000000C0,
> STATUS_TIMEOUT = (int) 0x00000102,
> STATUS_PENDING = (int) 0x00000103,
> STATUS_SEGMENT_NOTIFICATION = (int) 0x40000005,
> STATUS_GUARD_PAGE_VIOLATION = (int) 0x80000001,
> STATUS_DATATYPE_MISALIGNMENT = (int) 0x80000002,
> STATUS_BREAKPOINT = (int) 0x80000003,
> STATUS_SINGLE_STEP = (int) 0x80000004,
> STATUS_ACCESS_VIOLATION = (int) 0xC0000005,
> STATUS_IN_PAGE_ERROR = (int) 0xC0000006,
> STATUS_NO_MEMORY = (int) 0xC0000017,
> STATUS_ILLEGAL_INSTRUCTION = (int) 0xC000001D,
> STATUS_NONCONTINUABLE_EXCEPTION = (int) 0xC0000025,
> STATUS_INVALID_DISPOSITION = (int) 0xC0000026,
> STATUS_ARRAY_BOUNDS_EXCEEDED = (int) 0xC000008C,
> STATUS_FLOAT_DENORMAL_OPERAND = (int) 0xC000008D,
> STATUS_FLOAT_DIVIDE_BY_ZERO = (int) 0xC000008E,
> STATUS_FLOAT_INEXACT_RESULT = (int) 0xC000008F,
> STATUS_FLOAT_INVALID_OPERATION = (int) 0xC0000090,
> STATUS_FLOAT_OVERFLOW = (int) 0xC0000091,
> STATUS_FLOAT_STACK_CHECK = (int) 0xC0000092,
> STATUS_FLOAT_UNDERFLOW = (int) 0xC0000093,
> STATUS_INTEGER_DIVIDE_BY_ZERO = (int) 0xC0000094,
> STATUS_INTEGER_UNDERFLOW = (int) 0xC0000095,
> STATUS_PRIVILEGED_INSTRUCTION = (int) 0xC0000096,
> STATUS_STACK_OVERFLOW = (int) 0xC00000FD,
> STATUS_CONTROL_C_EXIT = (int) 0xC000013A
>} WapiStatus;
># 30 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/system.h" 1
># 15 "../../mono/io-layer/system.h"
>
>
>typedef struct _WapiSystemInfo WapiSystemInfo;
>
>struct _WapiSystemInfo
>{
> union _anon_union
> {
>  guint32 dwOemId;
>  struct _anon_struct
>  {
>   guint16 wProcessorArchitecture;
>   guint16 wReserved;
>  } _anon_struct;
> } _anon_union;
>
> guint32 dwPageSize;
> gpointer lpMinimumApplicationAddress;
> gpointer lpMaximumApplicationAddress;
> guint32 dwActiveProcessorMask;
> guint32 dwNumberOfProcessors;
> guint32 dwProcessorType;
> guint32 dwAllocationGranularity;
> guint16 wProcessorLevel;
> guint16 wProcessorRevision;
>};
>
>extern void GetSystemInfo(WapiSystemInfo *info);
>
>
># 31 "../../mono/io-layer/wapi.h" 2
># 1 "../../mono/io-layer/threads.h" 1
># 21 "../../mono/io-layer/threads.h"
>
># 40 "../../mono/io-layer/threads.h"
>typedef guint32 (*WapiThreadStart)(gpointer);
>typedef guint32 (*WapiApcProc)(gpointer);
>
>
>
>
>
>
>extern gpointer CreateThread(WapiSecurityAttributes *security,
>        guint32 stacksize, WapiThreadStart start,
>        gpointer param, guint32 create, gsize *tid);
>extern gpointer OpenThread (guint32 access, gboolean inherit, gsize tid);
>extern void ExitThread(guint32 exitcode) __attribute__((__noreturn__));
>extern gboolean GetExitCodeThread(gpointer handle, guint32 *exitcode);
>extern gsize GetCurrentThreadId(void);
>extern gpointer GetCurrentThread(void);
>extern guint32 ResumeThread(gpointer handle);
>extern guint32 SuspendThread(gpointer handle);
>extern guint32 mono_pthread_key_for_tls (guint32 idx);
>extern guint32 TlsAlloc(void);
>extern gboolean TlsFree(guint32 idx);
>extern gpointer TlsGetValue(guint32 idx);
>extern gboolean TlsSetValue(guint32 idx, gpointer value);
>extern void Sleep(guint32 ms);
>extern guint32 SleepEx(guint32 ms, gboolean alertable);
>extern guint32 QueueUserAPC (WapiApcProc apc_callback, gpointer thread_handle,
>     gpointer param);
>
>
>
>
>extern void _wapi_thread_signal_self (guint32 exitstatus);
>
>void wapi_interrupt_thread (gpointer handle);
>void wapi_clear_interruption (void);
>gboolean wapi_thread_set_wait_handle (gpointer handle);
>void wapi_thread_clear_wait_handle (gpointer handle);
>void wapi_self_interrupt (void);
>
>char* wapi_current_thread_desc (void);
>
>
># 32 "../../mono/io-layer/wapi.h" 2
>
>
># 1 "../../mono/io-layer/wait.h" 1
># 15 "../../mono/io-layer/wait.h"
>
># 30 "../../mono/io-layer/wait.h"
>extern guint32 WaitForSingleObject(gpointer handle, guint32 timeout);
>extern guint32 WaitForSingleObjectEx(gpointer handle, guint32 timeout,
>     gboolean alertable);
>extern guint32 SignalObjectAndWait(gpointer signal_handle, gpointer wait,
>       guint32 timeout, gboolean alertable);
>extern guint32 WaitForMultipleObjects(guint32 numobjects, gpointer *handles,
>          gboolean waitall, guint32 timeout);
>extern guint32 WaitForMultipleObjectsEx(guint32 numobjects, gpointer *handles,
>          gboolean waitall, guint32 timeout, gboolean alertable);
>extern guint32 WaitForInputIdle(gpointer handle, guint32 timeout);
>
>
># 35 "../../mono/io-layer/wapi.h" 2
># 36 "../../mono/io-layer/io-layer.h" 2
># 1 "../../mono/io-layer/uglify.h" 1
># 19 "../../mono/io-layer/uglify.h"
>typedef const gunichar2 *LPCTSTR;
>typedef gunichar2 *LPTSTR;
>typedef const char *LPCSTR;
>typedef char *LPSTR;
>typedef guint8 BYTE;
>typedef guint8 *LPBYTE;
>typedef guint16 WORD;
>typedef guint32 DWORD;
>typedef gpointer PVOID;
>typedef gpointer LPVOID;
>typedef gboolean BOOL;
>typedef guint32 *LPDWORD;
>typedef gint32 LONG;
>typedef guint32 ULONG;
>typedef gint32 *PLONG;
>typedef guint64 LONGLONG;
>typedef gunichar2 TCHAR;
>typedef size_t SIZE_T;
>typedef guint64 ULONG64;
>typedef guint UINT;
>typedef gconstpointer LPCVOID;
>
>typedef gpointer HANDLE;
>typedef gpointer *LPHANDLE;
>typedef guint32 SOCKET;
>typedef gpointer HMODULE;
>typedef gpointer HINSTANCE;
>typedef gpointer HWND;
>typedef gpointer HKEY;
>
>typedef WapiSecurityAttributes SECURITY_ATTRIBUTES;
>typedef WapiSecurityAttributes *LPSECURITY_ATTRIBUTES;
>typedef WapiOverlapped *LPOVERLAPPED;
>typedef WapiOverlappedCB LPOVERLAPPED_COMPLETION_ROUTINE;
>typedef WapiThreadStart LPTHREAD_START_ROUTINE;
>typedef WapiCriticalSection CRITICAL_SECTION;
>typedef WapiCriticalSection *LPCRITICAL_SECTION;
>typedef WapiFileTime FILETIME;
>typedef WapiFileTime *LPFILETIME;
>typedef WapiSystemTime SYSTEMTIME;
>typedef WapiSystemTime *LPSYSTEMTIME;
>typedef WapiWSAData WSADATA;
>typedef WapiWSAData *LDWSADATA;
>typedef WapiWSABuf WSABUF;
>typedef WapiWSABuf *LPWSABUF;
>typedef WapiLargeInteger LARGE_INTEGER;
>typedef WapiLargeInteger *PLARGE_INTEGER;
>typedef WapiULargeInteger ULARGE_INTEGER;
>typedef WapiULargeInteger *PULARGE_INTEGER;
>typedef WapiSystemInfo SYSTEM_INFO;
>typedef WapiSystemInfo *LPSYSTEM_INFO;
>typedef WapiFloatingSaveArea FLOATING_SAVE_AREA;
>typedef WapiFloatingSaveArea *PFLOATING_SAVE_AREA;
>typedef WapiContext CONTEXT;
>typedef WapiContext *PCONTEXT;
>typedef WapiFindData WIN32_FIND_DATA;
>typedef WapiFindData *LPWIN32_FIND_DATA;
>typedef WapiFileAttributesData WIN32_FILE_ATTRIBUTE_DATA;
>typedef WapiGetFileExInfoLevels GET_FILEEX_INFO_LEVELS;
>typedef WapiStartupInfo STARTUPINFO;
>typedef WapiStartupInfo *LPSTARTUPINFO;
>typedef WapiProcessInformation PROCESS_INFORMATION;
>typedef WapiFixedFileInfo VS_FIXEDFILEINFO;
>typedef WapiModuleInfo MODULEINFO;
>typedef WapiModuleInfo *LPMODULEINFO;
>typedef WapiImageDosHeader IMAGE_DOS_HEADER;
>typedef WapiImageDosHeader *PIMAGE_DOS_HEADER;
>typedef WapiImageFileHeader IMAGE_FILE_HEADER;
>typedef WapiImageFileHeader *PIMAGE_FILE_HEADER;
>typedef WapiImageDataDirectory IMAGE_DATA_DIRECTORY;
>typedef WapiImageDataDirectory *PIMAGE_DATA_DIRECTORY;
>typedef WapiImageOptionalHeader32 IMAGE_OPTIONAL_HEADER32;
>typedef WapiImageOptionalHeader32 *PIMAGE_OPTIONAL_HEADER32;
>typedef WapiImageOptionalHeader64 IMAGE_OPTIONAL_HEADER64;
>typedef WapiImageOptionalHeader64 *PIMAGE_OPTIONAL_HEADER64;
>typedef WapiImageOptionalHeader IMAGE_OPTIONAL_HEADER;
>typedef WapiImageOptionalHeader *PIMAGE_OPTIONAL_HEADER;
>typedef WapiImageNTHeaders32 IMAGE_NT_HEADERS32;
>typedef WapiImageNTHeaders32 *PIMAGE_NT_HEADERS32;
>typedef WapiImageNTHeaders64 IMAGE_NT_HEADERS64;
>typedef WapiImageNTHeaders64 *PIMAGE_NT_HEADERS64;
>typedef WapiImageNTHeaders IMAGE_NT_HEADERS;
>typedef WapiImageNTHeaders *PIMAGE_NT_HEADERS;
>typedef WapiImageSectionHeader IMAGE_SECTION_HEADER;
>typedef WapiImageSectionHeader *PIMAGE_SECTION_HEADER;
>typedef WapiImageResourceDirectory IMAGE_RESOURCE_DIRECTORY;
>typedef WapiImageResourceDirectory *PIMAGE_RESOURCE_DIRECTORY;
>typedef WapiImageResourceDirectoryEntry IMAGE_RESOURCE_DIRECTORY_ENTRY;
>typedef WapiImageResourceDirectoryEntry *PIMAGE_RESOURCE_DIRECTORY_ENTRY;
>typedef WapiImageResourceDataEntry IMAGE_RESOURCE_DATA_ENTRY;
>typedef WapiImageResourceDataEntry *PIMAGE_RESOURCE_DATA_ENTRY;
>typedef WapiApcProc PAPCFUNC;
>typedef WapiShellExecuteInfo SHELLEXECUTEINFO;
>typedef WapiShellExecuteInfo *LPSHELLEXECUTEINFO;
>typedef WapiTransmitFileBuffers TRANSMIT_FILE_BUFFERS;
>typedef WapiTransmitFileBuffers *PTRANSMIT_FILE_BUFFERS;
>typedef WapiTransmitFileBuffers *LPTRANSMIT_FILE_BUFFERS;
>typedef WapiDisconnectExFn LPFN_DISCONNECTEX;
>typedef WapiTransmitFileFn LPFN_TRANSMITFILE;
>typedef WapiGuid GUID;
>typedef WapiGuid *LPGUID;
># 37 "../../mono/io-layer/io-layer.h" 2
># 15 "../../mono/metadata/domain-internals.h" 2
># 1 "../../mono/metadata/mempool-internals.h" 1
># 9 "../../mono/metadata/mempool-internals.h"
>static inline GList*
>g_list_prepend_mempool (MonoMemPool *mp, GList *list, gpointer data)
>{
> GList *new_list;
>
> new_list = mono_mempool_alloc (mp, sizeof (GList));
> new_list->data = data;
> new_list->prev = list ? list->prev : ((void *)0);
>    new_list->next = list;
>
>    if (new_list->prev)
>            new_list->prev->next = new_list;
>    if (list)
>            list->prev = new_list;
>
> return new_list;
>}
>
>static inline GSList*
>g_slist_prepend_mempool (MonoMemPool *mp, GSList *list, gpointer data)
>{
> GSList *new_list;
>
> new_list = mono_mempool_alloc (mp, sizeof (GSList));
> new_list->data = data;
> new_list->next = list;
>
> return new_list;
>}
>
>static inline GSList*
>g_slist_append_mempool (MonoMemPool *mp, GSList *list, gpointer data)
>{
> GSList *new_list;
> GSList *last;
>
> new_list = mono_mempool_alloc (mp, sizeof (GSList));
> new_list->data = data;
> new_list->next = ((void *)0);
>
> if (list) {
>  last = list;
>  while (last->next)
>   last = last->next;
>  last->next = new_list;
>
>  return list;
> } else
>  return new_list;
>}
>
>long
>mono_mempool_get_bytes_allocated (void) __attribute__ ((visibility ("hidden")));
># 16 "../../mono/metadata/domain-internals.h" 2
>
>extern CRITICAL_SECTION mono_delegate_section;
>extern CRITICAL_SECTION mono_strtod_mutex;
>
>
>
>
>
>
>
>extern gboolean mono_dont_free_domains;
>
>
>typedef struct {
> MonoObject object;
> MonoString *application_base;
> MonoString *application_name;
> MonoString *cache_path;
> MonoString *configuration_file;
> MonoString *dynamic_base;
> MonoString *license_file;
> MonoString *private_bin_path;
> MonoString *private_bin_path_probe;
> MonoString *shadow_copy_directories;
> MonoString *shadow_copy_files;
> MonoBoolean publisher_policy;
> MonoBoolean path_changed;
> int loader_optimization;
> MonoBoolean disallow_binding_redirects;
> MonoBoolean disallow_code_downloads;
> MonoObject *activation_arguments;
> MonoObject *domain_initializer;
> MonoObject *application_trust;
> MonoArray *domain_initializer_args;
> MonoBoolean disallow_appbase_probe;
> MonoArray *configuration_bytes;
> MonoArray *serialized_non_primitives;
>} MonoAppDomainSetup;
>
>typedef struct _MonoJitInfoTable MonoJitInfoTable;
>typedef struct _MonoJitInfoTableChunk MonoJitInfoTableChunk;
>
>
>
>struct _MonoJitInfoTableChunk
>{
> int refcount;
> volatile int num_elements;
> volatile gint8 *last_code_end;
> MonoJitInfo * volatile data [64];
>};
>
>struct _MonoJitInfoTable
>{
> MonoDomain *domain;
> int num_chunks;
> MonoJitInfoTableChunk *chunks [0];
>};
>
>
>
>typedef GArray MonoAotModuleInfoTable;
>
>typedef struct {
> guint32 flags;
> gint32 exvar_offset;
> gpointer try_start;
> gpointer try_end;
> gpointer handler_start;
> union {
>  MonoClass *catch_class;
>  gpointer filter;
>  gpointer handler_end;
> } data;
>} MonoJitExceptionInfo;
>
>
>
>
>
>typedef struct {
> int dummy;
>} MonoGenericSharingContext;
>
>typedef struct
>{
> MonoGenericSharingContext *generic_sharing_context;
> gint32 this_offset;
> guint8 this_reg;
> gboolean has_this:1;
> gboolean this_in_reg:1;
>} MonoGenericJitInfo;
># 132 "../../mono/metadata/domain-internals.h"
>typedef struct
>{
> guint32 offset;
> guint16 clause;
> guint16 length;
>} MonoTryBlockHoleJitInfo;
>
>typedef struct
>{
> guint16 num_holes;
> MonoTryBlockHoleJitInfo holes [0];
>} MonoTryBlockHoleTableJitInfo;
>
>typedef struct
>{
> guint32 stack_size;
>} MonoArchEHJitInfo;
>
>struct _MonoJitInfo {
>
>
>
>
> MonoMethod *method;
> struct _MonoJitInfo *next_jit_code_hash;
> gpointer code_start;
>
> guint32 used_regs;
> int code_size;
> guint32 num_clauses:15;
>
> gboolean domain_neutral:1;
> gboolean cas_inited:1;
> gboolean cas_class_assert:1;
> gboolean cas_class_deny:1;
> gboolean cas_class_permitonly:1;
> gboolean cas_method_assert:1;
> gboolean cas_method_deny:1;
> gboolean cas_method_permitonly:1;
> gboolean has_generic_jit_info:1;
> gboolean has_try_block_holes:1;
> gboolean has_arch_eh_info:1;
> gboolean from_aot:1;
> gboolean from_llvm:1;
>
>
> gpointer gc_info;
>
> MonoJitExceptionInfo clauses [0];
>
>
>
>};
>
>
>
>struct _MonoAppContext {
> MonoObject obj;
> gint32 domain_id;
> gint32 context_id;
> gpointer *static_data;
>};
># 202 "../../mono/metadata/domain-internals.h"
>typedef enum {
> MONO_APPDOMAIN_CREATED,
> MONO_APPDOMAIN_UNLOADING_START,
> MONO_APPDOMAIN_UNLOADING,
> MONO_APPDOMAIN_UNLOADED
>} MonoAppDomainState;
>
>typedef struct _MonoThunkFreeList {
> guint32 size;
> int length;
> struct _MonoThunkFreeList *next;
>} MonoThunkFreeList;
>
>typedef struct _MonoJitCodeHash MonoJitCodeHash;
>
>struct _MonoDomain {
>
>
>
>
>
> CRITICAL_SECTION lock;
> MonoMemPool *mp;
> MonoCodeManager *code_mp;
>
>
>
>
>
> MonoAppDomainSetup *setup;
> MonoAppDomain *domain;
> MonoAppContext *default_context;
> MonoException *out_of_memory_ex;
> MonoException *null_reference_ex;
> MonoException *stack_overflow_ex;
>
> MonoObject *typeof_void;
>
> MonoObject *ephemeron_tombstone;
>
> MonoArray *empty_types;
>
>
>
>
>
> MonoGHashTable *env;
> MonoGHashTable *ldstr_table;
>
> MonoGHashTable *type_hash;
> MonoGHashTable *refobject_hash;
>
> gpointer *static_data_array;
>
> MonoGHashTable *type_init_exception_hash;
>
> MonoGHashTable *delegate_hash_table;
>
> guint32 state;
>
> gint32 domain_id;
> gint32 shadow_serial;
> unsigned char inet_family_hint;
> GSList *domain_assemblies;
> MonoAssembly *entry_assembly;
> char *friendly_name;
> GPtrArray *class_vtable_array;
>
> GHashTable *proxy_vtable_hash;
>
> MonoInternalHashTable jit_code_hash;
> CRITICAL_SECTION jit_code_hash_lock;
> int num_jit_info_tables;
> MonoJitInfoTable *
>   volatile jit_info_table;
> GSList *jit_info_free_queue;
>
> gchar **search_path;
> gchar *private_bin_path;
>
>
> MonoMethod *create_proxy_for_type_method;
> MonoMethod *private_invoke_method;
>
> GHashTable *special_static_fields;
>
>
>
>
> GHashTable *finalizable_objects_hash;
>
>
>
> GHashTable *track_resurrection_objects_hash;
>
> GHashTable *track_resurrection_handles_hash;
>
>
> CRITICAL_SECTION finalizable_objects_hash_lock;
>
> CRITICAL_SECTION assemblies_lock;
>
> GHashTable *method_rgctx_hash;
>
> GHashTable *generic_virtual_cases;
> MonoThunkFreeList **thunk_free_lists;
>
> GHashTable *generic_virtual_thunks;
>
>
> gpointer runtime_info;
>
>
> volatile int threadpool_jobs;
> HANDLE cleanup_semaphore;
>
>
> gpointer finalize_runtime_invoke;
>
>
> gpointer capture_context_runtime_invoke;
>
>
> gpointer capture_context_method;
>
>
> GSList *assembly_bindings;
> gboolean assembly_bindings_parsed;
>
>
>
> MonoImage *socket_assembly;
> MonoClass *sockaddr_class;
> MonoClassField *sockaddr_data_field;
>
>
> MonoImage *system_image;
> MonoImage *system_net_dll;
> MonoClass *corlib_asyncresult_class;
> MonoClass *socket_class;
> MonoClass *ad_unloaded_ex_class;
> MonoClass *process_class;
>};
>
>typedef struct {
> guint16 major, minor, build, revision;
>} AssemblyVersionSet;
>
>
>typedef struct {
> const char runtime_version [12];
> const char framework_version [4];
> const AssemblyVersionSet version_sets [3];
>} MonoRuntimeInfo;
># 364 "../../mono/metadata/domain-internals.h"
>typedef MonoDomain* (*MonoLoadFunc) (const char *filename, const char *runtime_version);
>
>void
>mono_install_runtime_load (MonoLoadFunc func) __attribute__ ((visibility ("hidden")));
>
>MonoDomain*
>mono_runtime_load (const char *filename, const char *runtime_version) __attribute__ ((visibility ("hidden")));
>
>typedef void (*MonoCreateDomainFunc) (MonoDomain *domain);
>
>void
>mono_install_create_domain_hook (MonoCreateDomainFunc func) __attribute__ ((visibility ("hidden")));
>
>typedef void (*MonoFreeDomainFunc) (MonoDomain *domain);
>
>void
>mono_install_free_domain_hook (MonoFreeDomainFunc func) __attribute__ ((visibility ("hidden")));
>
>void
>mono_init_com_types (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_cleanup (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_close_exe_image (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_jit_info_table_add (MonoDomain *domain, MonoJitInfo *ji) __attribute__ ((visibility ("hidden")));
>
>void
>mono_jit_info_table_remove (MonoDomain *domain, MonoJitInfo *ji) __attribute__ ((visibility ("hidden")));
>
>void
>mono_jit_info_add_aot_module (MonoImage *image, gpointer start, gpointer end) __attribute__ ((visibility ("hidden")));
>
>MonoGenericJitInfo*
>mono_jit_info_get_generic_jit_info (MonoJitInfo *ji) __attribute__ ((visibility ("hidden")));
>
>MonoGenericSharingContext*
>mono_jit_info_get_generic_sharing_context (MonoJitInfo *ji) __attribute__ ((visibility ("hidden")));
>
>void
>mono_jit_info_set_generic_sharing_context (MonoJitInfo *ji, MonoGenericSharingContext *gsctx) __attribute__ ((visibility ("hidden")));
>
>MonoJitInfo*
>mono_domain_lookup_shared_generic (MonoDomain *domain, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>char *
>mono_make_shadow_copy (const char *filename) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_is_shadow_copy_enabled (MonoDomain *domain, const gchar *dir_name) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_domain_alloc (MonoDomain *domain, guint size) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_domain_alloc0 (MonoDomain *domain, guint size) __attribute__ ((visibility ("hidden")));
>
>void*
>mono_domain_code_reserve (MonoDomain *domain, int size) __attribute__ ((visibility ("hidden")));
>
>void*
>mono_domain_code_reserve_align (MonoDomain *domain, int size, int alignment) __attribute__ ((visibility ("hidden")));
>
>void
>mono_domain_code_commit (MonoDomain *domain, void *data, int size, int newsize) __attribute__ ((visibility ("hidden")));
>
>void *
>nacl_domain_get_code_dest (MonoDomain *domain, void *data) __attribute__ ((visibility ("hidden")));
>
>void
>nacl_domain_code_validate (MonoDomain *domain, guint8 **buf_base, int buf_size, guint8 **code_end) __attribute__ ((visibility ("hidden")));
>
>void
>mono_domain_code_foreach (MonoDomain *domain, MonoCodeManagerFunc func, void *user_data) __attribute__ ((visibility ("hidden")));
>
>void
>mono_domain_unset (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_domain_set_internal_with_options (MonoDomain *domain, gboolean migrate_exception) __attribute__ ((visibility ("hidden")));
>
>MonoTryBlockHoleTableJitInfo*
>mono_jit_info_get_try_block_hole_table_info (MonoJitInfo *ji) __attribute__ ((visibility ("hidden")));
>
>MonoArchEHJitInfo*
>mono_jit_info_get_arch_eh_info (MonoJitInfo *ji) __attribute__ ((visibility ("hidden")));
>
>
>
>
>
>typedef MonoJitInfo *(*MonoJitInfoFindInAot) (MonoDomain *domain, MonoImage *image, gpointer addr);
>void mono_install_jit_info_find_in_aot (MonoJitInfoFindInAot func) __attribute__ ((visibility ("hidden")));
>
>void
>mono_jit_code_hash_init (MonoInternalHashTable *jit_code_hash) __attribute__ ((visibility ("hidden")));
>
>MonoAppDomain *
>ves_icall_System_AppDomain_getCurDomain (void) __attribute__ ((visibility ("hidden")));
>
>MonoAppDomain *
>ves_icall_System_AppDomain_getRootDomain (void) __attribute__ ((visibility ("hidden")));
>
>MonoAppDomain *
>ves_icall_System_AppDomain_createDomain (MonoString *friendly_name,
>          MonoAppDomainSetup *setup) __attribute__ ((visibility ("hidden")));
>
>MonoObject *
>ves_icall_System_AppDomain_GetData (MonoAppDomain *ad,
>          MonoString *name) __attribute__ ((visibility ("hidden")));
>
>MonoReflectionAssembly *
>ves_icall_System_AppDomain_LoadAssemblyRaw (MonoAppDomain *ad,
>              MonoArray *raw_assembly,
>          MonoArray *raw_symbol_store,
>          MonoObject *evidence,
>          MonoBoolean refonly) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_AppDomain_SetData (MonoAppDomain *ad,
>          MonoString *name,
>          MonoObject *data) __attribute__ ((visibility ("hidden")));
>
>MonoAppDomainSetup *
>ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad) __attribute__ ((visibility ("hidden")));
>
>MonoString *
>ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad) __attribute__ ((visibility ("hidden")));
>
>MonoArray *
>ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad,
>          MonoBoolean refonly) __attribute__ ((visibility ("hidden")));
>
>MonoReflectionAssembly *
>ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname,
>          MonoBoolean refonly) __attribute__ ((visibility ("hidden")));
>
>MonoReflectionAssembly *
>ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad,
>          MonoString *assRef,
>          MonoObject *evidence,
>          MonoBoolean refonly) __attribute__ ((visibility ("hidden")));
>
>gboolean
>ves_icall_System_AppDomain_InternalIsFinalizingForUnload (gint32 domain_id) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_AppDomain_InternalUnload (gint32 domain_id) __attribute__ ((visibility ("hidden")));
>
>gint32
>ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad,
>             MonoReflectionAssembly *refass,
>             MonoArray *args) __attribute__ ((visibility ("hidden")));
>
>MonoAppDomain *
>ves_icall_System_AppDomain_InternalSetDomain (MonoAppDomain *ad) __attribute__ ((visibility ("hidden")));
>
>MonoAppDomain *
>ves_icall_System_AppDomain_InternalSetDomainByID (gint32 domainid) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_AppDomain_InternalPushDomainRef (MonoAppDomain *ad) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_AppDomain_InternalPushDomainRefByID (gint32 domain_id) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_AppDomain_InternalPopDomainRef (void) __attribute__ ((visibility ("hidden")));
>
>MonoAppContext *
>ves_icall_System_AppDomain_InternalGetContext (void) __attribute__ ((visibility ("hidden")));
>
>MonoAppContext *
>ves_icall_System_AppDomain_InternalGetDefaultContext (void) __attribute__ ((visibility ("hidden")));
>
>MonoAppContext *
>ves_icall_System_AppDomain_InternalSetContext (MonoAppContext *mc) __attribute__ ((visibility ("hidden")));
>
>gint32
>ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad) __attribute__ ((visibility ("hidden")));
>
>MonoString *
>ves_icall_System_AppDomain_InternalGetProcessGuid (MonoString* newguid) __attribute__ ((visibility ("hidden")));
>
>MonoAssembly *
>mono_assembly_load_corlib (const MonoRuntimeInfo *runtime, MonoImageOpenStatus *status) __attribute__ ((visibility ("hidden")));
>
>const MonoRuntimeInfo*
>mono_get_runtime_info (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_runtime_set_no_exec (gboolean val) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_runtime_get_no_exec (void) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_assembly_name_parse (const char *name, MonoAssemblyName *aname) __attribute__ ((visibility ("hidden")));
>
>MonoImage *mono_assembly_open_from_bundle (const char *filename,
>        MonoImageOpenStatus *status,
>        gboolean refonly) __attribute__ ((visibility ("hidden")));
>
>void
>mono_domain_add_class_static_data (MonoDomain *domain, MonoClass *klass, gpointer data, guint32 *bitmap);
>
>MonoReflectionAssembly *
>mono_try_assembly_resolve (MonoDomain *domain, MonoString *fname, gboolean refonly) __attribute__ ((visibility ("hidden")));
>
>MonoAssembly* mono_assembly_load_full_nosearch (MonoAssemblyName *aname,
>      const char *basedir,
>      MonoImageOpenStatus *status,
>      gboolean refonly) __attribute__ ((visibility ("hidden")));
>
>void mono_set_private_bin_path_from_config (MonoDomain *domain) __attribute__ ((visibility ("hidden")));
>
>int mono_framework_version (void) __attribute__ ((visibility ("hidden")));
>
>void mono_reflection_cleanup_domain (MonoDomain *domain) __attribute__ ((visibility ("hidden")));
>
>void mono_assembly_cleanup_domain_bindings (guint32 domain_id) __attribute__ ((visibility ("hidden")));;
># 9 "../../mono/metadata/metadata-internals.h" 2
>
>
># 1 "../../mono/utils/mono-dl.h" 1
>
>
>
>
># 1 "../../mono/utils/mono-dl-fallback.h" 1
>
>
>
>
>
>
>
>enum {
> MONO_DL_LAZY = 1,
> MONO_DL_LOCAL = 2,
> MONO_DL_MASK = 3
>};
>
>
>
>
>typedef struct MonoDlFallbackHandler MonoDlFallbackHandler;
>
>
>
>
>typedef void* (*MonoDlFallbackLoad) (const char *name, int flags, char **err, void *user_data);
>typedef void* (*MonoDlFallbackSymbol) (void *handle, const char *name, char **err, void *user_data);
>typedef void* (*MonoDlFallbackClose) (void *handle, void *user_data);
>
>MonoDlFallbackHandler *mono_dl_fallback_register (MonoDlFallbackLoad load_func, MonoDlFallbackSymbol symbol_func,
>        MonoDlFallbackClose close_func, void *user_data);
>
>void mono_dl_fallback_unregister (MonoDlFallbackHandler *handler);
>
>
># 6 "../../mono/utils/mono-dl.h" 2
>
>typedef struct _MonoDl MonoDl;
>
>MonoDl* mono_dl_open (const char *name, int flags, char **error_msg) __attribute__ ((visibility ("hidden")));
>char* mono_dl_symbol (MonoDl *module, const char *name, void **symbol) __attribute__ ((visibility ("hidden")));
>void mono_dl_close (MonoDl *module) __attribute__ ((visibility ("hidden")));
>
>char* mono_dl_build_path (const char *directory, const char *name, void **iter) __attribute__ ((visibility ("hidden")));
># 12 "../../mono/metadata/metadata-internals.h" 2
># 1 "../../mono/utils/monobitset.h" 1
># 21 "../../mono/utils/monobitset.h"
>typedef struct {
> gsize size;
> gsize flags;
> gsize data [0];
>} MonoBitSet;
>
>typedef void (*MonoBitSetFunc) (guint idx, gpointer data);
>
>enum {
> MONO_BITSET_DONT_FREE = 1
>};
># 65 "../../mono/utils/monobitset.h"
>guint32 mono_bitset_alloc_size (guint32 max_size, guint32 flags);
>
>MonoBitSet* mono_bitset_new (guint32 max_size, guint32 flags);
>
>MonoBitSet* mono_bitset_mem_new (gpointer mem, guint32 max_size, guint32 flags);
>
>void mono_bitset_free (MonoBitSet *set);
>
>void mono_bitset_set (MonoBitSet *set, guint32 pos);
>
>void mono_bitset_set_all (MonoBitSet *set);
>
>int mono_bitset_test (const MonoBitSet *set, guint32 pos);
>
>gsize mono_bitset_test_bulk (const MonoBitSet *set, guint32 pos);
>
>void mono_bitset_clear (MonoBitSet *set, guint32 pos);
>
>void mono_bitset_clear_all (MonoBitSet *set);
>
>void mono_bitset_invert (MonoBitSet *set);
>
>guint32 mono_bitset_size (const MonoBitSet *set);
>
>guint32 mono_bitset_count (const MonoBitSet *set);
>
>void mono_bitset_low_high (const MonoBitSet *set, guint32 *low, guint32 *high);
>
>int mono_bitset_find_start (const MonoBitSet *set);
>
>int mono_bitset_find_first (const MonoBitSet *set, gint pos);
>
>int mono_bitset_find_last (const MonoBitSet *set, gint pos);
>
>int mono_bitset_find_first_unset (const MonoBitSet *set, gint pos);
>
>MonoBitSet* mono_bitset_clone (const MonoBitSet *set, guint32 new_size);
>
>void mono_bitset_copyto (const MonoBitSet *src, MonoBitSet *dest);
>
>void mono_bitset_union (MonoBitSet *dest, const MonoBitSet *src);
>
>void mono_bitset_intersection (MonoBitSet *dest, const MonoBitSet *src);
>
>void mono_bitset_sub (MonoBitSet *dest, const MonoBitSet *src);
>
>gboolean mono_bitset_equal (const MonoBitSet *src, const MonoBitSet *src1);
>
>void mono_bitset_foreach (MonoBitSet *set, MonoBitSetFunc func, gpointer data);
>
>void mono_bitset_intersection_2 (MonoBitSet *dest, const MonoBitSet *src1, const MonoBitSet *src2);
># 13 "../../mono/metadata/metadata-internals.h" 2
># 1 "../../mono/utils/mono-property-hash.h" 1
># 22 "../../mono/utils/mono-property-hash.h"
>
>
>typedef struct _MonoPropertyHash MonoPropertyHash;
>
>MonoPropertyHash* mono_property_hash_new (void);
>
>void mono_property_hash_destroy (MonoPropertyHash *hash);
>
>void mono_property_hash_insert (MonoPropertyHash *hash, gpointer object, guint32 property,
>        gpointer value);
>
>
>void mono_property_hash_remove_object (MonoPropertyHash *hash, gpointer object);
>
>gpointer mono_property_hash_lookup (MonoPropertyHash *hash, gpointer object, guint32 property);
>
>
># 14 "../../mono/metadata/metadata-internals.h" 2
># 1 "../../mono/utils/mono-value-hash.h" 1
># 15 "../../mono/utils/mono-value-hash.h"
># 1 "../../mono/utils/mono-compiler.h" 1
># 16 "../../mono/utils/mono-value-hash.h" 2
>
>
># 35 "../../mono/utils/mono-value-hash.h"
>typedef struct _MonoValueHashTable MonoValueHashTable;
>
>typedef gpointer (*MonoValueHashKeyExtractFunc) (gpointer value);
>
>MonoValueHashTable* mono_value_hash_table_new (GHashFunc hash_func,
>              GEqualFunc key_equal_func,
>              MonoValueHashKeyExtractFunc key_extract) __attribute__ ((visibility ("hidden")));
>
>void
>mono_value_hash_table_destroy (MonoValueHashTable *table) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_value_hash_table_lookup (MonoValueHashTable *table, gconstpointer key) __attribute__ ((visibility ("hidden")));
>
>
>
>void
>mono_value_hash_table_insert (MonoValueHashTable *table,
>     gpointer key, gpointer value) __attribute__ ((visibility ("hidden")));
>
>
># 15 "../../mono/metadata/metadata-internals.h" 2
>
>
>struct _MonoType {
> union {
>  MonoClass *klass;
>  MonoType *type;
>  MonoArrayType *array;
>  MonoMethodSignature *method;
>  MonoGenericParam *generic_param;
>  MonoGenericClass *generic_class;
> } data;
> unsigned int attrs : 16;
> MonoTypeEnum type : 8;
> unsigned int num_mods : 6;
> unsigned int byref : 1;
> unsigned int pinned : 1;
> MonoCustomMod modifiers [0];
>};
># 48 "../../mono/metadata/metadata-internals.h"
>struct _MonoAssemblyName {
> const char *name;
> const char *culture;
> const char *hash_value;
> const mono_byte* public_key;
>
> mono_byte public_key_token [17];
> uint32_t hash_alg;
> uint32_t hash_len;
> uint32_t flags;
> uint16_t major, minor, build, revision, arch;
>};
>
>struct MonoTypeNameParse {
> char *name_space;
> char *name;
> MonoAssemblyName assembly;
> GList *modifiers;
> GPtrArray *type_arguments;
> GList *nested;
>};
>
>struct _MonoAssembly {
># 79 "../../mono/metadata/metadata-internals.h"
> int ref_count;
> char *basedir;
> MonoAssemblyName aname;
> MonoImage *image;
> GSList *friend_assembly_names;
> guint8 friend_assembly_names_inited;
> guint8 in_gac;
> guint8 dynamic;
> guint8 corlib_internal;
> gboolean ref_only;
> guint8 wrap_non_exception_throws;
> guint8 wrap_non_exception_throws_inited;
> guint8 jit_optimizer_disabled;
> guint8 jit_optimizer_disabled_inited;
>
> guint32 ecma:2;
> guint32 aptc:2;
> guint32 fulltrust:2;
> guint32 unmanaged:2;
> guint32 skipverification:2;
>};
>
>typedef struct {
> const char* data;
> guint32 size;
>} MonoStreamHeader;
>
>struct _MonoTableInfo {
> const char *base;
> guint rows : 24;
> guint row_size : 8;
># 121 "../../mono/metadata/metadata-internals.h"
> guint32 size_bitfield;
>};
>
>
>
>typedef struct _MonoDllMap MonoDllMap;
>
>struct _MonoImage {
>
>
>
>
>
>
> int ref_count;
> void *raw_data_handle;
> char *raw_data;
> guint32 raw_data_len;
> guint8 raw_buffer_used : 1;
> guint8 raw_data_allocated : 1;
># 151 "../../mono/metadata/metadata-internals.h"
> guint8 dynamic : 1;
>
>
> guint8 ref_only : 1;
>
>
> guint8 uncompressed_metadata : 1;
>
> guint8 checked_module_cctor : 1;
> guint8 has_module_cctor : 1;
>
> guint8 idx_string_wide : 1;
> guint8 idx_guid_wide : 1;
> guint8 idx_blob_wide : 1;
>
>
> guint8 core_clr_platform_code : 1;
>
> char *name;
> const char *assembly_name;
> const char *module_name;
> char *version;
> gint16 md_version_major, md_version_minor;
> char *guid;
> void *image_info;
> MonoMemPool *mempool;
>
> char *raw_metadata;
>
> MonoStreamHeader heap_strings;
> MonoStreamHeader heap_us;
> MonoStreamHeader heap_blob;
> MonoStreamHeader heap_guid;
> MonoStreamHeader heap_tables;
>
> const char *tables_base;
>
>
> MonoTableInfo tables [(MONO_TABLE_GENERICPARAMCONSTRAINT + 1)];
>
>
>
>
>
>
>
> MonoAssembly **references;
>
> MonoImage **modules;
> guint32 module_count;
> gboolean *modules_loaded;
>
> MonoImage **files;
>
> gpointer aot_module;
>
>
>
>
> MonoAssembly *assembly;
>
>
>
>
> GHashTable *method_cache;
> MonoInternalHashTable class_cache;
>
>
> GHashTable *methodref_cache;
>
>
>
>
> GHashTable *field_cache;
>
>
> GHashTable *typespec_cache;
>
> GHashTable *memberref_signatures;
> GHashTable *helper_signatures;
>
>
> GHashTable *method_signatures;
>
>
>
>
> GHashTable *name_cache;
>
>
>
>
> GHashTable *array_cache;
> GHashTable *ptr_cache;
>
> GHashTable *szarray_cache;
>
> CRITICAL_SECTION szarray_cache_lock;
>
>
>
>
> GHashTable *delegate_begin_invoke_cache;
> GHashTable *delegate_end_invoke_cache;
> GHashTable *delegate_invoke_cache;
> GHashTable *runtime_invoke_cache;
>
>
>
>
> GHashTable *delegate_abstract_invoke_cache;
>
>
>
>
> GHashTable *delegate_bound_static_invoke_cache;
>
>
>
> GHashTable *runtime_invoke_direct_cache;
> GHashTable *runtime_invoke_vcall_cache;
> GHashTable *managed_wrapper_cache;
> GHashTable *native_wrapper_cache;
> GHashTable *native_wrapper_aot_cache;
> GHashTable *remoting_invoke_cache;
> GHashTable *synchronized_cache;
> GHashTable *unbox_wrapper_cache;
> GHashTable *cominterop_invoke_cache;
> GHashTable *cominterop_wrapper_cache;
> GHashTable *thunk_invoke_cache;
>
>
>
>
> GHashTable *ldfld_wrapper_cache;
> GHashTable *ldflda_wrapper_cache;
> GHashTable *stfld_wrapper_cache;
> GHashTable *isinst_cache;
> GHashTable *castclass_cache;
> GHashTable *proxy_isinst_cache;
> GHashTable *rgctx_template_hash;
>
>
> MonoPropertyHash *property_hash;
>
> void *reflection_info;
>
>
>
>
>
> void *user_info;
>
>
> MonoDllMap *dll_map;
>
>
> MonoBitSet *interface_bitset;
>
>
>
> GSList *reflection_info_unregister_classes;
>
>
> GSList *image_sets;
>
>
> MonoClass **var_cache_fast;
> MonoClass **mvar_cache_fast;
> GHashTable *var_cache_slow;
> GHashTable *mvar_cache_slow;
>
>
>
>
>
> CRITICAL_SECTION lock;
>};
># 337 "../../mono/metadata/metadata-internals.h"
>typedef struct {
> int nimages;
> MonoImage **images;
>
> GHashTable *gclass_cache, *ginst_cache, *gmethod_cache, *gsignature_cache;
>
> CRITICAL_SECTION lock;
>
>
>
>
>
> MonoMemPool *mempool;
>} MonoImageSet;
>
>enum {
> MONO_SECTION_TEXT,
> MONO_SECTION_RSRC,
> MONO_SECTION_RELOC,
> MONO_SECTION_MAX
>};
>
>typedef struct {
> GHashTable *hash;
> char *data;
> guint32 alloc_size;
> guint32 index;
> guint32 offset;
>} MonoDynamicStream;
>
>typedef struct {
> guint32 alloc_rows;
> guint32 rows;
> guint8 row_size;
> guint8 columns;
> guint32 next_idx;
> guint32 *values;
>} MonoDynamicTable;
>
>struct _MonoDynamicAssembly {
> MonoAssembly assembly;
> char *strong_name;
> guint32 strong_name_size;
> guint8 run;
> guint8 save;
> MonoDomain *domain;
>};
>
>struct _MonoDynamicImage {
> MonoImage image;
> guint32 meta_size;
> guint32 text_rva;
> guint32 metadata_rva;
> guint32 image_base;
> guint32 cli_header_offset;
> guint32 iat_offset;
> guint32 idt_offset;
> guint32 ilt_offset;
> guint32 imp_names_offset;
> struct {
>  guint32 rva;
>  guint32 size;
>  guint32 offset;
>  guint32 attrs;
> } sections [MONO_SECTION_MAX];
> GHashTable *typespec;
> GHashTable *typeref;
> GHashTable *handleref;
> MonoGHashTable *handleref_managed;
> MonoGHashTable *tokens;
> GHashTable *blob_cache;
> GHashTable *standalonesig_cache;
> GList *array_methods;
> GPtrArray *gen_params;
> MonoGHashTable *token_fixups;
> GHashTable *method_to_table_idx;
> GHashTable *field_to_table_idx;
> GHashTable *method_aux_hash;
> GHashTable *vararg_aux_hash;
> MonoGHashTable *generic_def_objects;
> MonoGHashTable *methodspec;
> gboolean run;
> gboolean save;
> gboolean initial_image;
> guint32 pe_kind, machine;
> char *strong_name;
> guint32 strong_name_size;
> char *win32_res;
> guint32 win32_res_size;
> guint8 *public_key;
> int public_key_len;
> MonoDynamicStream sheap;
> MonoDynamicStream code;
> MonoDynamicStream resources;
> MonoDynamicStream us;
> MonoDynamicStream blob;
> MonoDynamicStream tstream;
> MonoDynamicStream guid;
> MonoDynamicTable tables [(MONO_TABLE_GENERICPARAMCONSTRAINT + 1)];
> MonoClass *wrappers_type;
>};
>
>
>typedef struct _MonoAssemblyBindingInfo {
> char *name;
> char *culture;
> guchar public_key_token [17];
> int major;
> int minor;
> AssemblyVersionSet old_version_bottom;
> AssemblyVersionSet old_version_top;
> AssemblyVersionSet new_version;
> guint has_old_version_bottom : 1;
> guint has_old_version_top : 1;
> guint has_new_version : 1;
> guint is_valid : 1;
> gint32 domain_id;
>} MonoAssemblyBindingInfo;
>
>struct _MonoMethodHeader {
> const unsigned char *code;
>
>
>
> guint32 code_size;
>
> guint16 max_stack : 15;
> unsigned int is_transient: 1;
> unsigned int num_clauses : 15;
>
> unsigned int init_locals : 1;
> guint16 num_locals;
> MonoExceptionClause *clauses;
> MonoType *locals [0];
>};
>
>typedef struct {
> guint32 code_size;
> gboolean has_clauses;
>} MonoMethodHeaderSummary;
>
>
>
>struct _MonoMethodSignature {
> MonoType *ret;
>
>
>
>
>
> guint16 param_count;
> gint16 sentinelpos;
> unsigned int generic_param_count : 16;
>
> unsigned int call_convention : 6;
> unsigned int hasthis : 1;
> unsigned int explicit_this : 1;
> unsigned int pinvoke : 1;
> unsigned int is_inflated : 1;
> unsigned int has_type_parameters : 1;
> MonoType *params [0];
>};
>
>
>
>
>guint mono_aligned_addr_hash (gconstpointer ptr) __attribute__ ((visibility ("hidden")));
>
>void
>mono_image_check_for_module_cctor (MonoImage *image) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_image_alloc (MonoImage *image, guint size) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_image_alloc0 (MonoImage *image, guint size) __attribute__ ((visibility ("hidden")));
>
>
>
>char*
>mono_image_strdup (MonoImage *image, const char *s) __attribute__ ((visibility ("hidden")));
>
>GList*
>g_list_prepend_image (MonoImage *image, GList *list, gpointer data) __attribute__ ((visibility ("hidden")));
>
>GSList*
>g_slist_append_image (MonoImage *image, GSList *list, gpointer data) __attribute__ ((visibility ("hidden")));
>
>void
>mono_image_lock (MonoImage *image) __attribute__ ((visibility ("hidden")));
>
>void
>mono_image_unlock (MonoImage *image) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_image_property_lookup (MonoImage *image, gpointer subject, guint32 property) __attribute__ ((visibility ("hidden")));
>
>void
>mono_image_property_insert (MonoImage *image, gpointer subject, guint32 property, gpointer value) __attribute__ ((visibility ("hidden")));
>
>void
>mono_image_property_remove (MonoImage *image, gpointer subject) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_image_close_except_pools (MonoImage *image) __attribute__ ((visibility ("hidden")));
>
>void
>mono_image_close_finish (MonoImage *image) __attribute__ ((visibility ("hidden")));
>
>typedef void (*MonoImageUnloadFunc) (MonoImage *image, gpointer user_data);
>
>void
>mono_install_image_unload_hook (MonoImageUnloadFunc func, gpointer user_data) __attribute__ ((visibility ("hidden")));
>
>void
>mono_remove_image_unload_hook (MonoImageUnloadFunc func, gpointer user_data) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_image_set_alloc (MonoImageSet *set, guint size) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_image_set_alloc0 (MonoImageSet *set, guint size) __attribute__ ((visibility ("hidden")));
>
>char*
>mono_image_set_strdup (MonoImageSet *set, const char *s) __attribute__ ((visibility ("hidden")));
>
>
>
>MonoType*
>mono_metadata_get_shared_type (MonoType *type) __attribute__ ((visibility ("hidden")));
>
>GSList*
>mono_metadata_clean_for_image (MonoImage *image) __attribute__ ((visibility ("hidden")));
>
>void
>mono_metadata_clean_generic_classes_for_image (MonoImage *image) __attribute__ ((visibility ("hidden")));
>
>void
>mono_metadata_cleanup (void);
>
>const char * mono_meta_table_name (int table) __attribute__ ((visibility ("hidden")));
>void mono_metadata_compute_table_bases (MonoImage *meta) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_metadata_interfaces_from_typedef_full (MonoImage *image,
>            guint32 table_index,
>            MonoClass ***interfaces,
>            guint *count,
>            gboolean heap_alloc_result,
>            MonoGenericContext *context) __attribute__ ((visibility ("hidden")));
>
>MonoArrayType *
>mono_metadata_parse_array_full (MonoImage *image,
>          MonoGenericContainer *container,
>          const char *ptr,
>          const char **rptr) __attribute__ ((visibility ("hidden")));
>
>MonoType *
>mono_metadata_parse_type_full (MonoImage *image,
>          MonoGenericContainer *container,
>          MonoParseTypeMode mode,
>          short opt_attrs,
>          const char *ptr,
>          const char **rptr);
>
>MonoMethodSignature *
>mono_metadata_parse_signature_full (MonoImage *image,
>          MonoGenericContainer *generic_container,
>          guint32 token) __attribute__ ((visibility ("hidden")));
>
>MonoMethodSignature *
>mono_metadata_parse_method_signature_full (MonoImage *image,
>          MonoGenericContainer *generic_container,
>          int def,
>          const char *ptr,
>          const char **rptr);
>
>MonoMethodHeader *
>mono_metadata_parse_mh_full (MonoImage *image,
>          MonoGenericContainer *container,
>          const char *ptr);
>
>gboolean
>mono_method_get_header_summary (MonoMethod *method, MonoMethodHeaderSummary *summary) __attribute__ ((visibility ("hidden")));
>
>int* mono_metadata_get_param_attrs (MonoImage *m, int def, int param_count) __attribute__ ((visibility ("hidden")));
>gboolean mono_metadata_method_has_param_attrs (MonoImage *m, int def) __attribute__ ((visibility ("hidden")));
>
>guint
>mono_metadata_generic_context_hash (const MonoGenericContext *context) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_metadata_generic_context_equal (const MonoGenericContext *g1,
>          const MonoGenericContext *g2) __attribute__ ((visibility ("hidden")));
>
>MonoGenericInst *
>mono_metadata_parse_generic_inst (MonoImage *image,
>          MonoGenericContainer *container,
>          int count,
>          const char *ptr,
>          const char **rptr) __attribute__ ((visibility ("hidden")));
>
>MonoGenericInst *
>mono_metadata_get_generic_inst (int type_argc,
>          MonoType **type_argv) __attribute__ ((visibility ("hidden")));
>
>MonoGenericClass *
>mono_metadata_lookup_generic_class (MonoClass *gclass,
>          MonoGenericInst *inst,
>          gboolean is_dynamic) __attribute__ ((visibility ("hidden")));
>
>MonoGenericInst * mono_metadata_inflate_generic_inst (MonoGenericInst *ginst, MonoGenericContext *context, MonoError *error) __attribute__ ((visibility ("hidden")));
>
>void mono_dynamic_stream_reset (MonoDynamicStream* stream) __attribute__ ((visibility ("hidden")));
>void mono_assembly_addref (MonoAssembly *assembly) __attribute__ ((visibility ("hidden")));
>void mono_assembly_load_friends (MonoAssembly* ass) __attribute__ ((visibility ("hidden")));
>gboolean mono_assembly_has_skip_verification (MonoAssembly* ass) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_assembly_close_except_image_pools (MonoAssembly *assembly) __attribute__ ((visibility ("hidden")));
>void mono_assembly_close_finish (MonoAssembly *assembly) __attribute__ ((visibility ("hidden")));
>
>
>gboolean mono_public_tokens_are_equal (const unsigned char *pubt1, const unsigned char *pubt2) __attribute__ ((visibility ("hidden")));
>
>void mono_config_parse_publisher_policy (const char *filename, MonoAssemblyBindingInfo *binding_info) __attribute__ ((visibility ("hidden")));
>void mono_config_parse_assembly_bindings (const char *filename, int major, int minor, void *user_data,
>       void (*infocb)(MonoAssemblyBindingInfo *info, void *user_data)) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_assembly_name_parse_full (const char *name,
>           MonoAssemblyName *aname,
>           gboolean save_public_key,
>           gboolean *is_version_defined,
>        gboolean *is_token_defined) __attribute__ ((visibility ("hidden")));
>
>guint32 mono_metadata_get_generic_param_row (MonoImage *image, guint32 token, guint32 *owner);
>
>void mono_unload_interface_ids (MonoBitSet *bitset) __attribute__ ((visibility ("hidden")));
>
>
>MonoType *mono_metadata_type_dup (MonoImage *image, const MonoType *original) __attribute__ ((visibility ("hidden")));
>MonoMethodSignature *mono_metadata_signature_dup_full (MonoImage *image,MonoMethodSignature *sig) __attribute__ ((visibility ("hidden")));
>MonoMethodSignature *mono_metadata_signature_dup_mempool (MonoMemPool *mp, MonoMethodSignature *sig) __attribute__ ((visibility ("hidden")));
>
>MonoGenericInst *
>mono_get_shared_generic_inst (MonoGenericContainer *container) __attribute__ ((visibility ("hidden")));
>
>int
>mono_type_stack_size_internal (MonoType *t, int *align, gboolean allow_open) __attribute__ ((visibility ("hidden")));
>
>void mono_type_get_desc (GString *res, MonoType *type, mono_bool include_namespace);
>
>gboolean
>mono_metadata_type_equal_full (MonoType *t1, MonoType *t2, gboolean signature_only) __attribute__ ((visibility ("hidden")));
>
>MonoMarshalSpec *
>mono_metadata_parse_marshal_spec_full (MonoImage *image, const char *ptr) __attribute__ ((visibility ("hidden")));
>
>guint mono_metadata_generic_inst_hash (gconstpointer data) __attribute__ ((visibility ("hidden")));
>gboolean mono_metadata_generic_inst_equal (gconstpointer ka, gconstpointer kb) __attribute__ ((visibility ("hidden")));
>
>void
>mono_metadata_field_info_with_mempool (
>       MonoImage *meta,
>          guint32 table_index,
>          guint32 *offset,
>          guint32 *rva,
>          MonoMarshalSpec **marshal_spec);
>
>MonoClassField*
>mono_metadata_get_corresponding_field_from_generic_type_definition (MonoClassField *field) __attribute__ ((visibility ("hidden")));
>
>MonoEvent*
>mono_metadata_get_corresponding_event_from_generic_type_definition (MonoEvent *event) __attribute__ ((visibility ("hidden")));
>
>MonoProperty*
>mono_metadata_get_corresponding_property_from_generic_type_definition (MonoProperty *property) __attribute__ ((visibility ("hidden")));
>
>guint32
>mono_metadata_signature_size (MonoMethodSignature *sig) __attribute__ ((visibility ("hidden")));
>
>guint mono_metadata_str_hash (gconstpointer v1) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_image_load_pe_data (MonoImage *image) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_image_load_cli_data (MonoImage *image) __attribute__ ((visibility ("hidden")));
>
>void mono_image_load_names (MonoImage *image) __attribute__ ((visibility ("hidden")));
>
>MonoImage *mono_image_open_raw (const char *fname, MonoImageOpenStatus *status) __attribute__ ((visibility ("hidden")));
>
>MonoException *mono_get_exception_field_access_msg (const char *msg) __attribute__ ((visibility ("hidden")));
>
>MonoException *mono_get_exception_method_access_msg (const char *msg) __attribute__ ((visibility ("hidden")));
>
>MonoMethod* method_from_method_def_or_ref (MonoImage *m, guint32 tok, MonoGenericContext *context) __attribute__ ((visibility ("hidden")));
># 8 "../../mono/metadata/class-internals.h" 2
># 18 "../../mono/metadata/class-internals.h"
>extern gboolean mono_print_vtable;
>
>typedef void (*MonoStackWalkImpl) (MonoStackWalk func, gboolean do_il_offset, gpointer user_data);
>
>typedef struct _MonoMethodWrapper MonoMethodWrapper;
>typedef struct _MonoMethodInflated MonoMethodInflated;
>typedef struct _MonoMethodPInvoke MonoMethodPInvoke;
># 33 "../../mono/metadata/class-internals.h"
>typedef enum {
>
># 1 "../../mono/metadata/wrapper-types.h" 1
>
>
>
>
>
>MONO_WRAPPER_NONE,
>MONO_WRAPPER_DELEGATE_INVOKE,
>MONO_WRAPPER_DELEGATE_BEGIN_INVOKE,
>MONO_WRAPPER_DELEGATE_END_INVOKE,
>MONO_WRAPPER_RUNTIME_INVOKE,
>MONO_WRAPPER_NATIVE_TO_MANAGED,
>MONO_WRAPPER_MANAGED_TO_NATIVE,
>MONO_WRAPPER_MANAGED_TO_MANAGED,
>MONO_WRAPPER_REMOTING_INVOKE,
>MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK,
>MONO_WRAPPER_XDOMAIN_INVOKE,
>MONO_WRAPPER_XDOMAIN_DISPATCH,
>MONO_WRAPPER_LDFLD,
>MONO_WRAPPER_STFLD,
>MONO_WRAPPER_LDFLD_REMOTE,
>MONO_WRAPPER_STFLD_REMOTE,
>MONO_WRAPPER_SYNCHRONIZED,
>MONO_WRAPPER_DYNAMIC_METHOD,
>MONO_WRAPPER_ISINST,
>MONO_WRAPPER_CASTCLASS,
>MONO_WRAPPER_PROXY_ISINST,
>MONO_WRAPPER_STELEMREF,
>MONO_WRAPPER_UNBOX,
>MONO_WRAPPER_LDFLDA,
>MONO_WRAPPER_WRITE_BARRIER,
>MONO_WRAPPER_UNKNOWN,
>MONO_WRAPPER_COMINTEROP_INVOKE,
>MONO_WRAPPER_COMINTEROP,
>MONO_WRAPPER_ALLOC,
># 36 "../../mono/metadata/class-internals.h" 2
>
> MONO_WRAPPER_NUM
>} MonoWrapperType;
>
>typedef enum {
> MONO_TYPE_NAME_FORMAT_IL,
> MONO_TYPE_NAME_FORMAT_REFLECTION,
> MONO_TYPE_NAME_FORMAT_FULL_NAME,
> MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
>} MonoTypeNameFormat;
>
>typedef enum {
> MONO_REMOTING_TARGET_UNKNOWN,
> MONO_REMOTING_TARGET_APPDOMAIN,
> MONO_REMOTING_TARGET_COMINTEROP
>} MonoRemotingTarget;
>
>
>
>struct _MonoMethod {
> guint16 flags;
> guint16 iflags;
> guint32 token;
> MonoClass *klass;
> MonoMethodSignature *signature;
>
> const char *name;
>
> unsigned int inline_info:1;
> unsigned int inline_failure:1;
> unsigned int wrapper_type:5;
> unsigned int string_ctor:1;
> unsigned int save_lmf:1;
> unsigned int dynamic:1;
> unsigned int sre_method:1;
> unsigned int is_generic:1;
> unsigned int is_inflated:1;
> unsigned int skip_visibility:1;
> unsigned int verification_success:1;
>
> unsigned int is_mb_open : 1;
> signed int slot : 16;
>
>
>
>
>
>};
>
>struct _MonoMethodWrapper {
> MonoMethod method;
> MonoMethodHeader *header;
> void *method_data;
>};
>
>struct _MonoMethodPInvoke {
> MonoMethod method;
> gpointer addr;
>
> guint16 piflags;
> guint16 implmap_idx;
>};
>
>
>
>
>
>
>typedef struct MonoFieldDefaultValue {
>
>
>
>
>
>
> const char *data;
>
>
> MonoTypeEnum def_type;
>} MonoFieldDefaultValue;
>
>
>
>
>
>
>
>struct _MonoClassField {
>
> MonoType *type;
>
> const char *name;
>
>
> MonoClass *parent;
># 139 "../../mono/metadata/class-internals.h"
> int offset;
>};
># 151 "../../mono/metadata/class-internals.h"
>typedef struct {
> MonoClassField *field;
> guint32 offset;
> MonoMarshalSpec *mspec;
>} MonoMarshalField;
>
>typedef struct {
> guint32 native_size, min_align;
> guint32 num_fields;
> MonoMethod *ptr_to_str;
> MonoMethod *str_to_ptr;
> MonoMarshalField fields [0];
>} MonoMarshalType;
>
>
>
>struct _MonoProperty {
> MonoClass *parent;
> const char *name;
> MonoMethod *get;
> MonoMethod *set;
> guint32 attrs;
>};
>
>struct _MonoEvent {
> MonoClass *parent;
> const char *name;
> MonoMethod *add;
> MonoMethod *remove;
> MonoMethod *raise;
>
> MonoMethod **other;
>
> guint32 attrs;
>};
>
>
>enum {
> MONO_EXCEPTION_NONE = 0,
> MONO_EXCEPTION_SECURITY_LINKDEMAND = 1,
> MONO_EXCEPTION_SECURITY_INHERITANCEDEMAND = 2,
> MONO_EXCEPTION_INVALID_PROGRAM = 3,
> MONO_EXCEPTION_UNVERIFIABLE_IL = 4,
> MONO_EXCEPTION_MISSING_METHOD = 5,
> MONO_EXCEPTION_MISSING_FIELD = 6,
> MONO_EXCEPTION_TYPE_LOAD = 7,
> MONO_EXCEPTION_FILE_NOT_FOUND = 8,
> MONO_EXCEPTION_METHOD_ACCESS = 9,
> MONO_EXCEPTION_FIELD_ACCESS = 10,
> MONO_EXCEPTION_GENERIC_SHARING_FAILED = 11,
> MONO_EXCEPTION_BAD_IMAGE = 12,
> MONO_EXCEPTION_OBJECT_SUPPLIED = 13,
> MONO_EXCEPTION_OUT_OF_MEMORY = 14
>
>};
>
>
>
>
>typedef struct {
> guint16 max_domain;
>
> MonoVTable *domain_vtables [0];
>} MonoClassRuntimeInfo;
>
>
>
>enum {
> MONO_RGCTX_INFO_STATIC_DATA,
> MONO_RGCTX_INFO_KLASS,
> MONO_RGCTX_INFO_VTABLE,
> MONO_RGCTX_INFO_TYPE,
> MONO_RGCTX_INFO_REFLECTION_TYPE,
> MONO_RGCTX_INFO_METHOD,
> MONO_RGCTX_INFO_GENERIC_METHOD_CODE,
> MONO_RGCTX_INFO_CLASS_FIELD,
> MONO_RGCTX_INFO_METHOD_RGCTX,
> MONO_RGCTX_INFO_METHOD_CONTEXT,
> MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK,
> MONO_RGCTX_INFO_METHOD_DELEGATE_CODE,
> MONO_RGCTX_INFO_CAST_CACHE
>};
>
>typedef struct _MonoRuntimeGenericContextOtherInfoTemplate {
> int info_type;
> gpointer data;
> struct _MonoRuntimeGenericContextOtherInfoTemplate *next;
>} MonoRuntimeGenericContextOtherInfoTemplate;
>
>typedef struct {
> MonoClass *next_subclass;
> MonoRuntimeGenericContextOtherInfoTemplate *other_infos;
> GSList *method_templates;
>} MonoRuntimeGenericContextTemplate;
>
>typedef struct {
> MonoVTable *class_vtable;
> MonoGenericInst *method_inst;
> gpointer infos [0];
>} MonoMethodRuntimeGenericContext;
># 267 "../../mono/metadata/class-internals.h"
>typedef struct {
> struct {
>
>
>
>  guint32 first, count;
>
> } property, event;
>
>
> MonoProperty *properties;
>
>
> MonoEvent *events;
>
> guint32 declsec_flags;
>
>
>
> MonoFieldDefaultValue *field_def_values;
> MonoFieldDefaultValue *prop_def_values;
>
> GList *nested_classes;
>} MonoClassExt;
>
>struct _MonoClass {
>
> MonoClass *element_class;
>
> MonoClass *cast_class;
>
>
> MonoClass **supertypes;
> guint16 idepth;
>
>
> guint8 rank;
>
> int instance_size;
>
> guint inited : 1;
>
> guint init_pending : 1;
># 319 "../../mono/metadata/class-internals.h"
> guint size_inited : 1;
> guint valuetype : 1;
> guint enumtype : 1;
> guint blittable : 1;
> guint unicode : 1;
> guint wastypebuilder : 1;
>
> guint8 min_align;
>
> guint packing_size : 4;
>
>
> guint ghcimpl : 1;
> guint has_finalize : 1;
> guint marshalbyref : 1;
> guint contextbound : 1;
> guint delegate : 1;
> guint gc_descr_inited : 1;
> guint has_cctor : 1;
> guint has_references : 1;
>
> guint has_static_refs : 1;
> guint no_special_static_fields : 1;
>
>
>
>
>
> guint is_com_object : 1;
> guint nested_classes_inited : 1;
> guint interfaces_inited : 1;
> guint simd_type : 1;
> guint is_generic : 1;
> guint is_inflated : 1;
>
> guint has_finalize_inited : 1;
>
> guint8 exception_type;
>
>
>
>
>
> MonoClass *parent;
> MonoClass *nested_in;
>
> MonoImage *image;
> const char *name;
> const char *name_space;
>
> guint32 type_token;
> int vtable_size;
>
> guint16 interface_count;
> guint16 interface_id;
> guint16 max_interface_id;
>
> guint16 interface_offsets_count;
> MonoClass **interfaces_packed;
> guint16 *interface_offsets_packed;
>
>
>
>
> guint8 *interface_bitmap;
>
> MonoClass **interfaces;
>
> union {
>  int class_size;
>  int element_size;
>  int generic_param_token;
> } sizes;
>
>
>
>
> guint32 flags;
> struct {
>
>
>
>  guint32 first, count;
>
> } field, method;
>
>
> guint32 ref_info_handle;
>
>
> MonoMarshalType *marshal_info;
>
>
>
>
> MonoClassField *fields;
>
> MonoMethod **methods;
>
>
> MonoType this_arg;
> MonoType byval_arg;
>
> MonoGenericClass *generic_class;
> MonoGenericContainer *generic_container;
>
> void *gc_descr;
>
> MonoClassRuntimeInfo *runtime_info;
>
>
> MonoClass *next_class_cache;
>
>
> MonoMethod **vtable;
>
>
> MonoClassExt *ext;
>};
># 449 "../../mono/metadata/class-internals.h"
>int mono_class_interface_offset (MonoClass *klass, MonoClass *itf);
>int mono_class_interface_offset_with_variance (MonoClass *klass, MonoClass *itf, gboolean *non_exact_match) __attribute__ ((visibility ("hidden")));
>
>typedef gpointer MonoRuntimeGenericContext;
>
>
>struct MonoVTable {
> MonoClass *klass;
>
>
>
>
> void *gc_descr;
> MonoDomain *domain;
>        gpointer data;
>        gpointer type;
> guint8 *interface_bitmap;
> guint16 max_interface_id;
> guint8 rank;
> guint remote : 1;
> guint initialized : 1;
> guint init_failed : 1;
> guint32 imt_collisions_bitmap;
> MonoRuntimeGenericContext *runtime_generic_context;
>
> gpointer vtable [0];
>};
># 491 "../../mono/metadata/class-internals.h"
>struct _MonoGenericInst {
>
> guint id;
>
> guint type_argc : 22;
> guint is_open : 1;
> MonoType *type_argv [0];
>};
># 508 "../../mono/metadata/class-internals.h"
>struct _MonoGenericContext {
>
> MonoGenericInst *class_inst;
>
> MonoGenericInst *method_inst;
>};
>
>
>
>
>struct _MonoMethodInflated {
> union {
>  MonoMethod method;
>  MonoMethodPInvoke pinvoke;
> } method;
> MonoMethodHeader *header;
> MonoMethod *declaring;
> MonoGenericContext context;
>};
>
>
>
>
>struct _MonoGenericClass {
> MonoClass *container_class;
> MonoGenericContext context;
> guint is_dynamic : 1;
> guint is_tb_open : 1;
> MonoClass *cached_class;
>
>
>
>
>
>
> MonoImageSet *owner;
>};
>
>
>
>
>
>struct _MonoDynamicGenericClass {
> MonoGenericClass generic_class;
> int count_fields;
> MonoClassField *fields;
> guint initialized;
>
> MonoType **field_generic_types;
>
> MonoObject **field_objects;
>};
>
>
>
>
>struct _MonoGenericParam {
> MonoGenericContainer *owner;
> guint16 num;
>
>
>
>
>
>
> MonoImage *image;
>};
>
>
>typedef struct {
> MonoClass *pklass;
> const char *name;
> guint16 flags;
> guint32 token;
> MonoClass** constraints;
>} MonoGenericParamInfo;
>
>typedef struct {
> MonoGenericParam param;
> MonoGenericParamInfo info;
>} MonoGenericParamFull;
>
>
>
>
>
>
>struct _MonoGenericContainer {
> MonoGenericContext context;
>
>
> MonoGenericContainer *parent;
>
> union {
>  MonoClass *klass;
>  MonoMethod *method;
> } owner;
> int type_argc : 31;
>
>
> int is_method : 1;
>
> MonoGenericParamFull *type_params;
>
>
>
>
>
> MonoImage *image;
>};
># 634 "../../mono/metadata/class-internals.h"
>typedef struct MonoCachedClassInfo {
> guint32 vtable_size;
> guint has_finalize : 1;
> guint ghcimpl : 1;
> guint has_cctor : 1;
> guint has_nested_classes : 1;
> guint blittable : 1;
> guint has_references : 1;
> guint has_static_refs : 1;
> guint no_special_static_fields : 1;
> guint is_generic_container : 1;
> guint32 cctor_token;
> MonoImage *finalize_image;
> guint32 finalize_token;
> guint32 instance_size;
> guint32 class_size;
> guint32 packing_size;
> guint32 min_align;
>} MonoCachedClassInfo;
>
>typedef struct {
> const char *name;
> gconstpointer func;
> gconstpointer wrapper;
> gconstpointer trampoline;
> MonoMethodSignature *sig;
>} MonoJitICallInfo;
>
>typedef struct {
> guint8 exception_type;
> char *class_name;
> char *assembly_name;
> MonoClass *klass;
> const char *member_name;
> gboolean ref_only;
> char *msg;
>} MonoLoaderError;
>
>
>
>typedef struct {
> MonoVTable *default_vtable;
> MonoVTable *xdomain_vtable;
> MonoClass *proxy_class;
> char* proxy_class_name;
> uint32_t interface_count;
> MonoClass *interfaces [0];
>} MonoRemoteClass;
>
>
>
>MonoRemoteClass*
>mono_remote_class (MonoDomain *domain, MonoString *class_name, MonoClass *proxy_class) __attribute__ ((visibility ("hidden")));
>
>typedef struct {
> gulong new_object_count;
> gulong initialized_class_count;
> gulong generic_vtable_count;
> gulong used_class_count;
> gulong method_count;
> gulong class_vtable_size;
> gulong class_static_data_size;
> gulong generic_instance_count;
> gulong generic_class_count;
> gulong inflated_method_count;
> gulong inflated_method_count_2;
> gulong inflated_type_count;
> gulong generics_metadata_size;
> gulong dynamic_code_alloc_count;
> gulong dynamic_code_bytes_count;
> gulong dynamic_code_frees_count;
> gulong delegate_creations;
> gulong imt_tables_size;
> gulong imt_number_of_tables;
> gulong imt_number_of_methods;
> gulong imt_used_slots;
> gulong imt_slots_with_collisions;
> gulong imt_max_collisions_in_slot;
> gulong imt_method_count_when_max_collisions;
> gulong imt_thunks_size;
> gulong jit_info_table_insert_count;
> gulong jit_info_table_remove_count;
> gulong jit_info_table_lookup_count;
> gulong hazardous_pointer_count;
> gulong generics_sharable_methods;
> gulong generics_unsharable_methods;
> gulong generics_shared_methods;
> gulong minor_gc_count;
> gulong major_gc_count;
> gulong minor_gc_time_usecs;
> gulong major_gc_time_usecs;
> gboolean enabled;
>} MonoStats;
>
>
>
>
>
>
>
>typedef struct {
>
> guint32 jit_methods;
> guint32 jit_bytes;
> guint32 jit_time;
> guint32 jit_failures;
>
> guint32 exceptions_thrown;
> guint32 exceptions_filters;
> guint32 exceptions_finallys;
> guint32 exceptions_depth;
> guint32 aspnet_requests_queued;
> guint32 aspnet_requests;
>
> guint32 gc_collections0;
> guint32 gc_collections1;
> guint32 gc_collections2;
> guint32 gc_promotions0;
> guint32 gc_promotions1;
> guint32 gc_promotion_finalizers;
> guint32 gc_gen0size;
> guint32 gc_gen1size;
> guint32 gc_gen2size;
> guint32 gc_lossize;
> guint32 gc_fin_survivors;
> guint32 gc_num_handles;
> guint32 gc_allocated;
> guint32 gc_induced;
> guint32 gc_time;
> guint32 gc_total_bytes;
> guint32 gc_committed_bytes;
> guint32 gc_reserved_bytes;
> guint32 gc_num_pinned;
> guint32 gc_sync_blocks;
>
> guint32 remoting_calls;
> guint32 remoting_channels;
> guint32 remoting_proxies;
> guint32 remoting_classes;
> guint32 remoting_objects;
> guint32 remoting_contexts;
>
> guint32 loader_classes;
> guint32 loader_total_classes;
> guint32 loader_appdomains;
> guint32 loader_total_appdomains;
> guint32 loader_assemblies;
> guint32 loader_total_assemblies;
> guint32 loader_failures;
> guint32 loader_bytes;
> guint32 loader_appdomains_uloaded;
>
> guint32 thread_contentions;
> guint32 thread_queue_len;
> guint32 thread_queue_max;
> guint32 thread_num_logical;
> guint32 thread_num_physical;
> guint32 thread_cur_recognized;
> guint32 thread_num_recognized;
>
> guint32 interop_num_ccw;
> guint32 interop_num_stubs;
> guint32 interop_num_marshals;
>
> guint32 security_num_checks;
> guint32 security_num_link_checks;
> guint32 security_time;
> guint32 security_depth;
> guint32 unused;
>
> guint64 threadpool_workitems;
> guint64 threadpool_ioworkitems;
> guint threadpool_threads;
> guint threadpool_iothreads;
>} MonoPerfCounters;
>
>extern MonoPerfCounters *mono_perfcounters __attribute__ ((visibility ("hidden")));
>
>void mono_perfcounters_init (void);
>
>
>
>
>
>
>typedef struct {
> MonoObject base;
> void *handle;
>} MonoSafeHandle;
>
>
>
>
>typedef struct {
> MonoObject *wrapper;
> void *handle;
>} MonoHandleRef;
>
>enum {
> MONO_GENERIC_SHARING_NONE,
> MONO_GENERIC_SHARING_COLLECTIONS,
> MONO_GENERIC_SHARING_CORLIB,
> MONO_GENERIC_SHARING_ALL
>};
>
>
>
>
>enum {
> MONO_GENERIC_CONTEXT_USED_CLASS = 1,
> MONO_GENERIC_CONTEXT_USED_METHOD = 2
>};
>
>
>
>extern MonoStats mono_stats __attribute__ ((visibility ("hidden")));
>
>typedef gpointer (*MonoTrampoline) (MonoMethod *method);
>typedef gpointer (*MonoJumpTrampoline) (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper);
>typedef gpointer (*MonoRemotingTrampoline) (MonoDomain *domain, MonoMethod *method, MonoRemotingTarget target);
>typedef gpointer (*MonoDelegateTrampoline) (MonoClass *klass);
>
>typedef gpointer (*MonoLookupDynamicToken) (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context);
>
>typedef gboolean (*MonoGetCachedClassInfo) (MonoClass *klass, MonoCachedClassInfo *res);
>
>typedef gboolean (*MonoGetClassFromName) (MonoImage *image, const char *name_space, const char *name, MonoClass **res);
>
>void
>mono_classes_init (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_classes_cleanup (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_layout_fields (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_setup_interface_offsets (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_setup_vtable_general (MonoClass *klass, MonoMethod **overrides, int onum, GList *in_setup) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_setup_vtable (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_setup_methods (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_setup_mono_type (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_setup_parent (MonoClass *klass, MonoClass *parent) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_setup_supertypes (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_class_get_method_by_index (MonoClass *class, int index) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_class_get_inflated_method (MonoClass *class, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_class_get_vtable_entry (MonoClass *class, int offset) __attribute__ ((visibility ("hidden")));
>
>GPtrArray*
>mono_class_get_implemented_interfaces (MonoClass *klass, MonoError *error) __attribute__ ((visibility ("hidden")));
>
>int
>mono_class_get_vtable_size (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_is_open_constructed_type (MonoType *t) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_get_overrides_full (MonoImage *image, guint32 type_token, MonoMethod ***overrides, gint32 *num_overrides,
>          MonoGenericContext *generic_context) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_class_get_cctor (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_class_get_finalizer (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_needs_cctor_run (MonoClass *klass, MonoMethod *caller) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_field_is_special_static (MonoClassField *field) __attribute__ ((visibility ("hidden")));
>
>guint32
>mono_class_field_get_special_static_type (MonoClassField *field) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_has_special_static_fields (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>const char*
>mono_class_get_field_default_value (MonoClassField *field, MonoTypeEnum *def_type) __attribute__ ((visibility ("hidden")));
>
>const char*
>mono_class_get_property_default_value (MonoProperty *property, MonoTypeEnum *def_type) __attribute__ ((visibility ("hidden")));
>
>void
>mono_install_trampoline (MonoTrampoline func) __attribute__ ((visibility ("hidden")));
>
>void
>mono_install_jump_trampoline (MonoJumpTrampoline func) __attribute__ ((visibility ("hidden")));
>
>void
>mono_install_remoting_trampoline (MonoRemotingTrampoline func) __attribute__ ((visibility ("hidden")));
>
>void
>mono_install_delegate_trampoline (MonoDelegateTrampoline func) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_lookup_dynamic_token (MonoImage *image, guint32 token, MonoGenericContext *context) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_lookup_dynamic_token_class (MonoImage *image, guint32 token, gboolean check_token, MonoClass **handle_class, MonoGenericContext *context) __attribute__ ((visibility ("hidden")));
>
>void
>mono_install_lookup_dynamic_token (MonoLookupDynamicToken func) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_runtime_create_jump_trampoline (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_runtime_create_delegate_trampoline (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_install_get_cached_class_info (MonoGetCachedClassInfo func) __attribute__ ((visibility ("hidden")));
>
>void
>mono_install_get_class_from_name (MonoGetClassFromName func) __attribute__ ((visibility ("hidden")));
>
>MonoGenericContext*
>mono_class_get_context (MonoClass *class) __attribute__ ((visibility ("hidden")));
>
>MonoMethodSignature*
>mono_method_signature_checked (MonoMethod *m, MonoError *err) __attribute__ ((visibility ("hidden")));
>
>MonoGenericContext*
>mono_method_get_context_general (MonoMethod *method, gboolean uninflated) __attribute__ ((visibility ("hidden")));
>
>MonoGenericContext*
>mono_method_get_context (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>
>MonoGenericContainer*
>mono_method_get_generic_container (MonoMethod *method);
>
>MonoGenericContext*
>mono_generic_class_get_context (MonoGenericClass *gclass) __attribute__ ((visibility ("hidden")));
>
>MonoClass*
>mono_generic_class_get_class (MonoGenericClass *gclass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_method_set_generic_container (MonoMethod *method, MonoGenericContainer* container) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_class_inflate_generic_method_full (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_class_inflate_generic_method_full_checked (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context, MonoError *error) __attribute__ ((visibility ("hidden")));
>
>MonoMethodInflated*
>mono_method_inflated_lookup (MonoMethodInflated* method, gboolean cache) __attribute__ ((visibility ("hidden")));
>
>MonoMethodSignature *
>mono_metadata_get_inflated_signature (MonoMethodSignature *sig, MonoGenericContext *context);
>
>MonoType*
>mono_class_inflate_generic_type_with_mempool (MonoImage *image, MonoType *type, MonoGenericContext *context, MonoError *error) __attribute__ ((visibility ("hidden")));
>
>MonoClass*
>mono_class_inflate_generic_class (MonoClass *gklass, MonoGenericContext *context) __attribute__ ((visibility ("hidden")));
>
>MonoType*
>mono_class_inflate_generic_type_checked (MonoType *type, MonoGenericContext *context, MonoError *error) __attribute__ ((visibility ("hidden")));
>
>void
>mono_metadata_free_inflated_signature (MonoMethodSignature *sig);
>
>typedef struct {
> MonoImage *corlib;
> MonoClass *object_class;
> MonoClass *byte_class;
> MonoClass *void_class;
> MonoClass *boolean_class;
> MonoClass *sbyte_class;
> MonoClass *int16_class;
> MonoClass *uint16_class;
> MonoClass *int32_class;
> MonoClass *uint32_class;
> MonoClass *int_class;
> MonoClass *uint_class;
> MonoClass *int64_class;
> MonoClass *uint64_class;
> MonoClass *single_class;
> MonoClass *double_class;
> MonoClass *char_class;
> MonoClass *string_class;
> MonoClass *enum_class;
> MonoClass *array_class;
> MonoClass *delegate_class;
> MonoClass *multicastdelegate_class;
> MonoClass *asyncresult_class;
> MonoClass *manualresetevent_class;
> MonoClass *typehandle_class;
> MonoClass *fieldhandle_class;
> MonoClass *methodhandle_class;
> MonoClass *systemtype_class;
> MonoClass *monotype_class;
> MonoClass *exception_class;
> MonoClass *threadabortexception_class;
> MonoClass *thread_class;
> MonoClass *internal_thread_class;
> MonoClass *transparent_proxy_class;
> MonoClass *real_proxy_class;
> MonoClass *mono_method_message_class;
> MonoClass *appdomain_class;
> MonoClass *field_info_class;
> MonoClass *method_info_class;
> MonoClass *stringbuilder_class;
> MonoClass *math_class;
> MonoClass *stack_frame_class;
> MonoClass *stack_trace_class;
> MonoClass *marshal_class;
> MonoClass *iserializeable_class;
> MonoClass *serializationinfo_class;
> MonoClass *streamingcontext_class;
> MonoClass *typed_reference_class;
> MonoClass *argumenthandle_class;
> MonoClass *marshalbyrefobject_class;
> MonoClass *monitor_class;
> MonoClass *iremotingtypeinfo_class;
> MonoClass *runtimesecurityframe_class;
> MonoClass *executioncontext_class;
> MonoClass *internals_visible_class;
> MonoClass *generic_ilist_class;
> MonoClass *generic_nullable_class;
> MonoClass *variant_class;
> MonoClass *com_object_class;
> MonoClass *com_interop_proxy_class;
> MonoClass *iunknown_class;
> MonoClass *idispatch_class;
> MonoClass *safehandle_class;
> MonoClass *handleref_class;
> MonoClass *attribute_class;
> MonoClass *customattribute_data_class;
> MonoClass *critical_finalizer_object;
>} MonoDefaults;
>
>extern MonoDefaults mono_defaults __attribute__ ((visibility ("hidden")));
>
>void
>mono_loader_init (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_loader_cleanup (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_loader_lock (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_loader_unlock (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_loader_lock_track_ownership (gboolean track) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_loader_lock_is_owned_by_self (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_loader_lock_if_inited (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_loader_unlock_if_inited (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_loader_set_error_assembly_load (const char *assembly_name, gboolean ref_only) __attribute__ ((visibility ("hidden")));
>
>void
>mono_loader_set_error_type_load (const char *class_name, const char *assembly_name) __attribute__ ((visibility ("hidden")));
>
>void
>mono_loader_set_error_method_load (const char *class_name, const char *member_name) __attribute__ ((visibility ("hidden")));
>
>void
>mono_loader_set_error_field_load (MonoClass *klass, const char *member_name) __attribute__ ((visibility ("hidden")));
>void
>mono_loader_set_error_bad_image (char *msg) __attribute__ ((visibility ("hidden")));
>
>MonoException *
>mono_loader_error_prepare_exception (MonoLoaderError *error) __attribute__ ((visibility ("hidden")));
>
>MonoLoaderError *
>mono_loader_get_last_error (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_loader_clear_error (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_reflection_init (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_icall_init (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_icall_cleanup (void) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_method_get_wrapper_data (MonoMethod *method, guint32 id) __attribute__ ((visibility ("hidden")));
>
>void
>mono_install_stack_walk (MonoStackWalkImpl func) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_metadata_has_generic_params (MonoImage *image, guint32 token) __attribute__ ((visibility ("hidden")));
>
>MonoGenericContainer *
>mono_metadata_load_generic_params (MonoImage *image, guint32 token,
>       MonoGenericContainer *parent_container);
>
>void
>mono_metadata_load_generic_param_constraints (MonoImage *image, guint32 token,
>           MonoGenericContainer *container);
>
>gboolean
>mono_metadata_load_generic_param_constraints_full (MonoImage *image, guint32 token,
>           MonoGenericContainer *container) __attribute__ ((visibility ("hidden")));
>
>MonoMethodSignature*
>mono_create_icall_signature (const char *sigstr) __attribute__ ((visibility ("hidden")));
>
>MonoJitICallInfo *
>mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save) __attribute__ ((visibility ("hidden")));
>
>void
>mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper) __attribute__ ((visibility ("hidden")));
>
>MonoJitICallInfo *
>mono_find_jit_icall_by_name (const char *name) __attribute__ ((visibility ("hidden")));
>
>MonoJitICallInfo *
>mono_find_jit_icall_by_addr (gconstpointer addr) __attribute__ ((visibility ("hidden")));
>
>GHashTable*
>mono_get_jit_icall_info (void) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_class_get_exception_data (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoException*
>mono_class_get_exception_for_failure (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>char*
>mono_type_get_name_full (MonoType *type, MonoTypeNameFormat format) __attribute__ ((visibility ("hidden")));
>
>char*
>mono_type_get_full_name (MonoClass *class) __attribute__ ((visibility ("hidden")));
>
>MonoArrayType *mono_dup_array_type (MonoImage *image, MonoArrayType *a) __attribute__ ((visibility ("hidden")));
>MonoMethodSignature *mono_metadata_signature_deep_dup (MonoImage *image, MonoMethodSignature *sig) __attribute__ ((visibility ("hidden")));
>
>void
>mono_image_init_name_cache (MonoImage *image);
>
>gboolean mono_class_is_nullable (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>MonoClass *mono_class_get_nullable_param (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>
>void mono_object_describe (MonoObject *obj);
>void mono_object_describe_fields (MonoObject *obj);
>void mono_value_describe_fields (MonoClass* klass, const char* addr);
>void mono_class_describe_statics (MonoClass* klass);
>
>
>gboolean
>mono_type_is_valid_enum_basetype (MonoType * type);
>
>gboolean
>mono_class_is_valid_enum (MonoClass *klass);
>
>MonoType *
>mono_type_get_full (MonoImage *image, guint32 type_token, MonoGenericContext *context) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_generic_class_is_generic_type_definition (MonoGenericClass *gklass) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_method_get_declaring_generic_method (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_class_get_method_generic (MonoClass *klass, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoType*
>mono_type_get_basic_type_from_generic (MonoType *type) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_method_can_access_method_full (MonoMethod *method, MonoMethod *called, MonoClass *context_klass) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_method_can_access_field_full (MonoMethod *method, MonoClassField *field, MonoClass *context_klass) __attribute__ ((visibility ("hidden")));
>
>MonoClass *
>mono_class_get_generic_type_definition (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_has_parent_and_ignore_generics (MonoClass *klass, MonoClass *parent) __attribute__ ((visibility ("hidden")));
>
>int
>mono_method_get_vtable_slot (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>int
>mono_method_get_vtable_index (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_method_search_in_array_class (MonoClass *klass, const char *name, MonoMethodSignature *sig) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_setup_interface_id (MonoClass *class) __attribute__ ((visibility ("hidden")));
>
>MonoGenericContainer*
>mono_class_get_generic_container (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoGenericClass*
>mono_class_get_generic_class (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_alloc_ext (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_setup_interfaces (MonoClass *klass, MonoError *error) __attribute__ ((visibility ("hidden")));
>
>MonoClassField*
>mono_class_get_field_from_name_full (MonoClass *klass, const char *name, MonoType *type) __attribute__ ((visibility ("hidden")));
>
>MonoVTable*
>mono_class_vtable_full (MonoDomain *domain, MonoClass *class, gboolean raise_on_error) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_is_assignable_from_slow (MonoClass *target, MonoClass *candidate) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_has_variant_generic_params (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_is_corlib_image (MonoImage *image) __attribute__ ((visibility ("hidden")));
>
>MonoType*
>mono_field_get_type_checked (MonoClassField *field, MonoError *error) __attribute__ ((visibility ("hidden")));
>
>MonoClassField*
>mono_class_get_fields_lazy (MonoClass* klass, gpointer *iter) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_check_vtable_constraints (MonoClass *class, GList *in_setup) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_has_finalizer (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_unload_interface_id (MonoClass *class) __attribute__ ((visibility ("hidden")));
># 9 "../../mono/metadata/object-internals.h" 2
># 1 "../../mono/metadata/threads-types.h" 1
># 19 "../../mono/metadata/threads-types.h"
># 1 "../../mono/utils/mono-membar.h" 1
># 13 "../../mono/utils/mono-membar.h"
># 1 "../../config.h" 1
># 14 "../../mono/utils/mono-membar.h" 2
># 101 "../../mono/utils/mono-membar.h"
>static inline void mono_memory_barrier (void)
>{
> __asm__ __volatile__ ("bcr 15,0" : : : "memory");
>}
>
>static inline void mono_memory_read_barrier (void)
>{
> mono_memory_barrier ();
>}
>
>static inline void mono_memory_write_barrier (void)
>{
> mono_memory_barrier ();
>}
># 20 "../../mono/metadata/threads-types.h" 2
>
>
>typedef enum {
> ThreadState_Running = 0x00000000,
> ThreadState_StopRequested = 0x00000001,
> ThreadState_SuspendRequested = 0x00000002,
> ThreadState_Background = 0x00000004,
> ThreadState_Unstarted = 0x00000008,
> ThreadState_Stopped = 0x00000010,
> ThreadState_WaitSleepJoin = 0x00000020,
> ThreadState_Suspended = 0x00000040,
> ThreadState_AbortRequested = 0x00000080,
> ThreadState_Aborted = 0x00000100
>} MonoThreadState;
>
>
>typedef enum {
> ThreadApartmentState_STA = 0x00000000,
> ThreadApartmentState_MTA = 0x00000001,
> ThreadApartmentState_Unknown = 0x00000002
>} MonoThreadApartmentState;
>
>typedef void (*MonoThreadNotifyPendingExcFunc) (void);
># 53 "../../mono/metadata/threads-types.h"
>typedef struct _MonoInternalThread MonoInternalThread;
>
>typedef void (*MonoThreadCleanupFunc) (MonoInternalThread* thread);
>
>gpointer mono_create_thread (WapiSecurityAttributes *security,
>        guint32 stacksize, WapiThreadStart start,
>        gpointer param, guint32 create, gsize *tid) __attribute__ ((visibility ("hidden")));
>
>MonoInternalThread* mono_thread_create_internal (MonoDomain *domain, gpointer func, gpointer arg, gboolean threadpool_thread, guint32 stack_size) __attribute__ ((visibility ("hidden")));
>
>void mono_threads_install_cleanup (MonoThreadCleanupFunc func) __attribute__ ((visibility ("hidden")));
>
>void ves_icall_System_Threading_Thread_ConstructInternalThread (MonoThread *this) __attribute__ ((visibility ("hidden")));
>HANDLE ves_icall_System_Threading_Thread_Thread_internal(MonoThread *this_obj, MonoObject *start) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_InternalThread_Thread_free_internal(MonoInternalThread *this_obj, HANDLE thread) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_Sleep_internal(gint32 ms) __attribute__ ((visibility ("hidden")));
>gboolean ves_icall_System_Threading_Thread_Join_internal(MonoInternalThread *this_obj, int ms, HANDLE thread) __attribute__ ((visibility ("hidden")));
>gint32 ves_icall_System_Threading_Thread_GetDomainID (void) __attribute__ ((visibility ("hidden")));
>gboolean ves_icall_System_Threading_Thread_Yield (void) __attribute__ ((visibility ("hidden")));
>MonoString* ves_icall_System_Threading_Thread_GetName_internal (MonoInternalThread *this_obj) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_SetName_internal (MonoInternalThread *this_obj, MonoString *name) __attribute__ ((visibility ("hidden")));
>MonoObject* ves_icall_System_Threading_Thread_GetCachedCurrentCulture (MonoInternalThread *this_obj) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_SetCachedCurrentCulture (MonoThread *this_obj, MonoObject *culture) __attribute__ ((visibility ("hidden")));
>MonoObject* ves_icall_System_Threading_Thread_GetCachedCurrentUICulture (MonoInternalThread *this_obj) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_SetCachedCurrentUICulture (MonoThread *this_obj, MonoObject *culture) __attribute__ ((visibility ("hidden")));
>HANDLE ves_icall_System_Threading_Mutex_CreateMutex_internal(MonoBoolean owned, MonoString *name, MonoBoolean *created) __attribute__ ((visibility ("hidden")));
>MonoBoolean ves_icall_System_Threading_Mutex_ReleaseMutex_internal (HANDLE handle ) __attribute__ ((visibility ("hidden")));
>HANDLE ves_icall_System_Threading_Mutex_OpenMutex_internal (MonoString *name, gint32 rights, gint32 *error) __attribute__ ((visibility ("hidden")));
>HANDLE ves_icall_System_Threading_Semaphore_CreateSemaphore_internal (gint32 initialCount, gint32 maximumCount, MonoString *name, MonoBoolean *created) __attribute__ ((visibility ("hidden")));
>gint32 ves_icall_System_Threading_Semaphore_ReleaseSemaphore_internal (HANDLE handle, gint32 releaseCount, MonoBoolean *fail) __attribute__ ((visibility ("hidden")));
>HANDLE ves_icall_System_Threading_Semaphore_OpenSemaphore_internal (MonoString *name, gint32 rights, gint32 *error) __attribute__ ((visibility ("hidden")));
>HANDLE ves_icall_System_Threading_Events_CreateEvent_internal (MonoBoolean manual, MonoBoolean initial, MonoString *name, MonoBoolean *created) __attribute__ ((visibility ("hidden")));
>gboolean ves_icall_System_Threading_Events_SetEvent_internal (HANDLE handle) __attribute__ ((visibility ("hidden")));
>gboolean ves_icall_System_Threading_Events_ResetEvent_internal (HANDLE handle) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Events_CloseEvent_internal (HANDLE handle) __attribute__ ((visibility ("hidden")));
>HANDLE ves_icall_System_Threading_Events_OpenEvent_internal (MonoString *name, gint32 rights, gint32 *error) __attribute__ ((visibility ("hidden")));
>
>gboolean ves_icall_System_Threading_WaitHandle_WaitAll_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext) __attribute__ ((visibility ("hidden")));
>gint32 ves_icall_System_Threading_WaitHandle_WaitAny_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext) __attribute__ ((visibility ("hidden")));
>gboolean ves_icall_System_Threading_WaitHandle_WaitOne_internal(MonoObject *this_obj, HANDLE handle, gint32 ms, gboolean exitContext) __attribute__ ((visibility ("hidden")));
>gboolean ves_icall_System_Threading_WaitHandle_SignalAndWait_Internal (HANDLE toSignal, HANDLE toWait, gint32 ms, gboolean exitContext) __attribute__ ((visibility ("hidden")));
>
>MonoArray* ves_icall_System_Threading_Thread_ByteArrayToRootDomain (MonoArray *arr) __attribute__ ((visibility ("hidden")));
>MonoArray* ves_icall_System_Threading_Thread_ByteArrayToCurrentDomain (MonoArray *arr) __attribute__ ((visibility ("hidden")));
>
>gint32 ves_icall_System_Threading_Interlocked_Increment_Int(gint32 *location) __attribute__ ((visibility ("hidden")));
>gint64 ves_icall_System_Threading_Interlocked_Increment_Long(gint64 *location) __attribute__ ((visibility ("hidden")));
>gint32 ves_icall_System_Threading_Interlocked_Decrement_Int(gint32 *location) __attribute__ ((visibility ("hidden")));
>gint64 ves_icall_System_Threading_Interlocked_Decrement_Long(gint64 * location) __attribute__ ((visibility ("hidden")));
>
>gint32 ves_icall_System_Threading_Interlocked_Exchange_Int(gint32 *location, gint32 value) __attribute__ ((visibility ("hidden")));
>gint64 ves_icall_System_Threading_Interlocked_Exchange_Long(gint64 *location, gint64 value) __attribute__ ((visibility ("hidden")));
>MonoObject *ves_icall_System_Threading_Interlocked_Exchange_Object(MonoObject **location, MonoObject *value) __attribute__ ((visibility ("hidden")));
>gpointer ves_icall_System_Threading_Interlocked_Exchange_IntPtr(gpointer *location, gpointer value) __attribute__ ((visibility ("hidden")));
>gfloat ves_icall_System_Threading_Interlocked_Exchange_Single(gfloat *location, gfloat value) __attribute__ ((visibility ("hidden")));
>gdouble ves_icall_System_Threading_Interlocked_Exchange_Double(gdouble *location, gdouble value) __attribute__ ((visibility ("hidden")));
>
>gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int(gint32 *location, gint32 value, gint32 comparand) __attribute__ ((visibility ("hidden")));
>gint64 ves_icall_System_Threading_Interlocked_CompareExchange_Long(gint64 *location, gint64 value, gint64 comparand) __attribute__ ((visibility ("hidden")));
>MonoObject *ves_icall_System_Threading_Interlocked_CompareExchange_Object(MonoObject **location, MonoObject *value, MonoObject *comparand) __attribute__ ((visibility ("hidden")));
>gpointer ves_icall_System_Threading_Interlocked_CompareExchange_IntPtr(gpointer *location, gpointer value, gpointer comparand) __attribute__ ((visibility ("hidden")));
>gfloat ves_icall_System_Threading_Interlocked_CompareExchange_Single(gfloat *location, gfloat value, gfloat comparand) __attribute__ ((visibility ("hidden")));
>gdouble ves_icall_System_Threading_Interlocked_CompareExchange_Double(gdouble *location, gdouble value, gdouble comparand) __attribute__ ((visibility ("hidden")));
>MonoObject* ves_icall_System_Threading_Interlocked_CompareExchange_T(MonoObject **location, MonoObject *value, MonoObject *comparand) __attribute__ ((visibility ("hidden")));
>MonoObject* ves_icall_System_Threading_Interlocked_Exchange_T(MonoObject **location, MonoObject *value) __attribute__ ((visibility ("hidden")));
>
>gint32 ves_icall_System_Threading_Interlocked_Add_Int(gint32 *location, gint32 value) __attribute__ ((visibility ("hidden")));
>gint64 ves_icall_System_Threading_Interlocked_Add_Long(gint64 *location, gint64 value) __attribute__ ((visibility ("hidden")));
>gint64 ves_icall_System_Threading_Interlocked_Read_Long(gint64 *location) __attribute__ ((visibility ("hidden")));
>
>gint32 ves_icall_System_Threading_Interlocked_Increment_Int(gint32 *location) __attribute__ ((visibility ("hidden")));
>gint64 ves_icall_System_Threading_Interlocked_Increment_Long(gint64 *location) __attribute__ ((visibility ("hidden")));
>
>gint32 ves_icall_System_Threading_Interlocked_Decrement_Int(gint32 *location) __attribute__ ((visibility ("hidden")));
>gint64 ves_icall_System_Threading_Interlocked_Decrement_Long(gint64 * location) __attribute__ ((visibility ("hidden")));
>
>void ves_icall_System_Threading_Thread_Abort (MonoInternalThread *thread, MonoObject *state) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_ResetAbort (void) __attribute__ ((visibility ("hidden")));
>MonoObject* ves_icall_System_Threading_Thread_GetAbortExceptionState (MonoThread *thread) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_Suspend (MonoInternalThread *thread) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_Resume (MonoThread *thread) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_ClrState (MonoInternalThread *thread, guint32 state) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_SetState (MonoInternalThread *thread, guint32 state) __attribute__ ((visibility ("hidden")));
>guint32 ves_icall_System_Threading_Thread_GetState (MonoInternalThread *thread) __attribute__ ((visibility ("hidden")));
>
>gint8 ves_icall_System_Threading_Thread_VolatileRead1 (void *ptr) __attribute__ ((visibility ("hidden")));
>gint16 ves_icall_System_Threading_Thread_VolatileRead2 (void *ptr) __attribute__ ((visibility ("hidden")));
>gint32 ves_icall_System_Threading_Thread_VolatileRead4 (void *ptr) __attribute__ ((visibility ("hidden")));
>gint64 ves_icall_System_Threading_Thread_VolatileRead8 (void *ptr) __attribute__ ((visibility ("hidden")));
>void * ves_icall_System_Threading_Thread_VolatileReadIntPtr (void *ptr) __attribute__ ((visibility ("hidden")));
>
>void ves_icall_System_Threading_Thread_VolatileWrite1 (void *ptr, gint8) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_VolatileWrite2 (void *ptr, gint16) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_VolatileWrite4 (void *ptr, gint32) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_VolatileWrite8 (void *ptr, gint64) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_VolatileWriteIntPtr (void *ptr, void *) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_VolatileWriteObject (void *ptr, void *) __attribute__ ((visibility ("hidden")));
>
>void ves_icall_System_Threading_Thread_MemoryBarrier (void) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_Interrupt_internal (MonoInternalThread *this_obj) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Threading_Thread_SpinWait_nop (void) __attribute__ ((visibility ("hidden")));
>
>MonoInternalThread *mono_thread_internal_current (void) __attribute__ ((visibility ("hidden")));
>
>void mono_thread_internal_stop (MonoInternalThread *thread) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_thread_internal_has_appdomain_ref (MonoInternalThread *thread, MonoDomain *domain) __attribute__ ((visibility ("hidden")));
>
>void mono_thread_internal_reset_abort (MonoInternalThread *thread) __attribute__ ((visibility ("hidden")));
>
>void mono_alloc_special_static_data_free (GHashTable *special_static_fields) __attribute__ ((visibility ("hidden")));
>void mono_thread_free_local_slot_values (int slot, MonoBoolean thread_local) __attribute__ ((visibility ("hidden")));
>void mono_thread_current_check_pending_interrupt (void) __attribute__ ((visibility ("hidden")));
>void mono_thread_get_stack_bounds (guint8 **staddr, size_t *stsize) __attribute__ ((visibility ("hidden")));
>
>void mono_thread_set_state (MonoInternalThread *thread, MonoThreadState state) __attribute__ ((visibility ("hidden")));
>void mono_thread_clr_state (MonoInternalThread *thread, MonoThreadState state) __attribute__ ((visibility ("hidden")));
>gboolean mono_thread_test_state (MonoInternalThread *thread, MonoThreadState test) __attribute__ ((visibility ("hidden")));
>
>void mono_thread_init_apartment_state (void) __attribute__ ((visibility ("hidden")));
>void mono_thread_cleanup_apartment_state (void) __attribute__ ((visibility ("hidden")));
>
>void mono_threads_set_shutting_down (void) __attribute__ ((visibility ("hidden")));
>gboolean mono_threads_is_shutting_down (void) __attribute__ ((visibility ("hidden")));
>
>gunichar2* mono_thread_get_name (MonoInternalThread *this_obj, guint32 *name_len) __attribute__ ((visibility ("hidden")));
>
>MonoException* mono_thread_get_undeniable_exception (void);
>
>MonoException* mono_thread_get_and_clear_pending_exception (void) __attribute__ ((visibility ("hidden")));
>
>typedef struct {
> gpointer hazard_pointers [2];
>} MonoThreadHazardPointers;
>
>typedef void (*MonoHazardousFreeFunc) (gpointer p);
>
>void mono_thread_hazardous_free_or_queue (gpointer p, MonoHazardousFreeFunc free_func);
>void mono_thread_hazardous_try_free_all (void);
>
>MonoThreadHazardPointers* mono_hazard_pointer_get (void);
>
>void mono_threads_install_notify_pending_exc (MonoThreadNotifyPendingExcFunc func) __attribute__ ((visibility ("hidden")));
># 207 "../../mono/metadata/threads-types.h"
>MonoObject* mono_thread_get_execution_context (void) __attribute__ ((visibility ("hidden")));
>void mono_thread_set_execution_context (MonoObject *ec) __attribute__ ((visibility ("hidden")));
>
>void mono_runtime_set_has_tls_get (gboolean val) __attribute__ ((visibility ("hidden")));
>gboolean mono_runtime_has_tls_get (void) __attribute__ ((visibility ("hidden")));
>
>int mono_thread_get_abort_signal (void) __attribute__ ((visibility ("hidden")));
>
>void mono_thread_abort_all_other_threads (void) __attribute__ ((visibility ("hidden")));
>void mono_thread_suspend_all_other_threads (void) __attribute__ ((visibility ("hidden")));
>gboolean mono_threads_abort_appdomain_threads (MonoDomain *domain, int timeout) __attribute__ ((visibility ("hidden")));
>
>void mono_thread_push_appdomain_ref (MonoDomain *domain) __attribute__ ((visibility ("hidden")));
>void mono_thread_pop_appdomain_ref (void) __attribute__ ((visibility ("hidden")));
>gboolean mono_thread_has_appdomain_ref (MonoThread *thread, MonoDomain *domain) __attribute__ ((visibility ("hidden")));
>
>void mono_threads_clear_cached_culture (MonoDomain *domain) __attribute__ ((visibility ("hidden")));
>
>MonoException* mono_thread_request_interruption (mono_bool running_managed) __attribute__ ((visibility ("hidden")));
>gboolean mono_thread_interruption_requested (void) __attribute__ ((visibility ("hidden")));
>void mono_thread_interruption_checkpoint (void) __attribute__ ((visibility ("hidden")));
>void mono_thread_force_interruption_checkpoint (void) __attribute__ ((visibility ("hidden")));
>gint32* mono_thread_interruption_request_flag (void) __attribute__ ((visibility ("hidden")));
>
>uint32_t mono_alloc_special_static_data (uint32_t static_type, uint32_t size, uint32_t align, uintptr_t *bitmap, int max_set) __attribute__ ((visibility ("hidden")));
>void* mono_get_special_static_data (uint32_t offset) __attribute__ ((visibility ("hidden")));
>gpointer mono_get_special_static_data_for_thread (MonoInternalThread *thread, guint32 offset) __attribute__ ((visibility ("hidden")));
>
>MonoException* mono_thread_resume_interruption (void) __attribute__ ((visibility ("hidden")));
># 10 "../../mono/metadata/object-internals.h" 2
>
>
>
># 1 "../../mono/utils/mono-tls.h" 1
># 32 "../../mono/utils/mono-tls.h"
>static inline int
>mono_native_tls_alloc (pthread_key_t *key, void *destructor)
>{
> return pthread_key_create (key, destructor) == 0;
>}
>
>static inline void
>mono_native_tls_free (pthread_key_t key)
>{
> pthread_key_delete (key);
>}
>
>static inline int
>mono_native_tls_set_value (pthread_key_t key, gpointer value)
>{
> return !pthread_setspecific (key, value);
>}
># 14 "../../mono/metadata/object-internals.h" 2
># 160 "../../mono/metadata/object-internals.h"
>typedef uint32_t mono_array_size_t;
>typedef int32_t mono_array_lower_bound_t;
>
>
>
>
>typedef struct {
> mono_array_size_t length;
> mono_array_lower_bound_t lower_bound;
>} MonoArrayBounds;
>
>struct _MonoArray {
> MonoObject obj;
>
> MonoArrayBounds *bounds;
>
> mono_array_size_t max_length;
>
> double vector [0];
>};
>
>struct _MonoString {
> MonoObject object;
> int32_t length;
> mono_unichar2 chars [0];
>};
># 196 "../../mono/metadata/object-internals.h"
>typedef struct {
> MonoObject obj;
> MonoObject *identity;
>} MonoMarshalByRefObject;
>
>
>struct _MonoAppDomain {
> MonoMarshalByRefObject mbr;
> MonoDomain *data;
>};
>
>typedef struct {
> MonoObject object;
> gint32 length;
> MonoString *str;
> MonoString *cached_str;
> gint32 max_capacity;
>} MonoStringBuilder;
>
>typedef struct {
> MonoType *type;
> gpointer value;
> MonoClass *klass;
>} MonoTypedRef;
>
>typedef struct {
> gpointer args;
>} MonoArgumentHandle;
>
>typedef struct {
> MonoMethodSignature *sig;
> gpointer args;
> gint32 next_arg;
> gint32 num_args;
>} MonoArgIterator;
>
>struct _MonoException {
> MonoObject object;
>
>
> MonoArray *trace_ips;
> MonoObject *inner_ex;
> MonoString *message;
> MonoString *help_link;
> MonoString *class_name;
> MonoString *stack_trace;
> MonoString *remote_stack_trace;
> gint32 remote_stack_index;
> gint32 hresult;
> MonoString *source;
> MonoObject *_data;
>};
>
>typedef struct {
> MonoException base;
>} MonoSystemException;
>
>typedef struct {
> MonoSystemException base;
> MonoString *param_name;
>} MonoArgumentException;
>
>typedef struct {
> MonoSystemException base;
> MonoString *msg;
> MonoString *type_name;
>} MonoTypeLoadException;
>
>typedef struct {
> MonoException base;
> MonoObject *wrapped_exception;
>} MonoRuntimeWrappedException;
>
>typedef struct {
> MonoObject object;
> MonoObject *async_state;
> MonoObject *handle;
> MonoObject *async_delegate;
> gpointer *data;
> MonoObject *object_data;
> MonoBoolean sync_completed;
> MonoBoolean completed;
> MonoBoolean endinvoke_called;
> MonoObject *async_callback;
> MonoObject *execution_context;
> MonoObject *original_context;
> gint64 add_time;
>} MonoAsyncResult;
>
>typedef struct {
> MonoMarshalByRefObject object;
> gpointer handle;
> MonoBoolean disposed;
>} MonoWaitHandle;
>
>
>typedef enum {
> CallType_Sync = 0,
> CallType_BeginInvoke = 1,
> CallType_EndInvoke = 2,
> CallType_OneWay = 3
>} MonoCallType;
>
>
>struct _MonoReflectionType {
> MonoObject object;
> MonoType *type;
>};
>
>typedef struct {
> MonoReflectionType type;
> MonoObject *type_info;
>} MonoReflectionMonoType;
>
>typedef struct {
> MonoObject object;
> MonoReflectionType *class_to_proxy;
> MonoObject *context;
> MonoObject *unwrapped_server;
> gint32 target_domain_id;
> MonoString *target_uri;
> MonoObject *object_identity;
> MonoObject *obj_TP;
> MonoObject *stub_data;
>} MonoRealProxy;
>
>typedef struct {
> MonoMarshalByRefObject object;
> gpointer iunknown;
> GHashTable* itf_hash;
>} MonoComObject;
>
>typedef struct {
> MonoRealProxy real_proxy;
> MonoComObject *com_object;
> gint32 ref_count;
>} MonoComInteropProxy;
>
>typedef struct {
> MonoObject object;
> MonoRealProxy *rp;
> MonoRemoteClass *remote_class;
> MonoBoolean custom_type_info;
>} MonoTransparentProxy;
>
>typedef struct {
> MonoObject obj;
> MonoReflectionMethod *method;
> MonoArray *args;
> MonoArray *names;
> MonoArray *arg_types;
> MonoObject *ctx;
> MonoObject *rval;
> MonoObject *exc;
> MonoAsyncResult *async_result;
> guint32 call_type;
>} MonoMethodMessage;
>
>typedef struct {
> MonoObject obj;
> gint32 il_offset;
> gint32 native_offset;
> MonoReflectionMethod *method;
> MonoString *filename;
> gint32 line;
> gint32 column;
> MonoString *internal_method_name;
>} MonoStackFrame;
>
>typedef enum {
> MONO_THREAD_FLAG_DONT_MANAGE = 1,
>} MonoThreadFlags;
>
>struct _MonoInternalThread {
> MonoObject obj;
> volatile int lock_thread_id;
> HANDLE handle;
> MonoArray *cached_culture_info;
> gpointer unused1;
> MonoBoolean threadpool_thread;
> gunichar2 *name;
> guint32 name_len;
> guint32 state;
> MonoException *abort_exc;
> int abort_state_handle;
> guint64 tid;
> HANDLE start_notify;
> gpointer stack_ptr;
> gpointer *static_data;
> gpointer jit_data;
> gpointer lock_data;
> MonoAppContext *current_appcontext;
> int stack_size;
> gpointer appdomain_refs;
>
> gint32 interruption_requested;
> gpointer suspend_event;
> gpointer suspended_event;
> gpointer resume_event;
> CRITICAL_SECTION *synch_cs;
> MonoBoolean thread_dump_requested;
> gpointer end_stack;
> MonoBoolean thread_interrupt_requested;
> guint8 apartment_state;
> gint32 critical_region_level;
> guint32 small_id;
> MonoThreadManageCallback manage_callback;
> MonoException *pending_exception;
> MonoThread *root_domain_thread;
> gpointer interrupt_on_stop;
> gsize flags;
> gpointer android_tid;
>
>
>
>
> gpointer unused5;
> gint32 managed_id;
>};
>
>struct _MonoThread {
> MonoObject obj;
> struct _MonoInternalThread *internal_thread;
> MonoObject *start_obj;
> MonoObject *ec_to_set;
>};
>
>typedef struct {
> MonoString *name;
> MonoReflectionType *type;
> MonoObject *value;
>} MonoSerializationEntry;
>
>typedef struct {
> guint32 state;
> MonoObject *additional;
>} MonoStreamingContext;
>
>typedef struct {
> MonoObject obj;
> MonoBoolean readOnly;
> MonoString *AMDesignator;
> MonoString *PMDesignator;
> MonoString *DateSeparator;
> MonoString *TimeSeparator;
> MonoString *ShortDatePattern;
> MonoString *LongDatePattern;
> MonoString *ShortTimePattern;
> MonoString *LongTimePattern;
> MonoString *MonthDayPattern;
> MonoString *YearMonthPattern;
> MonoString *FullDateTimePattern;
> MonoString *RFC1123Pattern;
> MonoString *SortableDateTimePattern;
> MonoString *UniversalSortableDateTimePattern;
> guint32 FirstDayOfWeek;
> MonoObject *Calendar;
> guint32 CalendarWeekRule;
> MonoArray *AbbreviatedDayNames;
> MonoArray *DayNames;
> MonoArray *MonthNames;
> MonoArray *AbbreviatedMonthNames;
> MonoArray *ShortDatePatterns;
> MonoArray *LongDatePatterns;
> MonoArray *ShortTimePatterns;
> MonoArray *LongTimePatterns;
> MonoArray *MonthDayPatterns;
> MonoArray *YearMonthPatterns;
> MonoArray *shortDayNames;
>} MonoDateTimeFormatInfo;
>
>typedef struct
>{
> MonoObject obj;
> MonoBoolean readOnly;
> MonoString *decimalFormats;
> MonoString *currencyFormats;
> MonoString *percentFormats;
> MonoString *digitPattern;
> MonoString *zeroPattern;
> gint32 currencyDecimalDigits;
> MonoString *currencyDecimalSeparator;
> MonoString *currencyGroupSeparator;
> MonoArray *currencyGroupSizes;
> gint32 currencyNegativePattern;
> gint32 currencyPositivePattern;
> MonoString *currencySymbol;
> MonoString *naNSymbol;
> MonoString *negativeInfinitySymbol;
> MonoString *negativeSign;
> guint32 numberDecimalDigits;
> MonoString *numberDecimalSeparator;
> MonoString *numberGroupSeparator;
> MonoArray *numberGroupSizes;
> gint32 numberNegativePattern;
> gint32 percentDecimalDigits;
> MonoString *percentDecimalSeparator;
> MonoString *percentGroupSeparator;
> MonoArray *percentGroupSizes;
> gint32 percentNegativePattern;
> gint32 percentPositivePattern;
> MonoString *percentSymbol;
> MonoString *perMilleSymbol;
> MonoString *positiveInfinitySymbol;
> MonoString *positiveSign;
>} MonoNumberFormatInfo;
>
>typedef struct {
> MonoObject obj;
> gint32 lcid;
> MonoString *icu_name;
> gpointer ICU_collator;
>} MonoCompareInfo;
>
>typedef struct {
> MonoObject obj;
> MonoBoolean is_read_only;
> gint32 lcid;
> gint32 parent_lcid;
> gint32 specific_lcid;
> gint32 datetime_index;
> gint32 number_index;
> MonoBoolean use_user_override;
> MonoNumberFormatInfo *number_format;
> MonoDateTimeFormatInfo *datetime_format;
> MonoObject *textinfo;
> MonoString *name;
> MonoString *displayname;
> MonoString *englishname;
> MonoString *nativename;
> MonoString *iso3lang;
> MonoString *iso2lang;
> MonoString *icu_name;
> MonoString *win3lang;
> MonoString *territory;
> MonoCompareInfo *compareinfo;
> const gint32 *calendar_data;
> const void* text_info_data;
>} MonoCultureInfo;
>
>typedef struct {
> MonoObject obj;
> gint32 region_id;
> MonoString *iso2name;
> MonoString *iso3name;
> MonoString *win3name;
> MonoString *english_name;
> MonoString *currency_symbol;
> MonoString *iso_currency_symbol;
> MonoString *currency_english_name;
>} MonoRegionInfo;
>
>typedef struct {
> MonoObject obj;
> MonoString *str;
> gint32 options;
> MonoArray *key;
> gint32 lcid;
>} MonoSortKey;
>
>typedef struct {
> MonoObject object;
> guint32 intType;
>} MonoInterfaceTypeAttribute;
>
>
>
>
>
>
>typedef struct {
> gpointer (*create_ftnptr) (MonoDomain *domain, gpointer addr);
> gpointer (*get_addr_from_ftnptr) (gpointer descr);
> char* (*get_runtime_build_info) (void);
> gpointer (*get_vtable_trampoline) (int slot_index);
> gpointer (*get_imt_trampoline) (int imt_slot_index);
> void (*set_cast_details) (MonoClass *from, MonoClass *to);
>} MonoRuntimeCallbacks;
>
>
>typedef void (*MonoFreeMethodFunc) (MonoDomain *domain, MonoMethod *method);
>
>
>typedef gboolean (*MonoInitVTableFunc) (MonoVTable *vtable);
>
>void mono_set_pending_exception (MonoException *exc) __attribute__ ((visibility ("hidden")));
>
>
>
>MonoAsyncResult *
>mono_async_result_new (MonoDomain *domain, HANDLE handle,
>        MonoObject *state, gpointer data, MonoObject *object_data) __attribute__ ((visibility ("hidden")));
>
>MonoWaitHandle *
>mono_wait_handle_new (MonoDomain *domain, HANDLE handle) __attribute__ ((visibility ("hidden")));
>
>HANDLE
>mono_wait_handle_get_handle (MonoWaitHandle *handle) __attribute__ ((visibility ("hidden")));
>
>void
>mono_message_init (MonoDomain *domain, MonoMethodMessage *this_obj,
>        MonoReflectionMethod *method, MonoArray *out_args) __attribute__ ((visibility ("hidden")));
>
>MonoObject *
>mono_remoting_invoke (MonoObject *real_proxy, MonoMethodMessage *msg,
>        MonoObject **exc, MonoArray **out_args) __attribute__ ((visibility ("hidden")));
>
>MonoObject *
>mono_message_invoke (MonoObject *target, MonoMethodMessage *msg,
>        MonoObject **exc, MonoArray **out_args) __attribute__ ((visibility ("hidden")));
>
>MonoMethodMessage *
>mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke,
>         MonoDelegate **cb, MonoObject **state) __attribute__ ((visibility ("hidden")));
>
>void
>mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args) __attribute__ ((visibility ("hidden")));
>
>void
>mono_delegate_ctor_with_method (MonoObject *this, MonoObject *target, gpointer addr, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>void
>mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr) __attribute__ ((visibility ("hidden")));
>
>void*
>mono_class_get_allocation_ftn (MonoVTable *vtable, gboolean for_box, gboolean *pass_size_in_words) __attribute__ ((visibility ("hidden")));
>
>void
>mono_runtime_free_method (MonoDomain *domain, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>
>typedef void (*MonoExceptionFunc) (MonoException *ex);
>
>void
>mono_install_handler (MonoExceptionFunc func) __attribute__ ((visibility ("hidden")));
>
>void
>mono_install_runtime_invoke (MonoInvokeFunc func) __attribute__ ((visibility ("hidden")));
>
>void
>mono_install_compile_method (MonoCompileFunc func) __attribute__ ((visibility ("hidden")));
>
>void
>mono_install_free_method (MonoFreeMethodFunc func) __attribute__ ((visibility ("hidden")));
>
>void
>mono_install_callbacks (MonoRuntimeCallbacks *cbs) __attribute__ ((visibility ("hidden")));
>
>MonoRuntimeCallbacks*
>mono_get_runtime_callbacks (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_type_initialization_init (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_type_initialization_cleanup (void) __attribute__ ((visibility ("hidden")));
>
>int
>mono_thread_kill (MonoInternalThread *thread, int signal) __attribute__ ((visibility ("hidden")));
>
>pthread_key_t
>mono_thread_get_native_tls_key (void) __attribute__ ((visibility ("hidden")));
>
>gint32
>mono_thread_get_tls_offset (void) __attribute__ ((visibility ("hidden")));
>
>pthread_key_t
>mono_domain_get_native_tls_key (void) __attribute__ ((visibility ("hidden")));
>
>gint32
>mono_domain_get_tls_offset (void) __attribute__ ((visibility ("hidden")));
># 699 "../../mono/metadata/object-internals.h"
>static inline MonoReflectionType*
>monotype_cast (MonoObject *obj)
>{
> do { if (!((!(obj) || (((MonoObject*)(obj))->vtable->klass->image == mono_defaults.corlib && ((MonoReflectionType*)(obj))->type != ((void *)0))))) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "../../mono/metadata/object-internals.h", 702, "IS_MONOTYPE (obj)"); } while (0);
>
> return (MonoReflectionType*)obj;
>}
>
>
>
>
>
>struct _MonoReflectionMethod {
> MonoObject object;
> MonoMethod *method;
> MonoString *name;
> MonoReflectionType *reftype;
>};
>
>typedef struct _MonoReflectionGenericMethod MonoReflectionGenericMethod;
>struct _MonoReflectionGenericMethod {
> MonoReflectionMethod method;
>};
>
>struct _MonoDelegate {
> MonoObject object;
>
> gpointer method_ptr;
>
> gpointer invoke_impl;
> MonoObject *target;
> MonoMethod *method;
> gpointer delegate_trampoline;
>
>
>
>
> guint8 **method_code;
> MonoReflectionMethod *method_info;
> MonoReflectionMethod *original_method_info;
> MonoObject *data;
>};
>
>typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
>struct _MonoMulticastDelegate {
> MonoDelegate delegate;
> MonoMulticastDelegate *prev;
>};
>
>struct _MonoReflectionField {
> MonoObject object;
> MonoClass *klass;
> MonoClassField *field;
> MonoString *name;
> MonoReflectionType *type;
> guint32 attrs;
>};
>
>struct _MonoReflectionProperty {
> MonoObject object;
> MonoClass *klass;
> MonoProperty *property;
>};
>
>
>struct _MonoReflectionEvent {
> MonoObject object;
> MonoObject *cached_add_event;
>};
>
>typedef struct {
> MonoReflectionEvent object;
> MonoClass *klass;
> MonoEvent *event;
>} MonoReflectionMonoEvent;
>
>typedef struct {
> MonoObject object;
> MonoReflectionType *ClassImpl;
> MonoObject *DefaultValueImpl;
> MonoObject *MemberImpl;
> MonoString *NameImpl;
> gint32 PositionImpl;
> guint32 AttrsImpl;
> MonoObject *MarshalAsImpl;
>} MonoReflectionParameter;
>
>struct _MonoReflectionMethodBody {
> MonoObject object;
> MonoArray *clauses;
> MonoArray *locals;
> MonoArray *il;
> MonoBoolean init_locals;
> guint32 local_var_sig_token;
> guint32 max_stack;
>};
>
>struct _MonoReflectionAssembly {
> MonoObject object;
> MonoAssembly *assembly;
> MonoObject *resolve_event_holder;
>
> MonoObject *evidence;
> MonoObject *minimum;
> MonoObject *optional;
> MonoObject *refuse;
> MonoObject *granted;
> MonoObject *denied;
>
> MonoBoolean from_byte_array;
> MonoString *name;
>};
>
>typedef struct {
> MonoReflectionType *utype;
> MonoArray *values;
> MonoArray *names;
>} MonoEnumInfo;
>
>typedef struct {
> MonoReflectionType *parent;
> MonoReflectionType *ret;
> guint32 attrs;
> guint32 implattrs;
> guint32 callconv;
>} MonoMethodInfo;
>
>typedef struct {
> MonoReflectionType *parent;
> MonoReflectionType *declaring_type;
> MonoString *name;
> MonoReflectionMethod *get;
> MonoReflectionMethod *set;
> guint32 attrs;
>} MonoPropertyInfo;
>
>typedef struct {
> MonoReflectionType *declaring_type;
> MonoReflectionType *reflected_type;
> MonoString *name;
> MonoReflectionMethod *add_method;
> MonoReflectionMethod *remove_method;
> MonoReflectionMethod *raise_method;
> guint32 attrs;
> MonoArray *other_methods;
>} MonoEventInfo;
>
>typedef struct {
> MonoString *name;
> MonoString *name_space;
> MonoReflectionType *etype;
> MonoReflectionType *nested_in;
> MonoReflectionAssembly *assembly;
> guint32 rank;
> MonoBoolean isprimitive;
>} MonoTypeInfo;
>
>typedef struct {
> MonoObject *member;
> gint32 code_pos;
>} MonoReflectionILTokenInfo;
>
>typedef struct {
> MonoObject object;
> MonoArray *code;
> gint32 code_len;
> gint32 max_stack;
> gint32 cur_stack;
> MonoArray *locals;
> MonoArray *ex_handlers;
> gint32 num_token_fixups;
> MonoArray *token_fixups;
>} MonoReflectionILGen;
>
>typedef struct {
> MonoArray *handlers;
> gint32 start;
> gint32 len;
> gint32 label;
>} MonoILExceptionInfo;
>
>typedef struct {
> MonoObject *extype;
> gint32 type;
> gint32 start;
> gint32 len;
> gint32 filter_offset;
>} MonoILExceptionBlock;
>
>typedef struct {
> MonoObject object;
> MonoObject *catch_type;
> gint32 filter_offset;
> gint32 flags;
> gint32 try_offset;
> gint32 try_length;
> gint32 handler_offset;
> gint32 handler_length;
>} MonoReflectionExceptionHandlingClause;
>
>typedef struct {
> MonoObject object;
> MonoReflectionType *local_type;
> MonoBoolean is_pinned;
> guint16 local_index;
>} MonoReflectionLocalVariableInfo;
>
>typedef struct {
>
>
>
>
> MonoObject object;
> MonoObject *type;
> MonoBoolean is_pinned;
> guint16 local_index;
> MonoString *name;
>} MonoReflectionLocalBuilder;
>
>typedef struct {
> MonoObject object;
> gint32 count;
> gint32 type;
> gint32 eltype;
> MonoString *guid;
> MonoString *mcookie;
> MonoString *marshaltype;
> MonoObject *marshaltyperef;
> gint32 param_num;
> MonoBoolean has_size;
>} MonoReflectionMarshal;
>
>typedef struct {
> MonoObject object;
> MonoObject* methodb;
> MonoString *name;
> MonoArray *cattrs;
> MonoReflectionMarshal *marshal_info;
> guint32 attrs;
> int position;
> guint32 table_idx;
> MonoObject *def_value;
>} MonoReflectionParamBuilder;
>
>typedef struct {
> MonoObject object;
> MonoMethod *mhandle;
> MonoReflectionILGen *ilgen;
> MonoArray *parameters;
> guint32 attrs;
> guint32 iattrs;
> guint32 table_idx;
> guint32 call_conv;
> MonoObject *type;
> MonoArray *pinfo;
> MonoArray *cattrs;
> MonoBoolean init_locals;
> MonoArray *param_modreq;
> MonoArray *param_modopt;
> MonoArray *permissions;
>} MonoReflectionCtorBuilder;
>
>typedef struct {
> MonoObject object;
> MonoMethod *mhandle;
> MonoObject *rtype;
> MonoArray *parameters;
> guint32 attrs;
> guint32 iattrs;
> MonoString *name;
> guint32 table_idx;
> MonoArray *code;
> MonoReflectionILGen *ilgen;
> MonoObject *type;
> MonoArray *pinfo;
> MonoArray *cattrs;
> MonoReflectionMethod *override_method;
> MonoString *dll;
> MonoString *dllentry;
> guint32 charset;
> guint32 extra_flags;
> guint32 native_cc;
> guint32 call_conv;
> MonoBoolean init_locals;
> MonoGenericContainer *generic_container;
> MonoArray *generic_params;
> MonoArray *return_modreq;
> MonoArray *return_modopt;
> MonoArray *param_modreq;
> MonoArray *param_modopt;
> MonoArray *permissions;
>} MonoReflectionMethodBuilder;
>
>typedef struct {
> MonoObject object;
> MonoMethod *mhandle;
> MonoReflectionType *parent;
> MonoReflectionType *ret;
> MonoArray *parameters;
> MonoString *name;
> guint32 table_idx;
> guint32 call_conv;
>} MonoReflectionArrayMethod;
>
>typedef struct {
> MonoArray *data;
> MonoString *name;
> MonoString *filename;
> guint32 attrs;
> guint32 offset;
> MonoObject *stream;
>} MonoReflectionResource;
>
>typedef struct {
> guint32 res_type;
> guint32 res_id;
> guint32 lang_id;
> MonoArray *res_data;
>} MonoReflectionWin32Resource;
>
>typedef struct {
> guint32 action;
> MonoString *pset;
>} MonoReflectionPermissionSet;
>
>typedef struct {
> MonoReflectionAssembly assembly;
> MonoDynamicAssembly *dynamic_assembly;
> MonoReflectionMethod *entry_point;
> MonoArray *modules;
> MonoString *name;
> MonoString *dir;
> MonoArray *cattrs;
> MonoArray *resources;
> MonoArray *public_key;
> MonoString *version;
> MonoString *culture;
> guint32 algid;
> guint32 flags;
> guint32 pekind;
> MonoBoolean delay_sign;
> guint32 access;
> MonoArray *loaded_modules;
> MonoArray *win32_resources;
>
> MonoArray *permissions_minimum;
> MonoArray *permissions_optional;
> MonoArray *permissions_refused;
> gint32 pe_kind;
> gint32 machine;
> MonoBoolean corlib_internal;
> MonoArray *type_forwarders;
> MonoArray *pktoken;
>} MonoReflectionAssemblyBuilder;
>
>typedef struct {
> MonoObject object;
> guint32 attrs;
> MonoObject *type;
> MonoString *name;
> MonoObject *def_value;
> gint32 offset;
> gint32 table_idx;
> MonoReflectionType *typeb;
> MonoArray *rva_data;
> MonoArray *cattrs;
> MonoReflectionMarshal *marshal_info;
> MonoClassField *handle;
> MonoArray *modreq;
> MonoArray *modopt;
>} MonoReflectionFieldBuilder;
>
>typedef struct {
> MonoObject object;
> guint32 attrs;
> MonoString *name;
> MonoObject *type;
> MonoArray *parameters;
> MonoArray *cattrs;
> MonoObject *def_value;
> MonoReflectionMethodBuilder *set_method;
> MonoReflectionMethodBuilder *get_method;
> gint32 table_idx;
> MonoObject *type_builder;
> MonoArray *returnModReq;
> MonoArray *returnModOpt;
> MonoArray *paramModReq;
> MonoArray *paramModOpt;
> guint32 call_conv;
>} MonoReflectionPropertyBuilder;
>
>struct _MonoReflectionModule {
> MonoObject obj;
> MonoImage *image;
> MonoReflectionAssembly *assembly;
> MonoString *fqname;
> MonoString *name;
> MonoString *scopename;
> MonoBoolean is_resource;
> guint32 token;
>};
>
>typedef struct {
> MonoReflectionModule module;
> MonoDynamicImage *dynamic_image;
> gint32 num_types;
> MonoArray *types;
> MonoArray *cattrs;
> MonoArray *guid;
> guint32 table_idx;
> MonoReflectionAssemblyBuilder *assemblyb;
> MonoArray *global_methods;
> MonoArray *global_fields;
> gboolean is_main;
> MonoArray *resources;
>} MonoReflectionModuleBuilder;
>
>typedef struct {
> MonoReflectionType type;
> MonoString *name;
> MonoString *nspace;
> MonoObject *parent;
> MonoReflectionType *nesting_type;
> MonoArray *interfaces;
> gint32 num_methods;
> MonoArray *methods;
> MonoArray *ctors;
> MonoArray *properties;
> gint32 num_fields;
> MonoArray *fields;
> MonoArray *events;
> MonoArray *cattrs;
> MonoArray *subtypes;
> guint32 attrs;
> guint32 table_idx;
> MonoReflectionModuleBuilder *module;
> gint32 class_size;
> gint32 packing_size;
> MonoGenericContainer *generic_container;
> MonoArray *generic_params;
> MonoArray *permissions;
> MonoReflectionType *created;
>} MonoReflectionTypeBuilder;
>
>typedef struct {
> MonoReflectionType type;
> MonoReflectionType *element_type;
> int rank;
>} MonoReflectionArrayType;
>
>typedef struct {
> MonoReflectionType type;
> MonoReflectionType *element_type;
>} MonoReflectionDerivedType;
>
>typedef struct {
> MonoReflectionType type;
> MonoReflectionTypeBuilder *tbuilder;
> MonoReflectionMethodBuilder *mbuilder;
> MonoString *name;
> guint32 index;
> MonoReflectionType *base_type;
> MonoArray *iface_constraints;
> MonoArray *cattrs;
> guint32 attrs;
>} MonoReflectionGenericParam;
>
>typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass;
>struct _MonoReflectionGenericClass {
> MonoReflectionType type;
> MonoReflectionType *generic_type;
> MonoArray *type_arguments;
> guint32 initialized;
>};
>
>typedef struct {
> MonoObject obj;
> MonoString *name;
> MonoString *codebase;
> gint32 major, minor, build, revision;
> MonoObject *cultureInfo;
> guint32 flags;
> guint32 hashalg;
> MonoObject *keypair;
> MonoArray *publicKey;
> MonoArray *keyToken;
> guint32 versioncompat;
> MonoObject *version;
> guint32 processor_architecture;
>} MonoReflectionAssemblyName;
>
>typedef struct {
> MonoObject obj;
> MonoString *name;
> MonoReflectionType *type;
> MonoReflectionTypeBuilder *typeb;
> MonoArray *cattrs;
> MonoReflectionMethodBuilder *add_method;
> MonoReflectionMethodBuilder *remove_method;
> MonoReflectionMethodBuilder *raise_method;
> MonoArray *other_methods;
> guint32 attrs;
> guint32 table_idx;
>} MonoReflectionEventBuilder;
>
>typedef struct {
> MonoObject obj;
> MonoReflectionMethod *ctor;
> MonoArray *data;
>} MonoReflectionCustomAttr;
>
>typedef struct {
> MonoObject object;
> gint32 call_conv;
> gint32 charset;
> MonoString *dll;
> MonoString *entry_point;
> MonoBoolean exact_spelling;
> MonoBoolean preserve_sig;
> MonoBoolean set_last_error;
> MonoBoolean best_fit_mapping;
> MonoBoolean throw_on_unmappable;
>} MonoReflectionDllImportAttribute;
>
>typedef struct {
> MonoObject object;
> gint32 call_conv;
> gint32 charset;
> MonoBoolean set_last_error;
> MonoBoolean best_fit_mapping;
> MonoBoolean throw_on_unmappable;
>} MonoReflectionUnmanagedFunctionPointerAttribute;
>
>typedef struct {
> MonoObject object;
> MonoString *guid;
>} MonoReflectionGuidAttribute;
>
>typedef struct {
> MonoObject object;
> MonoMethod *mhandle;
> MonoString *name;
> MonoReflectionType *rtype;
> MonoArray *parameters;
> guint32 attrs;
> guint32 call_conv;
> MonoReflectionModule *module;
> MonoBoolean skip_visibility;
> MonoBoolean init_locals;
> MonoReflectionILGen *ilgen;
> gint32 nrefs;
> MonoArray *refs;
> GSList *referenced_by;
> MonoReflectionType *owner;
>} MonoReflectionDynamicMethod;
>
>typedef struct {
> MonoObject object;
> MonoReflectionModuleBuilder *module;
> MonoArray *arguments;
> guint32 type;
> MonoReflectionType *return_type;
> guint32 call_conv;
> guint32 unmanaged_call_conv;
> MonoArray *modreqs;
> MonoArray *modopts;
>} MonoReflectionSigHelper;
>
>typedef struct {
> MonoObject object;
> MonoReflectionGenericClass *inst;
> MonoObject *fb;
>} MonoReflectionFieldOnTypeBuilderInst;
>
>typedef struct {
> MonoObject object;
> MonoReflectionGenericClass *inst;
> MonoObject *cb;
>} MonoReflectionCtorOnTypeBuilderInst;
>
>typedef struct {
> MonoObject object;
> MonoReflectionType *inst;
> MonoObject *mb;
> MonoArray *method_args;
> MonoReflectionMethodBuilder *generic_method_definition;
>} MonoReflectionMethodOnTypeBuilderInst;
>
>typedef struct {
> MonoObject object;
> MonoBoolean visible;
>} MonoReflectionComVisibleAttribute;
>
>enum {
> RESOURCE_LOCATION_EMBEDDED = 1,
> RESOURCE_LOCATION_ANOTHER_ASSEMBLY = 2,
> RESOURCE_LOCATION_IN_MANIFEST = 4
>};
>
>typedef struct {
> MonoObject object;
> MonoReflectionAssembly *assembly;
> MonoString *filename;
> guint32 location;
>} MonoManifestResourceInfo;
>
>
>typedef struct {
> MonoObject object;
> gpointer m_value;
>} MonoIntPtr;
>
>
>typedef enum {
> GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT = 0,
> GENERIC_PARAMETER_ATTRIBUTE_COVARIANT = 1,
> GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT = 2,
> GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK = 3,
>
> GENERIC_PARAMETER_ATTRIBUTE_NO_SPECIAL_CONSTRAINT = 0,
> GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT = 4,
> GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT = 8,
> GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT = 16,
> GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK = 28
>} GenericParameterAttributes;
>
>typedef struct {
> MonoType *type;
> MonoClassField *field;
> MonoProperty *prop;
>} CattrNamedArg;
>
>void mono_image_create_pefile (MonoReflectionModuleBuilder *module, HANDLE file) __attribute__ ((visibility ("hidden")));
>void mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly) __attribute__ ((visibility ("hidden")));
>MonoReflectionModule * mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name) __attribute__ ((visibility ("hidden")));
>guint32 mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str) __attribute__ ((visibility ("hidden")));
>guint32 mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj, gboolean create_methodspec, gboolean register_token) __attribute__ ((visibility ("hidden")));
>guint32 mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types) __attribute__ ((visibility ("hidden")));
>void mono_image_module_basic_init (MonoReflectionModuleBuilder *module) __attribute__ ((visibility ("hidden")));
>void mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj) __attribute__ ((visibility ("hidden")));
>void mono_dynamic_image_free (MonoDynamicImage *image) __attribute__ ((visibility ("hidden")));
>void mono_image_set_wrappers_type (MonoReflectionModuleBuilder *mb, MonoReflectionType *type) __attribute__ ((visibility ("hidden")));
>
>void mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb) __attribute__ ((visibility ("hidden")));
>
>void mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb) __attribute__ ((visibility ("hidden")));
>
>void mono_reflection_setup_generic_class (MonoReflectionTypeBuilder *tb) __attribute__ ((visibility ("hidden")));
>
>void mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb) __attribute__ ((visibility ("hidden")));
>
>MonoReflectionType* mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb) __attribute__ ((visibility ("hidden")));
>
>void mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides) __attribute__ ((visibility ("hidden")));
>
>void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m) __attribute__ ((visibility ("hidden")));
>void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod *mb) __attribute__ ((visibility ("hidden")));
>
>void mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam) __attribute__ ((visibility ("hidden")));
>void mono_reflection_create_unmanaged_type (MonoReflectionType *type) __attribute__ ((visibility ("hidden")));
>void mono_reflection_register_with_runtime (MonoReflectionType *type) __attribute__ ((visibility ("hidden")));
>
>void mono_reflection_create_custom_attr_data_args (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len, MonoArray **typed_args, MonoArray **named_args, CattrNamedArg **named_arg_info) __attribute__ ((visibility ("hidden")));
>MonoMethodSignature * mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token) __attribute__ ((visibility ("hidden")));
>
>MonoArray* mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass) __attribute__ ((visibility ("hidden")));
>
>MonoClass*
>mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic) __attribute__ ((visibility ("hidden")));
>MonoType*
>mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types) __attribute__ ((visibility ("hidden")));
>MonoReflectionMethod*
>mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types) __attribute__ ((visibility ("hidden")));
>void
>mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *methods, MonoArray *ctors, MonoArray *fields, MonoArray *properties, MonoArray *events) __attribute__ ((visibility ("hidden")));
>MonoReflectionEvent *
>mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb) __attribute__ ((visibility ("hidden")));
>
>MonoArray *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig) __attribute__ ((visibility ("hidden")));
>
>MonoArray *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig) __attribute__ ((visibility ("hidden")));
>
>MonoReflectionMarshal* mono_reflection_marshal_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_reflection_is_valid_dynamic_token (MonoDynamicImage *image, guint32 token) __attribute__ ((visibility ("hidden")));
>
>void
>mono_reflection_resolve_custom_attribute_data (MonoReflectionMethod *method, MonoReflectionAssembly *assembly, gpointer data, guint32 data_length, MonoArray **ctor_args, MonoArray ** named_args) __attribute__ ((visibility ("hidden")));
>
>MonoType*
>mono_reflection_type_get_handle (MonoReflectionType *ref) __attribute__ ((visibility ("hidden")));
>
>void
>mono_reflection_free_dynamic_generic_class (MonoGenericClass *gclass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_image_build_metadata (MonoReflectionModuleBuilder *module) __attribute__ ((visibility ("hidden")));
>
>int
>mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const char *blob, void *value) __attribute__ ((visibility ("hidden")));
>
>void
>mono_release_type_locks (MonoInternalThread *thread) __attribute__ ((visibility ("hidden")));
>
>char *
>mono_string_to_utf8_mp (MonoMemPool *mp, MonoString *s, MonoError *error) __attribute__ ((visibility ("hidden")));
>
>char *
>mono_string_to_utf8_image (MonoImage *image, MonoString *s, MonoError *error) __attribute__ ((visibility ("hidden")));
>
>
>MonoArray*
>mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array) __attribute__ ((visibility ("hidden")));
>
>void
>mono_array_full_copy (MonoArray *src, MonoArray *dest) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_array_calc_byte_len (MonoClass *class, uintptr_t len, uintptr_t *res) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxy *real_proxy) __attribute__ ((visibility ("hidden")));
>
>void
>mono_upgrade_remote_class (MonoDomain *domain, MonoObject *tproxy, MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_create_ftnptr (MonoDomain *domain, gpointer addr) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_get_addr_from_ftnptr (gpointer descr) __attribute__ ((visibility ("hidden")));
>
>void
>mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoObject*
>mono_nullable_box (guint8 *buf, MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>
>
>
>
>
>
>typedef union {
> int vtable_slot;
> gpointer target_code;
>} MonoImtItemValue;
>
>typedef struct _MonoImtBuilderEntry {
> gpointer key;
> struct _MonoImtBuilderEntry *next;
> MonoImtItemValue value;
> int children;
> guint8 has_target_code : 1;
>} MonoImtBuilderEntry;
>
>typedef struct _MonoIMTCheckItem MonoIMTCheckItem;
>
>struct _MonoIMTCheckItem {
> gpointer key;
> int check_target_idx;
> MonoImtItemValue value;
> guint8 *jmp_code;
> guint8 *code_target;
> guint8 is_equals;
> guint8 compare_done;
> guint8 chunk_size;
> guint8 short_branch;
> guint8 has_target_code;
>};
>
>typedef gpointer (*MonoImtThunkBuilder) (MonoVTable *vtable, MonoDomain *domain,
>  MonoIMTCheckItem **imt_entries, int count, gpointer fail_trunk);
>
>void
>mono_install_imt_thunk_builder (MonoImtThunkBuilder func) __attribute__ ((visibility ("hidden")));
>
>void
>mono_vtable_build_imt_slot (MonoVTable* vtable, int imt_slot) __attribute__ ((visibility ("hidden")));
>
>guint32
>mono_method_get_imt_slot (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>void
>mono_method_add_generic_virtual_invocation (MonoDomain *domain, MonoVTable *vtable,
>           gpointer *vtable_slot,
>           MonoMethod *method, gpointer code) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_method_alloc_generic_virtual_thunk (MonoDomain *domain, int size) __attribute__ ((visibility ("hidden")));
>
>typedef enum {
> MONO_UNHANDLED_POLICY_LEGACY,
> MONO_UNHANDLED_POLICY_CURRENT
>} MonoRuntimeUnhandledExceptionPolicy;
>
>MonoRuntimeUnhandledExceptionPolicy
>mono_runtime_unhandled_exception_policy_get (void) __attribute__ ((visibility ("hidden")));
>void
>mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy) __attribute__ ((visibility ("hidden")));
>
>MonoVTable *
>mono_class_try_get_vtable (MonoDomain *domain, MonoClass *class) __attribute__ ((visibility ("hidden")));
>
>MonoException *
>mono_runtime_class_init_full (MonoVTable *vtable, gboolean raise_exception) __attribute__ ((visibility ("hidden")));
>
>void
>mono_method_clear_object (MonoDomain *domain, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_compute_gc_descriptor (MonoClass *class) __attribute__ ((visibility ("hidden")));
>
>MonoObject*
>mono_object_xdomain_representation (MonoObject *obj, MonoDomain *target_domain, MonoObject **exc) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_is_reflection_method_or_constructor (MonoClass *class) __attribute__ ((visibility ("hidden")));
>
>MonoObject *
>mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_class_get_ref_info (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_set_ref_info (MonoClass *klass, gpointer obj) __attribute__ ((visibility ("hidden")));
>
>void
>mono_class_free_ref_info (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoObject *
>mono_object_new_pinned (MonoDomain *domain, MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>void
>mono_field_static_get_value_for_thread (MonoInternalThread *thread, MonoVTable *vt, MonoClassField *field, void *value) __attribute__ ((visibility ("hidden")));
># 17 "../../mono/metadata/marshal.h" 2
>
>
>
># 1 "../../mono/metadata/method-builder.h" 1
># 20 "../../mono/metadata/method-builder.h"
>
>
>typedef struct _MonoMethodBuilder {
> MonoMethod *method;
> char *name;
> GList *locals_list;
> int locals;
> gboolean dynamic;
> gboolean no_dup_name;
> gboolean skip_visibility;
> guint32 code_size, pos;
> unsigned char *code;
> int num_clauses;
> MonoExceptionClause *clauses;
>} MonoMethodBuilder;
>
>MonoMethodBuilder *
>mono_mb_new (MonoClass *klass, const char *name, MonoWrapperType type) __attribute__ ((visibility ("hidden")));
>
>MonoMethodBuilder *
>mono_mb_new_no_dup_name (MonoClass *klass, const char *name, MonoWrapperType type) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_free (MonoMethodBuilder *mb) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_patch_addr (MonoMethodBuilder *mb, int pos, int value) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_patch_addr_s (MonoMethodBuilder *mb, int pos, gint8 value) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_patch_branch (MonoMethodBuilder *mb, guint32 pos) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_patch_short_branch (MonoMethodBuilder *mb, guint32 pos) __attribute__ ((visibility ("hidden")));
>
>int
>mono_mb_get_label (MonoMethodBuilder *mb) __attribute__ ((visibility ("hidden")));
>
>int
>mono_mb_get_pos (MonoMethodBuilder *mb) __attribute__ ((visibility ("hidden")));
>
>guint32
>mono_mb_add_data (MonoMethodBuilder *mb, gpointer data) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_ptr (MonoMethodBuilder *mb, gpointer ptr) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_calli (MonoMethodBuilder *mb, MonoMethodSignature *sig) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_native_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, gpointer func) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_managed_call (MonoMethodBuilder *mb, MonoMethod *method, MonoMethodSignature *opt_sig) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_icall (MonoMethodBuilder *mb, gpointer func) __attribute__ ((visibility ("hidden")));
>
>int
>mono_mb_add_local (MonoMethodBuilder *mb, MonoType *type) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_mb_create_method (MonoMethodBuilder *mb, MonoMethodSignature *signature, int max_stack) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_ldarg (MonoMethodBuilder *mb, guint argnum) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_ldarg_addr (MonoMethodBuilder *mb, guint argnum) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_ldloc (MonoMethodBuilder *mb, guint num) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_ldloc_addr (MonoMethodBuilder *mb, guint locnum) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_stloc (MonoMethodBuilder *mb, guint num) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_exception (MonoMethodBuilder *mb, const char *exc_name, const char *msg) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_exception_full (MonoMethodBuilder *mb, const char *exc_nspace, const char *exc_name, const char *msg) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_icon (MonoMethodBuilder *mb, gint32 value) __attribute__ ((visibility ("hidden")));
>
>guint32
>mono_mb_emit_branch (MonoMethodBuilder *mb, guint8 op) __attribute__ ((visibility ("hidden")));
>
>guint32
>mono_mb_emit_short_branch (MonoMethodBuilder *mb, guint8 op) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_branch_label (MonoMethodBuilder *mb, guint8 op, guint32 label) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_add_to_local (MonoMethodBuilder *mb, guint16 local, gint32 incr) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_ldflda (MonoMethodBuilder *mb, gint32 offset) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_byte (MonoMethodBuilder *mb, guint8 op) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_i2 (MonoMethodBuilder *mb, gint16 data) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_i4 (MonoMethodBuilder *mb, gint32 data) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_op (MonoMethodBuilder *mb, guint8 op, gpointer data) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_emit_ldstr (MonoMethodBuilder *mb, char *str) __attribute__ ((visibility ("hidden")));
>
>void
>mono_mb_set_clauses (MonoMethodBuilder *mb, int num_clauses, MonoExceptionClause *clauses) __attribute__ ((visibility ("hidden")));
>
>
># 21 "../../mono/metadata/marshal.h" 2
># 34 "../../mono/metadata/marshal.h"
>typedef struct {
> MonoMethodBuilder *mb;
> MonoMethodSignature *sig;
> MonoMethodPInvoke *piinfo;
> int *orig_conv_args;
> int retobj_var;
> MonoClass *retobj_class;
> MonoMethodSignature *csig;
> MonoImage *image;
>} EmitMarshalContext;
>
>typedef enum {
>
>
>
>
>
>
>
> MARSHAL_ACTION_CONV_IN,
>
>
>
>
>
> MARSHAL_ACTION_PUSH,
>
>
>
>
>
> MARSHAL_ACTION_CONV_OUT,
>
>
>
>
>
>
> MARSHAL_ACTION_CONV_RESULT,
>
> MARSHAL_ACTION_MANAGED_CONV_IN,
> MARSHAL_ACTION_MANAGED_CONV_OUT,
> MARSHAL_ACTION_MANAGED_CONV_RESULT
>} MarshalAction;
>
>typedef struct {
> guint32 rank, elem_size;
>} ElementAddrWrapperInfo;
>
>
>
>
>typedef MonoObject *(*RuntimeInvokeFunction) (MonoObject *this, void **params, MonoObject **exc, void* compiled_method);
>
>typedef void (*RuntimeInvokeDynamicFunction) (void *args, MonoObject **exc, void* compiled_method);
>
>
>
>void
>mono_marshal_init (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_marshal_cleanup (void) __attribute__ ((visibility ("hidden")));
>
>gint32
>mono_class_native_size (MonoClass *klass, guint32 *align) __attribute__ ((visibility ("hidden")));
>
>MonoMarshalType *
>mono_marshal_load_type_info (MonoClass* klass) __attribute__ ((visibility ("hidden")));
>
>gint32
>mono_marshal_type_size (MonoType *type, MonoMarshalSpec *mspec, guint32 *align,
>   gboolean as_field, gboolean unicode) __attribute__ ((visibility ("hidden")));
>
>int
>mono_type_native_stack_size (MonoType *type, guint32 *alignment) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_array_to_savearray (MonoArray *array) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_array_to_lparray (MonoArray *array) __attribute__ ((visibility ("hidden")));
>
>void
>mono_free_lparray (MonoArray *array, gpointer* nativeArray) __attribute__ ((visibility ("hidden")));
>
>void
>mono_string_utf8_to_builder (MonoStringBuilder *sb, char *text) __attribute__ ((visibility ("hidden")));
>
>void
>mono_string_utf16_to_builder (MonoStringBuilder *sb, gunichar2 *text) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_string_builder_to_utf8 (MonoStringBuilder *sb) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_string_builder_to_utf16 (MonoStringBuilder *sb) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_string_to_ansibstr (MonoString *string_obj) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_string_to_bstr (MonoString *string_obj) __attribute__ ((visibility ("hidden")));
>
>void
>mono_string_to_byvalstr (gpointer dst, MonoString *src, int size) __attribute__ ((visibility ("hidden")));
>
>void
>mono_string_to_byvalwstr (gpointer dst, MonoString *src, int size) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_delegate_to_ftnptr (MonoDelegate *delegate) __attribute__ ((visibility ("hidden")));
>
>MonoDelegate*
>mono_ftnptr_to_delegate (MonoClass *klass, gpointer ftn) __attribute__ ((visibility ("hidden")));
>
>void mono_delegate_free_ftnptr (MonoDelegate *delegate) __attribute__ ((visibility ("hidden")));
>
>void
>mono_marshal_set_last_error (void) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_marshal_asany (MonoObject *obj, MonoMarshalNative string_encoding, int param_attrs) __attribute__ ((visibility ("hidden")));
>
>void
>mono_marshal_free_asany (MonoObject *o, gpointer ptr, MonoMarshalNative string_encoding, int param_attrs) __attribute__ ((visibility ("hidden")));
>
>guint
>mono_type_to_ldind (MonoType *type) __attribute__ ((visibility ("hidden")));
>
>guint
>mono_type_to_stind (MonoType *type) __attribute__ ((visibility ("hidden")));
>
>
>
>MonoMethod *
>mono_marshal_method_from_wrapper (MonoMethod *wrapper) __attribute__ ((visibility ("hidden")));
>
>void
>mono_marshal_set_wrapper_info (MonoMethod *method, gpointer data) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_marshal_get_wrapper_info (MonoMethod *wrapper) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_remoting_invoke (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_xappdomain_invoke (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_remoting_invoke_for_target (MonoMethod *method, MonoRemotingTarget target_type) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_remoting_invoke_with_check (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_delegate_begin_invoke (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_delegate_end_invoke (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_delegate_invoke (MonoMethod *method, MonoDelegate *del) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_runtime_invoke (MonoMethod *method, gboolean virtual) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_marshal_get_runtime_invoke_dynamic (void) __attribute__ ((visibility ("hidden")));
>
>MonoMethodSignature*
>mono_marshal_get_string_ctor_signature (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_managed_wrapper (MonoMethod *method, MonoClass *delegate_klass, uint32_t this_loc) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_marshal_get_vtfixup_ftnptr (MonoImage *image, guint32 token, guint16 type) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_icall_wrapper (MonoMethodSignature *sig, const char *name, gconstpointer func, gboolean check_exceptions) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_native_wrapper (MonoMethod *method, gboolean check_exceptions, gboolean aot) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_native_func_wrapper (MonoImage *image, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_struct_to_ptr (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_ptr_to_struct (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_stfld_wrapper (MonoType *type) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_ldfld_wrapper (MonoType *type) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_ldflda_wrapper (MonoType *type) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_ldfld_remote_wrapper (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_stfld_remote_wrapper (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_synchronized_wrapper (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_unbox_wrapper (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_castclass_with_cache (void) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_isinst_with_cache (void) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_isinst (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_castclass (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_proxy_cancast (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_stelemref (void) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_marshal_get_virtual_stelemref (MonoClass *array_class) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_marshal_get_array_address (int rank, int elem_size) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_generic_array_helper (MonoClass *class, MonoClass *iface,
>           gchar *name, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>MonoMethod *
>mono_marshal_get_thunk_invoke_wrapper (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>void
>mono_marshal_free_dynamic_wrappers (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>void
>mono_marshal_free_inflated_wrappers (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>
>
>void *
>mono_marshal_alloc (gulong size) __attribute__ ((visibility ("hidden")));
>
>void
>mono_marshal_free (gpointer ptr) __attribute__ ((visibility ("hidden")));
>
>void
>mono_marshal_free_array (gpointer *ptr, int size) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_marshal_free_ccw (MonoObject* obj) __attribute__ ((visibility ("hidden")));
>
>MonoObject *
>mono_marshal_xdomain_copy_value (MonoObject *val) __attribute__ ((visibility ("hidden")));
>
>void
>cominterop_release_all_rcws (void) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_copy_to_unmanaged (MonoArray *src, gint32 start_index,
>            gpointer dest, gint32 length) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_copy_from_unmanaged (gpointer src, gint32 start_index,
>              MonoArray *dest, gint32 length) __attribute__ ((visibility ("hidden")));
>
>gpointer
>ves_icall_System_Runtime_InteropServices_Marshal_ReadIntPtr (gpointer ptr, gint32 offset) __attribute__ ((visibility ("hidden")));
>
>unsigned char
>ves_icall_System_Runtime_InteropServices_Marshal_ReadByte (gpointer ptr, gint32 offset) __attribute__ ((visibility ("hidden")));
>
>gint16
>ves_icall_System_Runtime_InteropServices_Marshal_ReadInt16 (gpointer ptr, gint32 offset) __attribute__ ((visibility ("hidden")));
>
>gint32
>ves_icall_System_Runtime_InteropServices_Marshal_ReadInt32 (gpointer ptr, gint32 offset) __attribute__ ((visibility ("hidden")));
>
>gint64
>ves_icall_System_Runtime_InteropServices_Marshal_ReadInt64 (gpointer ptr, gint32 offset) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_WriteByte (gpointer ptr, gint32 offset, unsigned char val) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_WriteIntPtr (gpointer ptr, gint32 offset, gpointer val) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_WriteInt16 (gpointer ptr, gint32 offset, gint16 val) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_WriteInt32 (gpointer ptr, gint32 offset, gint32 val) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_WriteInt64 (gpointer ptr, gint32 offset, gint64 val) __attribute__ ((visibility ("hidden")));
>
>MonoString *
>ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr) __attribute__ ((visibility ("hidden")));
>
>MonoString *
>ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi_len (char *ptr, gint32 len) __attribute__ ((visibility ("hidden")));
>
>MonoString *
>ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni (guint16 *ptr) __attribute__ ((visibility ("hidden")));
>
>MonoString *
>ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni_len (guint16 *ptr, gint32 len) __attribute__ ((visibility ("hidden")));
>
>MonoString *
>ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringBSTR (gpointer ptr) __attribute__ ((visibility ("hidden")));
>
>guint32
>ves_icall_System_Runtime_InteropServices_Marshal_GetComSlotForMethodInfoInternal (MonoReflectionMethod *m) __attribute__ ((visibility ("hidden")));
>
>guint32
>ves_icall_System_Runtime_InteropServices_Marshal_GetLastWin32Error (void) __attribute__ ((visibility ("hidden")));
>
>guint32
>ves_icall_System_Runtime_InteropServices_Marshal_SizeOf (MonoReflectionType *rtype) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_StructureToPtr (MonoObject *obj, gpointer dst, MonoBoolean delete_old) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure (gpointer src, MonoObject *dst) __attribute__ ((visibility ("hidden")));
>
>MonoObject *
>ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure_type (gpointer src, MonoReflectionType *type) __attribute__ ((visibility ("hidden")));
>
>int
>ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf (MonoReflectionType *type, MonoString *field_name) __attribute__ ((visibility ("hidden")));
>
>gpointer
>ves_icall_System_Runtime_InteropServices_Marshal_StringToBSTR (MonoString *string) __attribute__ ((visibility ("hidden")));
>
>gpointer
>ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (MonoString *string) __attribute__ ((visibility ("hidden")));
>
>gpointer
>ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalUni (MonoString *string) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_DestroyStructure (gpointer src, MonoReflectionType *type) __attribute__ ((visibility ("hidden")));
>
>void*
>ves_icall_System_Runtime_InteropServices_Marshal_AllocCoTaskMem (int size) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_FreeCoTaskMem (void *ptr) __attribute__ ((visibility ("hidden")));
>
>gpointer
>ves_icall_System_Runtime_InteropServices_Marshal_ReAllocCoTaskMem (gpointer ptr, int size) __attribute__ ((visibility ("hidden")));
>
>void*
>ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal (int size) __attribute__ ((visibility ("hidden")));
>
>gpointer
>ves_icall_System_Runtime_InteropServices_Marshal_ReAllocHGlobal (gpointer ptr, int size) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal (void *ptr) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_Runtime_InteropServices_Marshal_FreeBSTR (void *ptr) __attribute__ ((visibility ("hidden")));
>
>void*
>ves_icall_System_Runtime_InteropServices_Marshal_UnsafeAddrOfPinnedArrayElement (MonoArray *arrayobj, int index) __attribute__ ((visibility ("hidden")));
>
>MonoDelegate*
>ves_icall_System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointerInternal (void *ftn, MonoReflectionType *type) __attribute__ ((visibility ("hidden")));
>
>int
>ves_icall_System_Runtime_InteropServices_Marshal_AddRefInternal (gpointer pUnk) __attribute__ ((visibility ("hidden")));
>
>int
>ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal (gpointer pUnk, gpointer riid, gpointer* ppv) __attribute__ ((visibility ("hidden")));
>
>int
>ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (gpointer pUnk) __attribute__ ((visibility ("hidden")));
>
>void*
>ves_icall_System_Runtime_InteropServices_Marshal_GetIUnknownForObjectInternal (MonoObject* object) __attribute__ ((visibility ("hidden")));
>
>MonoObject*
>ves_icall_System_Runtime_InteropServices_Marshal_GetObjectForCCW (void* pUnk) __attribute__ ((visibility ("hidden")));
>
>void*
>ves_icall_System_Runtime_InteropServices_Marshal_GetIDispatchForObjectInternal (MonoObject* object) __attribute__ ((visibility ("hidden")));
>
>void*
>ves_icall_System_Runtime_InteropServices_Marshal_GetCCW (MonoObject* object, MonoReflectionType* type) __attribute__ ((visibility ("hidden")));
>
>MonoBoolean
>ves_icall_System_Runtime_InteropServices_Marshal_IsComObject (MonoObject* object) __attribute__ ((visibility ("hidden")));
>
>gint32
>ves_icall_System_Runtime_InteropServices_Marshal_ReleaseComObjectInternal (MonoObject* object) __attribute__ ((visibility ("hidden")));
>
>MonoObject *
>ves_icall_System_ComObject_CreateRCW (MonoReflectionType *type) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_System_ComObject_ReleaseInterfaces(MonoComObject* obj) __attribute__ ((visibility ("hidden")));
>
>gpointer
>ves_icall_System_ComObject_GetInterfaceInternal (MonoComObject* obj, MonoReflectionType* type, MonoBoolean throw_exception) __attribute__ ((visibility ("hidden")));
>
>void
>ves_icall_Mono_Interop_ComInteropProxy_AddProxy (gpointer pUnk, MonoComInteropProxy* proxy) __attribute__ ((visibility ("hidden")));
>
>MonoComInteropProxy*
>ves_icall_Mono_Interop_ComInteropProxy_FindProxy (gpointer pUnk) __attribute__ ((visibility ("hidden")));
>
>void
>mono_win32_compat_CopyMemory (gpointer dest, gconstpointer source, gsize length);
>
>void
>mono_win32_compat_FillMemory (gpointer dest, gsize length, guchar fill);
>
>void
>mono_win32_compat_MoveMemory (gpointer dest, gconstpointer source, gsize length);
>
>void
>mono_win32_compat_ZeroMemory (gpointer dest, gsize length);
>
>void
>mono_marshal_find_nonzero_bit_offset (guint8 *buf, int len, int *byte_offset, guint8 *bitmask) __attribute__ ((visibility ("hidden")));
>
>MonoMethodSignature*
>mono_signature_no_pinvoke (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>
>
>void
>mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func, gboolean aot, gboolean check_exceptions) __attribute__ ((visibility ("hidden")));
>
>void
>mono_marshal_emit_managed_wrapper (MonoMethodBuilder *mb, MonoMethodSignature *invoke_sig, MonoMarshalSpec **mspecs, EmitMarshalContext* m, MonoMethod *method, uint32_t target_handle) __attribute__ ((visibility ("hidden")));
>
>GHashTable*
>mono_marshal_get_cache (GHashTable **var, GHashFunc hash_func, GCompareFunc equal_func) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_marshal_find_in_cache (GHashTable *cache, gpointer key) __attribute__ ((visibility ("hidden")));
>
>MonoMethod*
>mono_mb_create_and_cache (GHashTable *cache, gpointer key,
>        MonoMethodBuilder *mb, MonoMethodSignature *sig,
>        int max_stack) __attribute__ ((visibility ("hidden")));
>void
>mono_marshal_emit_thread_interrupt_checkpoint (MonoMethodBuilder *mb) __attribute__ ((visibility ("hidden")));
>
>
># 46 "method-to-ir.c" 2
># 1 "../../mono/metadata/debug-helpers.h" 1
>
>
>
>
>
>
>
>typedef struct MonoDisHelper MonoDisHelper;
>
>typedef char* (*MonoDisIndenter) (MonoDisHelper *dh, MonoMethod *method, uint32_t ip_offset);
>typedef char* (*MonoDisTokener) (MonoDisHelper *dh, MonoMethod *method, uint32_t token);
>
>struct MonoDisHelper {
> const char *newline;
> const char *label_format;
> const char *label_target;
> MonoDisIndenter indenter;
> MonoDisTokener tokener;
> void* user_data;
>};
>
>char* mono_disasm_code_one (MonoDisHelper *dh, MonoMethod *method, const mono_byte *ip, const mono_byte** endp);
>char* mono_disasm_code (MonoDisHelper *dh, MonoMethod *method, const mono_byte *ip, const mono_byte* end);
>
>typedef struct MonoMethodDesc MonoMethodDesc;
>
>char* mono_type_full_name (MonoType *type);
>
>char* mono_signature_get_desc (MonoMethodSignature *sig, mono_bool include_namespace);
>
>char* mono_context_get_desc (MonoGenericContext *context);
>
>MonoMethodDesc* mono_method_desc_new (const char *name, mono_bool include_namespace);
>MonoMethodDesc* mono_method_desc_from_method (MonoMethod *method);
>void mono_method_desc_free (MonoMethodDesc *desc);
>mono_bool mono_method_desc_match (MonoMethodDesc *desc, MonoMethod *method);
>mono_bool mono_method_desc_full_match (MonoMethodDesc *desc, MonoMethod *method);
>MonoMethod* mono_method_desc_search_in_class (MonoMethodDesc *desc, MonoClass *klass);
>MonoMethod* mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image);
>
>char* mono_method_full_name (MonoMethod *method, mono_bool signature);
>
>char* mono_field_full_name (MonoClassField *field);
>
>
># 47 "method-to-ir.c" 2
># 1 "../../mono/metadata/mono-debug.h" 1
># 13 "../../mono/metadata/mono-debug.h"
>
>
>typedef struct _MonoSymbolTable MonoSymbolTable;
>typedef struct _MonoDebugDataTable MonoDebugDataTable;
>
>typedef struct _MonoSymbolFile MonoSymbolFile;
>
>typedef struct _MonoDebugHandle MonoDebugHandle;
>
>typedef struct _MonoDebugLineNumberEntry MonoDebugLineNumberEntry;
>
>typedef struct _MonoDebugVarInfo MonoDebugVarInfo;
>typedef struct _MonoDebugMethodJitInfo MonoDebugMethodJitInfo;
>typedef struct _MonoDebugMethodAddress MonoDebugMethodAddress;
>typedef struct _MonoDebugMethodAddressList MonoDebugMethodAddressList;
>typedef struct _MonoDebugClassEntry MonoDebugClassEntry;
>
>typedef struct _MonoDebugMethodInfo MonoDebugMethodInfo;
>typedef struct _MonoDebugLocalsInfo MonoDebugLocalsInfo;
>typedef struct _MonoDebugSourceLocation MonoDebugSourceLocation;
>
>typedef struct _MonoDebugList MonoDebugList;
>
>typedef enum {
> MONO_DEBUG_FORMAT_NONE,
> MONO_DEBUG_FORMAT_MONO,
> MONO_DEBUG_FORMAT_DEBUGGER
>} MonoDebugFormat;
>
>
>
>
>
>
>struct _MonoDebugList {
> MonoDebugList *next;
> const void* data;
>};
>
>struct _MonoSymbolTable {
> uint64_t magic;
> uint32_t version;
> uint32_t total_size;
>
>
>
>
> MonoDebugHandle *corlib;
> MonoDebugDataTable *global_data_table;
> MonoDebugList *data_tables;
>
>
>
>
> MonoDebugList *symbol_files;
>};
>
>struct _MonoDebugHandle {
> uint32_t index;
> char *image_file;
> MonoImage *image;
> MonoDebugDataTable *type_table;
> MonoSymbolFile *symfile;
>};
>
>struct _MonoDebugMethodJitInfo {
> const mono_byte *code_start;
> uint32_t code_size;
> uint32_t prologue_end;
> uint32_t epilogue_begin;
> const mono_byte *wrapper_addr;
> uint32_t num_line_numbers;
> MonoDebugLineNumberEntry *line_numbers;
> uint32_t num_params;
> MonoDebugVarInfo *this_var;
> MonoDebugVarInfo *params;
> uint32_t num_locals;
> MonoDebugVarInfo *locals;
>};
>
>struct _MonoDebugMethodAddressList {
> uint32_t size;
> uint32_t count;
> mono_byte data [0];
>};
>
>struct _MonoDebugSourceLocation {
> char *source_file;
> uint32_t row, column;
> uint32_t il_offset;
>};
># 125 "../../mono/metadata/mono-debug.h"
>struct _MonoDebugVarInfo {
> uint32_t index;
> uint32_t offset;
> uint32_t size;
> uint32_t begin_scope;
> uint32_t end_scope;
> MonoType *type;
>};
>
>
>
>
>
>extern MonoSymbolTable *mono_symbol_table;
>extern MonoDebugFormat mono_debug_format;
>extern int32_t mono_debug_debugger_version;
>extern int32_t _mono_debug_using_mono_debugger;
>
>void mono_debug_list_add (MonoDebugList **list, const void* data);
>void mono_debug_list_remove (MonoDebugList **list, const void* data);
>
>void mono_debug_init (MonoDebugFormat format);
>void mono_debug_open_image_from_memory (MonoImage *image, const mono_byte *raw_contents, int size);
>void mono_debug_cleanup (void);
>
>void mono_debug_close_image (MonoImage *image);
>
>void mono_debug_domain_unload (MonoDomain *domain);
>void mono_debug_domain_create (MonoDomain *domain);
>
>mono_bool mono_debug_using_mono_debugger (void);
>
>MonoDebugMethodAddress *
>mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain);
>
>void
>mono_debug_remove_method (MonoMethod *method, MonoDomain *domain);
>
>MonoDebugMethodInfo *
>mono_debug_lookup_method (MonoMethod *method);
>
>MonoDebugMethodAddressList *
>mono_debug_lookup_method_addresses (MonoMethod *method);
>
>MonoDebugMethodJitInfo*
>mono_debug_find_method (MonoMethod *method, MonoDomain *domain);
>
>void
>mono_debug_free_method_jit_info (MonoDebugMethodJitInfo *jit);
>
>
>void
>mono_debug_add_delegate_trampoline (void* code, int size);
>
>MonoDebugLocalsInfo*
>mono_debug_lookup_locals (MonoMethod *method);
>
>
>
>
>
>MonoDebugSourceLocation *
>mono_debug_lookup_source_location (MonoMethod *method, uint32_t address, MonoDomain *domain);
>
>int32_t
>mono_debug_il_offset_from_address (MonoMethod *method, MonoDomain *domain, uint32_t native_offset);
>
>void
>mono_debug_free_source_location (MonoDebugSourceLocation *location);
>
>char *
>mono_debug_print_stack_frame (MonoMethod *method, uint32_t native_offset, MonoDomain *domain);
>
>
>
>
>
>
>
>int mono_debugger_method_has_breakpoint (MonoMethod *method);
>int mono_debugger_insert_breakpoint (const char *method_name, mono_bool include_namespace);
>
>void mono_set_is_debugger_attached (mono_bool attached);
>mono_bool mono_is_debugger_attached (void);
>
>
># 48 "method-to-ir.c" 2
># 1 "../../mono/metadata/gc-internal.h" 1
># 15 "../../mono/metadata/gc-internal.h"
># 1 "../../mono/utils/gc_wrapper.h" 1
>
>
>
>
>
>
>
># 1 "../../config.h" 1
># 9 "../../mono/utils/gc_wrapper.h" 2
># 79 "../../mono/utils/gc_wrapper.h"
>int mono_gc_pthread_create (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
>int mono_gc_pthread_join (pthread_t thread, void **retval);
>int mono_gc_pthread_detach (pthread_t thread);
># 16 "../../mono/metadata/gc-internal.h" 2
># 78 "../../mono/metadata/gc-internal.h"
>void mono_object_register_finalizer (MonoObject *obj) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_GC_InternalCollect (int generation) __attribute__ ((visibility ("hidden")));
>gint64 ves_icall_System_GC_GetTotalMemory (MonoBoolean forceCollection) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_GC_KeepAlive (MonoObject *obj) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_GC_ReRegisterForFinalize (MonoObject *obj) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_GC_SuppressFinalize (MonoObject *obj) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_GC_WaitForPendingFinalizers (void) __attribute__ ((visibility ("hidden")));
>
>MonoObject *ves_icall_System_GCHandle_GetTarget (guint32 handle) __attribute__ ((visibility ("hidden")));
>guint32 ves_icall_System_GCHandle_GetTargetHandle (MonoObject *obj, guint32 handle, gint32 type) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_GCHandle_FreeHandle (guint32 handle) __attribute__ ((visibility ("hidden")));
>gpointer ves_icall_System_GCHandle_GetAddrOfPinnedObject (guint32 handle) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_GC_register_ephemeron_array (MonoObject *array) __attribute__ ((visibility ("hidden")));
>MonoObject *ves_icall_System_GC_get_ephemeron_tombstone (void) __attribute__ ((visibility ("hidden")));
>
>extern void mono_gc_init (void) __attribute__ ((visibility ("hidden")));
>extern void mono_gc_base_init (void) __attribute__ ((visibility ("hidden")));
>extern void mono_gc_cleanup (void) __attribute__ ((visibility ("hidden")));
>extern void mono_gc_enable (void) __attribute__ ((visibility ("hidden")));
>extern void mono_gc_disable (void) __attribute__ ((visibility ("hidden")));
>
>
>
>
>
>extern gboolean mono_gc_is_gc_thread (void) __attribute__ ((visibility ("hidden")));
>
>
>
>
>
>extern gboolean mono_gc_register_thread (void *baseptr) __attribute__ ((visibility ("hidden")));
>
>extern gboolean mono_gc_is_finalizer_internal_thread (MonoInternalThread *thread) __attribute__ ((visibility ("hidden")));
>
>extern void mono_gc_set_stack_end (void *stack_end) __attribute__ ((visibility ("hidden")));
>
>
>
>
>extern gboolean mono_object_is_alive (MonoObject* obj);
>extern gboolean mono_gc_is_finalizer_thread (MonoThread *thread);
>extern gpointer mono_gc_out_of_memory (size_t size);
>extern void mono_gc_enable_events (void);
>
>
>void mono_gc_weak_link_add (void **link_addr, MonoObject *obj, gboolean track) __attribute__ ((visibility ("hidden")));
>void mono_gc_weak_link_remove (void **link_addr) __attribute__ ((visibility ("hidden")));
>MonoObject *mono_gc_weak_link_get (void **link_addr) __attribute__ ((visibility ("hidden")));
>
>
>void mono_gc_add_weak_track_handle (MonoObject *obj, guint32 gchandle) __attribute__ ((visibility ("hidden")));
>void mono_gc_change_weak_track_handle (MonoObject *old_obj, MonoObject *obj, guint32 gchandle) __attribute__ ((visibility ("hidden")));
>void mono_gc_remove_weak_track_handle (guint32 gchandle) __attribute__ ((visibility ("hidden")));
>GSList* mono_gc_remove_weak_track_object (MonoDomain *domain, MonoObject *obj) __attribute__ ((visibility ("hidden")));
>
>
>
>gboolean mono_gc_ephemeron_array_add (MonoObject *obj) __attribute__ ((visibility ("hidden")));
>
>
>MonoBoolean
>GCHandle_CheckCurrentDomain (guint32 gchandle) __attribute__ ((visibility ("hidden")));
>
>
>void* mono_gc_make_descr_from_bitmap (gsize *bitmap, int numbits) __attribute__ ((visibility ("hidden")));
>
>
>void* mono_gc_make_root_descr_all_refs (int numbits) __attribute__ ((visibility ("hidden")));
>
>
>
>
>
>
>typedef void (*MonoGCMarkFunc) (void **addr);
>typedef void (*MonoGCRootMarkFunc) (void *addr, MonoGCMarkFunc mark_func);
>
>
>void *mono_gc_make_root_descr_user (MonoGCRootMarkFunc marker);
># 167 "../../mono/metadata/gc-internal.h"
>void* mono_gc_alloc_fixed (size_t size, void *descr) __attribute__ ((visibility ("hidden")));
>void mono_gc_free_fixed (void* addr) __attribute__ ((visibility ("hidden")));
>
>
>gboolean mono_gchandle_is_in_domain (guint32 gchandle, MonoDomain *domain) __attribute__ ((visibility ("hidden")));
>void mono_gchandle_free_domain (MonoDomain *domain) __attribute__ ((visibility ("hidden")));
>
>typedef void (*FinalizerThreadCallback) (gpointer user_data);
>
>
>gboolean mono_gc_pending_finalizers (void) __attribute__ ((visibility ("hidden")));
>void mono_gc_finalize_notify (void) __attribute__ ((visibility ("hidden")));
>
>void* mono_gc_alloc_pinned_obj (MonoVTable *vtable, size_t size) __attribute__ ((visibility ("hidden")));
>void* mono_gc_alloc_obj (MonoVTable *vtable, size_t size) __attribute__ ((visibility ("hidden")));
>void* mono_gc_alloc_vector (MonoVTable *vtable, size_t size, uintptr_t max_length) __attribute__ ((visibility ("hidden")));
>void* mono_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length, uintptr_t bounds_size) __attribute__ ((visibility ("hidden")));
>void* mono_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len) __attribute__ ((visibility ("hidden")));
>void* mono_gc_make_descr_for_string (gsize *bitmap, int numbits) __attribute__ ((visibility ("hidden")));
>void* mono_gc_make_descr_for_object (gsize *bitmap, int numbits, size_t obj_size) __attribute__ ((visibility ("hidden")));
>void* mono_gc_make_descr_for_array (int vector, gsize *elem_bitmap, int numbits, size_t elem_size) __attribute__ ((visibility ("hidden")));
>
>void mono_gc_register_for_finalization (MonoObject *obj, void *user_data) __attribute__ ((visibility ("hidden")));
>void mono_gc_add_memory_pressure (gint64 value) __attribute__ ((visibility ("hidden")));
>int mono_gc_register_root (char *start, size_t size, void *descr) __attribute__ ((visibility ("hidden")));
>void mono_gc_deregister_root (char* addr) __attribute__ ((visibility ("hidden")));
>int mono_gc_finalizers_for_domain (MonoDomain *domain, MonoObject **out_array, int out_size) __attribute__ ((visibility ("hidden")));
>void mono_gc_run_finalize (void *obj, void *data) __attribute__ ((visibility ("hidden")));
>void mono_gc_clear_domain (MonoDomain * domain) __attribute__ ((visibility ("hidden")));
>void* mono_gc_alloc_mature (MonoVTable *vtable) __attribute__ ((visibility ("hidden")));
># 208 "../../mono/metadata/gc-internal.h"
>int mono_gc_register_root_wbarrier (char *start, size_t size, void *descr) __attribute__ ((visibility ("hidden")));
>
>void mono_gc_wbarrier_set_root (gpointer ptr, MonoObject *value) __attribute__ ((visibility ("hidden")));
>
>
>
>
>
>
>void mono_gc_finalize_threadpool_threads (void) __attribute__ ((visibility ("hidden")));
>
>
>
>
>typedef struct {
> const char *gc_name;
> int alloc_type;
>} AllocatorWrapperInfo;
>
>MonoMethod* mono_gc_get_managed_allocator (MonoVTable *vtable, gboolean for_box) __attribute__ ((visibility ("hidden")));
>MonoMethod* mono_gc_get_managed_array_allocator (MonoVTable *vtable, int rank) __attribute__ ((visibility ("hidden")));
>MonoMethod *mono_gc_get_managed_allocator_by_type (int atype) __attribute__ ((visibility ("hidden")));
>
>guint32 mono_gc_get_managed_allocator_types (void) __attribute__ ((visibility ("hidden")));
>
>
>const char *mono_gc_get_gc_name (void) __attribute__ ((visibility ("hidden")));
>
>
>MonoMethod* mono_gc_get_write_barrier (void) __attribute__ ((visibility ("hidden")));
>
>
>void mono_gc_wbarrier_value_copy_bitmap (gpointer dest, gpointer src, int size, unsigned bitmap) __attribute__ ((visibility ("hidden")));
>
>
>MonoString *mono_string_alloc (int length) __attribute__ ((visibility ("hidden")));
>
>
>
>
>
>typedef struct {
>
>
>
>
> gpointer (*thread_attach_func) (void);
>
>
>
>
> void (*thread_detach_func) (gpointer user_data);
>
>
>
>
>
>
> void (*thread_suspend_func) (gpointer user_data, void *sigcontext);
># 275 "../../mono/metadata/gc-internal.h"
> void (*thread_mark_func) (gpointer user_data, guint8 *stack_start, guint8 *stack_end, gboolean precise);
>} MonoGCCallbacks;
>
>
>void mono_gc_set_gc_callbacks (MonoGCCallbacks *callbacks) __attribute__ ((visibility ("hidden")));
>MonoGCCallbacks *mono_gc_get_gc_callbacks (void) __attribute__ ((visibility ("hidden")));
>
>
>
>
>void mono_gc_conservatively_scan_area (void *start, void *end) __attribute__ ((visibility ("hidden")));
>
>
>void *mono_gc_scan_object (void *obj) __attribute__ ((visibility ("hidden")));
>
>
>gsize* mono_gc_get_bitmap_for_descr (void *descr, int *numbits) __attribute__ ((visibility ("hidden")));
>
>
>
>int mono_gc_get_suspend_signal (void) __attribute__ ((visibility ("hidden")));
>
>
>
>
>char* mono_gc_get_description (void) __attribute__ ((visibility ("hidden")));
>
>
>
>
>void mono_gc_set_desktop_mode (void) __attribute__ ((visibility ("hidden")));
>
>
>
>
>gboolean mono_gc_is_moving (void) __attribute__ ((visibility ("hidden")));
>
>typedef void* (*MonoGCLockedCallbackFunc) (void *data);
>
>void* mono_gc_invoke_with_gc_lock (MonoGCLockedCallbackFunc func, void *data) __attribute__ ((visibility ("hidden")));
>
>int mono_gc_get_los_limit (void) __attribute__ ((visibility ("hidden")));
>
>guint8* mono_gc_get_card_table (int *shift_bits, gpointer *card_mask) __attribute__ ((visibility ("hidden")));
>
>void* mono_gc_get_nursery (int *shift_bits, size_t *size) __attribute__ ((visibility ("hidden")));
>
>
>
>
>gboolean mono_gc_is_disabled (void) __attribute__ ((visibility ("hidden")));
>
>
>
>
>
>
>gboolean mono_gc_parse_environment_string_extract_number (const char *str, glong *out) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_gc_precise_stack_mark_enabled (void) __attribute__ ((visibility ("hidden")));
>
>FILE *mono_gc_get_logfile (void) __attribute__ ((visibility ("hidden")));
>
>typedef void (*mono_reference_queue_callback) (void *user_data);
>
>typedef struct _MonoReferenceQueue MonoReferenceQueue;
>typedef struct _RefQueueEntry RefQueueEntry;
>
>struct _RefQueueEntry {
>
>
>
> guint32 gchandle;
>
> void *user_data;
> RefQueueEntry *next;
>};
>
>struct _MonoReferenceQueue {
> RefQueueEntry *queue;
> mono_reference_queue_callback callback;
> MonoReferenceQueue *next;
> gboolean should_be_deleted;
>};
>
>MonoReferenceQueue* mono_gc_reference_queue_new (mono_reference_queue_callback callback) __attribute__ ((visibility ("hidden")));
>void mono_gc_reference_queue_free (MonoReferenceQueue *queue) __attribute__ ((visibility ("hidden")));
>gboolean mono_gc_reference_queue_add (MonoReferenceQueue *queue, MonoObject *obj, void *user_data) __attribute__ ((visibility ("hidden")));
># 49 "method-to-ir.c" 2
># 1 "../../mono/metadata/security-manager.h" 1
># 15 "../../mono/metadata/security-manager.h"
># 1 "../../mono/metadata/object.h" 1
># 16 "../../mono/metadata/security-manager.h" 2
># 1 "../../mono/metadata/metadata-internals.h" 1
># 17 "../../mono/metadata/security-manager.h" 2
># 1 "../../mono/metadata/domain-internals.h" 1
># 18 "../../mono/metadata/security-manager.h" 2
># 1 "../../mono/metadata/tokentype.h" 1
># 19 "../../mono/metadata/security-manager.h" 2
># 1 "../../mono/metadata/threads.h" 1
># 20 "../../mono/metadata/security-manager.h" 2
># 1 "../../mono/metadata/marshal.h" 1
># 21 "../../mono/metadata/security-manager.h" 2
># 1 "../../mono/metadata/image.h" 1
># 22 "../../mono/metadata/security-manager.h" 2
># 1 "../../mono/metadata/reflection.h" 1
># 23 "../../mono/metadata/security-manager.h" 2
># 1 "../../mono/metadata/tabledefs.h" 1
># 24 "../../mono/metadata/security-manager.h" 2
># 35 "../../mono/metadata/security-manager.h"
>enum {
> MONO_METADATA_SECURITY_OK = 0x00,
> MONO_METADATA_INHERITANCEDEMAND_CLASS = 0x01,
> MONO_METADATA_INHERITANCEDEMAND_METHOD = 0x02
>};
>
>typedef enum {
> MONO_SECURITY_MODE_NONE,
> MONO_SECURITY_MODE_CORE_CLR,
> MONO_SECURITY_MODE_CAS,
> MONO_SECURITY_MODE_SMCS_HACK
>} MonoSecurityMode;
>
>
>
>typedef struct {
> MonoClass *securitymanager;
> MonoMethod *demand;
> MonoMethod *demandchoice;
> MonoMethod *demandunmanaged;
> MonoMethod *inheritancedemand;
> MonoMethod *inheritsecurityexception;
> MonoMethod *linkdemand;
> MonoMethod *linkdemandfulltrust;
> MonoMethod *linkdemandunmanaged;
> MonoMethod *linkdemandsecurityexception;
>
> MonoClass *allowpartiallytrustedcallers;
> MonoClass *suppressunmanagedcodesecurity;
>} MonoSecurityManager;
>
>
>void mono_activate_security_manager (void) __attribute__ ((visibility ("hidden")));
>gboolean mono_is_security_manager_active (void) __attribute__ ((visibility ("hidden")));
>MonoSecurityManager* mono_security_manager_get_methods (void) __attribute__ ((visibility ("hidden")));
>gboolean mono_is_ecma_key (const char *publickey, int size) __attribute__ ((visibility ("hidden")));
>MonoMethod* mono_get_context_capture_method (void) __attribute__ ((visibility ("hidden")));
>
>void mono_secman_inheritancedemand_class (MonoClass *klass, MonoClass *parent) __attribute__ ((visibility ("hidden")));
>void mono_secman_inheritancedemand_method (MonoMethod *override, MonoMethod *base) __attribute__ ((visibility ("hidden")));
>
>
>void mono_security_set_mode (MonoSecurityMode mode) __attribute__ ((visibility ("hidden")));
>MonoSecurityMode mono_security_get_mode (void) __attribute__ ((visibility ("hidden")));
>
>
>MonoBoolean ves_icall_System_Security_SecurityManager_get_SecurityEnabled (void) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Security_SecurityManager_set_SecurityEnabled (MonoBoolean value) __attribute__ ((visibility ("hidden")));
>MonoBoolean ves_icall_System_Security_SecurityManager_get_CheckExecutionRights (void) __attribute__ ((visibility ("hidden")));
>void ves_icall_System_Security_SecurityManager_set_CheckExecutionRights (MonoBoolean value) __attribute__ ((visibility ("hidden")));
>MonoBoolean ves_icall_System_Security_SecurityManager_GetLinkDemandSecurity (MonoReflectionMethod *m, MonoDeclSecurityActions *kactions, MonoDeclSecurityActions *mactions) __attribute__ ((visibility ("hidden")));
># 50 "method-to-ir.c" 2
>
># 1 "../../mono/metadata/security-core-clr.h" 1
># 15 "../../mono/metadata/security-core-clr.h"
>typedef enum {
>
>
> MONO_SECURITY_CORE_CLR_TRANSPARENT = 0,
> MONO_SECURITY_CORE_CLR_SAFE_CRITICAL,
> MONO_SECURITY_CORE_CLR_CRITICAL
>} MonoSecurityCoreCLRLevel;
>
>extern gboolean mono_security_core_clr_test;
>
>extern void mono_security_core_clr_check_inheritance (MonoClass *class) __attribute__ ((visibility ("hidden")));
>extern void mono_security_core_clr_check_override (MonoClass *class, MonoMethod *override, MonoMethod *base) __attribute__ ((visibility ("hidden")));
>
>extern void mono_security_core_clr_ensure_reflection_access_field (MonoClassField *field) __attribute__ ((visibility ("hidden")));
>extern void mono_security_core_clr_ensure_reflection_access_method (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>extern gboolean mono_security_core_clr_ensure_delegate_creation (MonoMethod *method, gboolean throwOnBindFailure) __attribute__ ((visibility ("hidden")));
>extern MonoException* mono_security_core_clr_ensure_dynamic_method_resolved_object (gpointer ref, MonoClass *handle_class) __attribute__ ((visibility ("hidden")));
>
>extern gboolean mono_security_core_clr_can_access_internals (MonoImage *accessing, MonoImage* accessed) __attribute__ ((visibility ("hidden")));
>
>extern MonoException* mono_security_core_clr_is_field_access_allowed (MonoMethod *caller, MonoClassField *field) __attribute__ ((visibility ("hidden")));
>extern MonoException* mono_security_core_clr_is_call_allowed (MonoMethod *caller, MonoMethod *callee) __attribute__ ((visibility ("hidden")));
>
>extern MonoSecurityCoreCLRLevel mono_security_core_clr_class_level (MonoClass *class) __attribute__ ((visibility ("hidden")));
>extern MonoSecurityCoreCLRLevel mono_security_core_clr_method_level (MonoMethod *method, gboolean with_class_level) __attribute__ ((visibility ("hidden")));
>
>extern gboolean mono_security_core_clr_is_platform_image (MonoImage *image) __attribute__ ((visibility ("hidden")));
>extern gboolean mono_security_core_clr_determine_platform_image (MonoImage *image) __attribute__ ((visibility ("hidden")));
>
>extern gboolean mono_security_core_clr_require_elevated_permissions (void);
># 52 "method-to-ir.c" 2
># 1 "../../mono/metadata/monitor.h" 1
># 17 "../../mono/metadata/monitor.h"
>
>
>void mono_locks_dump (gboolean include_untaken);
>
>void mono_monitor_init (void) __attribute__ ((visibility ("hidden")));
>void mono_monitor_cleanup (void) __attribute__ ((visibility ("hidden")));
>
>void** mono_monitor_get_object_monitor_weak_link (MonoObject *object) __attribute__ ((visibility ("hidden")));
>
>void mono_monitor_init_tls (void) __attribute__ ((visibility ("hidden")));
>
>MonoMethod* mono_monitor_get_fast_path (MonoMethod *enter_or_exit) __attribute__ ((visibility ("hidden")));
>
>void mono_monitor_threads_sync_members_offset (int *owner_offset, int *nest_offset, int *entry_count_offset) __attribute__ ((visibility ("hidden")));
>
>
>
>extern gboolean ves_icall_System_Threading_Monitor_Monitor_try_enter(MonoObject *obj, guint32 ms) __attribute__ ((visibility ("hidden")));
>extern gboolean ves_icall_System_Threading_Monitor_Monitor_test_owner(MonoObject *obj) __attribute__ ((visibility ("hidden")));
>extern gboolean ves_icall_System_Threading_Monitor_Monitor_test_synchronised(MonoObject *obj) __attribute__ ((visibility ("hidden")));
>extern void ves_icall_System_Threading_Monitor_Monitor_pulse(MonoObject *obj) __attribute__ ((visibility ("hidden")));
>extern void ves_icall_System_Threading_Monitor_Monitor_pulse_all(MonoObject *obj) __attribute__ ((visibility ("hidden")));
>extern gboolean ves_icall_System_Threading_Monitor_Monitor_wait(MonoObject *obj, guint32 ms) __attribute__ ((visibility ("hidden")));
>extern void ves_icall_System_Threading_Monitor_Monitor_try_enter_with_atomic_var (MonoObject *obj, guint32 ms, char *lockTaken) __attribute__ ((visibility ("hidden")));
>
>
># 53 "method-to-ir.c" 2
># 1 "../../mono/metadata/profiler-private.h" 1
>
>
>
>
># 1 "../../mono/metadata/profiler.h" 1
>
>
>
>
>
>
>
>
>
>
>typedef enum {
> MONO_PROFILE_NONE = 0,
> MONO_PROFILE_APPDOMAIN_EVENTS = 1 << 0,
> MONO_PROFILE_ASSEMBLY_EVENTS = 1 << 1,
> MONO_PROFILE_MODULE_EVENTS = 1 << 2,
> MONO_PROFILE_CLASS_EVENTS = 1 << 3,
> MONO_PROFILE_JIT_COMPILATION = 1 << 4,
> MONO_PROFILE_INLINING = 1 << 5,
> MONO_PROFILE_EXCEPTIONS = 1 << 6,
> MONO_PROFILE_ALLOCATIONS = 1 << 7,
> MONO_PROFILE_GC = 1 << 8,
> MONO_PROFILE_THREADS = 1 << 9,
> MONO_PROFILE_REMOTING = 1 << 10,
> MONO_PROFILE_TRANSITIONS = 1 << 11,
> MONO_PROFILE_ENTER_LEAVE = 1 << 12,
> MONO_PROFILE_COVERAGE = 1 << 13,
> MONO_PROFILE_INS_COVERAGE = 1 << 14,
> MONO_PROFILE_STATISTICAL = 1 << 15,
> MONO_PROFILE_METHOD_EVENTS = 1 << 16,
> MONO_PROFILE_MONITOR_EVENTS = 1 << 17,
> MONO_PROFILE_IOMAP_EVENTS = 1 << 18,
> MONO_PROFILE_GC_MOVES = 1 << 19,
> MONO_PROFILE_GC_ROOTS = 1 << 20
>} MonoProfileFlags;
>
>typedef enum {
> MONO_PROFILE_OK,
> MONO_PROFILE_FAILED
>} MonoProfileResult;
>
>typedef enum {
> MONO_GC_EVENT_START,
> MONO_GC_EVENT_MARK_START,
> MONO_GC_EVENT_MARK_END,
> MONO_GC_EVENT_RECLAIM_START,
> MONO_GC_EVENT_RECLAIM_END,
> MONO_GC_EVENT_END,
> MONO_GC_EVENT_PRE_STOP_WORLD,
> MONO_GC_EVENT_POST_STOP_WORLD,
> MONO_GC_EVENT_PRE_START_WORLD,
> MONO_GC_EVENT_POST_START_WORLD
>} MonoGCEvent;
>
>
>typedef struct {
> MonoMethod *method;
> int iloffset;
> int counter;
> const char *filename;
> int line;
> int col;
>} MonoProfileCoverageEntry;
>
>
>typedef enum {
> MONO_PROFILER_CODE_BUFFER_UNKNOWN,
> MONO_PROFILER_CODE_BUFFER_METHOD,
> MONO_PROFILER_CODE_BUFFER_LAST
>} MonoProfilerCodeBufferType;
>
>typedef struct _MonoProfiler MonoProfiler;
>
>typedef enum {
> MONO_PROFILER_MONITOR_CONTENTION = 1,
> MONO_PROFILER_MONITOR_DONE = 2,
> MONO_PROFILER_MONITOR_FAIL = 3
>} MonoProfilerMonitorEvent;
>
>typedef enum {
> MONO_PROFILER_CALL_CHAIN_NONE = 0,
> MONO_PROFILER_CALL_CHAIN_NATIVE = 1,
> MONO_PROFILER_CALL_CHAIN_GLIBC = 2,
> MONO_PROFILER_CALL_CHAIN_MANAGED = 3,
> MONO_PROFILER_CALL_CHAIN_INVALID = 4
>} MonoProfilerCallChainStrategy;
>
>typedef enum {
> MONO_PROFILER_GC_HANDLE_CREATED,
> MONO_PROFILER_GC_HANDLE_DESTROYED
>} MonoProfileGCHandleEvent;
>
>typedef enum {
> MONO_PROFILE_GC_ROOT_PINNING = 1 << 8,
> MONO_PROFILE_GC_ROOT_WEAKREF = 2 << 8,
> MONO_PROFILE_GC_ROOT_INTERIOR = 4 << 8,
>
> MONO_PROFILE_GC_ROOT_STACK = 0,
> MONO_PROFILE_GC_ROOT_FINALIZER = 1,
> MONO_PROFILE_GC_ROOT_HANDLE = 2,
> MONO_PROFILE_GC_ROOT_OTHER = 3,
> MONO_PROFILE_GC_ROOT_MISC = 4,
> MONO_PROFILE_GC_ROOT_TYPEMASK = 0xff
>} MonoProfileGCRootType;
>
>
>
>
>
>typedef void (*MonoProfileFunc) (MonoProfiler *prof);
>
>typedef void (*MonoProfileAppDomainFunc) (MonoProfiler *prof, MonoDomain *domain);
>typedef void (*MonoProfileMethodFunc) (MonoProfiler *prof, MonoMethod *method);
>typedef void (*MonoProfileClassFunc) (MonoProfiler *prof, MonoClass *klass);
>typedef void (*MonoProfileModuleFunc) (MonoProfiler *prof, MonoImage *module);
>typedef void (*MonoProfileAssemblyFunc) (MonoProfiler *prof, MonoAssembly *assembly);
>typedef void (*MonoProfileMonitorFunc) (MonoProfiler *prof, MonoObject *obj, MonoProfilerMonitorEvent event);
>
>typedef void (*MonoProfileExceptionFunc) (MonoProfiler *prof, MonoObject *object);
>typedef void (*MonoProfileExceptionClauseFunc) (MonoProfiler *prof, MonoMethod *method, int clause_type, int clause_num);
>
>typedef void (*MonoProfileAppDomainResult)(MonoProfiler *prof, MonoDomain *domain, int result);
>typedef void (*MonoProfileMethodResult) (MonoProfiler *prof, MonoMethod *method, int result);
>typedef void (*MonoProfileJitResult) (MonoProfiler *prof, MonoMethod *method, MonoJitInfo* jinfo, int result);
>typedef void (*MonoProfileClassResult) (MonoProfiler *prof, MonoClass *klass, int result);
>typedef void (*MonoProfileModuleResult) (MonoProfiler *prof, MonoImage *module, int result);
>typedef void (*MonoProfileAssemblyResult) (MonoProfiler *prof, MonoAssembly *assembly, int result);
>
>typedef void (*MonoProfileMethodInline) (MonoProfiler *prof, MonoMethod *parent, MonoMethod *child, int *ok);
>
>typedef void (*MonoProfileThreadFunc) (MonoProfiler *prof, uintptr_t tid);
>typedef void (*MonoProfileThreadNameFunc) (MonoProfiler *prof, uintptr_t tid, const char *name);
>typedef void (*MonoProfileAllocFunc) (MonoProfiler *prof, MonoObject *obj, MonoClass *klass);
>typedef void (*MonoProfileStatFunc) (MonoProfiler *prof, mono_byte *ip, void *context);
>typedef void (*MonoProfileStatCallChainFunc) (MonoProfiler *prof, int call_chain_depth, mono_byte **ip, void *context);
>typedef void (*MonoProfileGCFunc) (MonoProfiler *prof, MonoGCEvent event, int generation);
>typedef void (*MonoProfileGCMoveFunc) (MonoProfiler *prof, void **objects, int num);
>typedef void (*MonoProfileGCResizeFunc) (MonoProfiler *prof, int64_t new_size);
>typedef void (*MonoProfileGCHandleFunc) (MonoProfiler *prof, int op, int type, uintptr_t handle, MonoObject *obj);
>typedef void (*MonoProfileGCRootFunc) (MonoProfiler *prof, int num_roots, void **objects, int *root_types, uintptr_t *extra_info);
>
>typedef void (*MonoProfileIomapFunc) (MonoProfiler *prof, const char *report, const char *pathname, const char *new_pathname);
>
>typedef mono_bool (*MonoProfileCoverageFilterFunc) (MonoProfiler *prof, MonoMethod *method);
>
>typedef void (*MonoProfileCoverageFunc) (MonoProfiler *prof, const MonoProfileCoverageEntry *entry);
>
>typedef void (*MonoProfilerCodeChunkNew) (MonoProfiler *prof, void* chunk, int size);
>typedef void (*MonoProfilerCodeChunkDestroy) (MonoProfiler *prof, void* chunk);
>typedef void (*MonoProfilerCodeBufferNew) (MonoProfiler *prof, void* buffer, int size, MonoProfilerCodeBufferType type, void *data);
>
>
>
>
>void mono_profiler_install (MonoProfiler *prof, MonoProfileFunc shutdown_callback);
>void mono_profiler_set_events (MonoProfileFlags events);
>
>MonoProfileFlags mono_profiler_get_events (void);
>
>void mono_profiler_install_appdomain (MonoProfileAppDomainFunc start_load, MonoProfileAppDomainResult end_load,
>                                        MonoProfileAppDomainFunc start_unload, MonoProfileAppDomainFunc end_unload);
>void mono_profiler_install_assembly (MonoProfileAssemblyFunc start_load, MonoProfileAssemblyResult end_load,
>                                        MonoProfileAssemblyFunc start_unload, MonoProfileAssemblyFunc end_unload);
>void mono_profiler_install_module (MonoProfileModuleFunc start_load, MonoProfileModuleResult end_load,
>                                        MonoProfileModuleFunc start_unload, MonoProfileModuleFunc end_unload);
>void mono_profiler_install_class (MonoProfileClassFunc start_load, MonoProfileClassResult end_load,
>                                        MonoProfileClassFunc start_unload, MonoProfileClassFunc end_unload);
>
>void mono_profiler_install_jit_compile (MonoProfileMethodFunc start, MonoProfileMethodResult end);
>void mono_profiler_install_jit_end (MonoProfileJitResult end);
>void mono_profiler_install_method_free (MonoProfileMethodFunc callback);
>void mono_profiler_install_method_invoke (MonoProfileMethodFunc start, MonoProfileMethodFunc end);
>void mono_profiler_install_enter_leave (MonoProfileMethodFunc enter, MonoProfileMethodFunc fleave);
>void mono_profiler_install_thread (MonoProfileThreadFunc start, MonoProfileThreadFunc end);
>void mono_profiler_install_thread_name (MonoProfileThreadNameFunc thread_name_cb);
>void mono_profiler_install_transition (MonoProfileMethodResult callback);
>void mono_profiler_install_allocation (MonoProfileAllocFunc callback);
>void mono_profiler_install_monitor (MonoProfileMonitorFunc callback);
>void mono_profiler_install_statistical (MonoProfileStatFunc callback);
>void mono_profiler_install_statistical_call_chain (MonoProfileStatCallChainFunc callback, int call_chain_depth, MonoProfilerCallChainStrategy call_chain_strategy);
>void mono_profiler_install_exception (MonoProfileExceptionFunc throw_callback, MonoProfileMethodFunc exc_method_leave, MonoProfileExceptionClauseFunc clause_callback);
>void mono_profiler_install_coverage_filter (MonoProfileCoverageFilterFunc callback);
>void mono_profiler_coverage_get (MonoProfiler *prof, MonoMethod *method, MonoProfileCoverageFunc func);
>void mono_profiler_install_gc (MonoProfileGCFunc callback, MonoProfileGCResizeFunc heap_resize_callback);
>void mono_profiler_install_gc_moves (MonoProfileGCMoveFunc callback);
>void mono_profiler_install_gc_roots (MonoProfileGCHandleFunc handle_callback, MonoProfileGCRootFunc roots_callback);
>void mono_profiler_install_runtime_initialized (MonoProfileFunc runtime_initialized_callback);
>
>void mono_profiler_install_code_chunk_new (MonoProfilerCodeChunkNew callback);
>void mono_profiler_install_code_chunk_destroy (MonoProfilerCodeChunkDestroy callback);
>void mono_profiler_install_code_buffer_new (MonoProfilerCodeBufferNew callback);
>
>void mono_profiler_install_iomap (MonoProfileIomapFunc callback);
>
>void mono_profiler_load (const char *desc);
>
>
># 6 "../../mono/metadata/profiler-private.h" 2
>
>
>
>extern MonoProfileFlags mono_profiler_events;
>
>enum {
> MONO_PROFILE_START_LOAD,
> MONO_PROFILE_END_LOAD,
> MONO_PROFILE_START_UNLOAD,
> MONO_PROFILE_END_UNLOAD
>};
>
>typedef struct {
> int entries;
> struct {
>                guchar* cil_code;
>                int count;
>        } data [1];
>} MonoProfileCoverageInfo;
>
>void mono_profiler_shutdown (void) __attribute__ ((visibility ("hidden")));
>
>void mono_profiler_method_enter (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>void mono_profiler_method_leave (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>void mono_profiler_method_jit (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>void mono_profiler_method_end_jit (MonoMethod *method, MonoJitInfo* jinfo, int result) __attribute__ ((visibility ("hidden")));
>void mono_profiler_method_free (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>void mono_profiler_method_start_invoke (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>void mono_profiler_method_end_invoke (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>void mono_profiler_code_transition (MonoMethod *method, int result) __attribute__ ((visibility ("hidden")));
>void mono_profiler_allocation (MonoObject *obj, MonoClass *klass) __attribute__ ((visibility ("hidden")));
>void mono_profiler_monitor_event (MonoObject *obj, MonoProfilerMonitorEvent event) __attribute__ ((visibility ("hidden")));
>void mono_profiler_stat_hit (guchar *ip, void *context) __attribute__ ((visibility ("hidden")));
>void mono_profiler_stat_call_chain (int call_chain_depth, guchar **ips, void *context) __attribute__ ((visibility ("hidden")));
>int mono_profiler_stat_get_call_chain_depth (void) __attribute__ ((visibility ("hidden")));
>MonoProfilerCallChainStrategy mono_profiler_stat_get_call_chain_strategy (void) __attribute__ ((visibility ("hidden")));
>void mono_profiler_thread_start (gsize tid) __attribute__ ((visibility ("hidden")));
>void mono_profiler_thread_end (gsize tid) __attribute__ ((visibility ("hidden")));
>void mono_profiler_thread_name (gsize tid, const char *name) __attribute__ ((visibility ("hidden")));
>
>void mono_profiler_exception_thrown (MonoObject *exception) __attribute__ ((visibility ("hidden")));
>void mono_profiler_exception_method_leave (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>void mono_profiler_exception_clause_handler (MonoMethod *method, int clause_type, int clause_num) __attribute__ ((visibility ("hidden")));
>
>void mono_profiler_assembly_event (MonoAssembly *assembly, int code) __attribute__ ((visibility ("hidden")));
>void mono_profiler_assembly_loaded (MonoAssembly *assembly, int result) __attribute__ ((visibility ("hidden")));
>
>void mono_profiler_module_event (MonoImage *image, int code) __attribute__ ((visibility ("hidden")));
>void mono_profiler_module_loaded (MonoImage *image, int result) __attribute__ ((visibility ("hidden")));
>
>void mono_profiler_class_event (MonoClass *klass, int code) __attribute__ ((visibility ("hidden")));
>void mono_profiler_class_loaded (MonoClass *klass, int result) __attribute__ ((visibility ("hidden")));
>
>void mono_profiler_appdomain_event (MonoDomain *domain, int code) __attribute__ ((visibility ("hidden")));
>void mono_profiler_appdomain_loaded (MonoDomain *domain, int result) __attribute__ ((visibility ("hidden")));
>
>void mono_profiler_iomap (char *report, const char *pathname, const char *new_pathname) __attribute__ ((visibility ("hidden")));
>
>MonoProfileCoverageInfo* mono_profiler_coverage_alloc (MonoMethod *method, int entries) __attribute__ ((visibility ("hidden")));
>void mono_profiler_coverage_free (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>void mono_profiler_gc_event (MonoGCEvent e, int generation) __attribute__ ((visibility ("hidden")));
>void mono_profiler_gc_heap_resize (gint64 new_size) __attribute__ ((visibility ("hidden")));
>void mono_profiler_gc_moves (void **objects, int num) __attribute__ ((visibility ("hidden")));
>void mono_profiler_gc_handle (int op, int type, uintptr_t handle, MonoObject *obj) __attribute__ ((visibility ("hidden")));
>void mono_profiler_gc_roots (int num, void **objects, int *root_types, uintptr_t *extra_info) __attribute__ ((visibility ("hidden")));
>
>void mono_profiler_code_chunk_new (gpointer chunk, int size) __attribute__ ((visibility ("hidden")));
>void mono_profiler_code_chunk_destroy (gpointer chunk) __attribute__ ((visibility ("hidden")));
>void mono_profiler_code_buffer_new (gpointer buffer, int size, MonoProfilerCodeBufferType type, void *data) __attribute__ ((visibility ("hidden")));
>
>void mono_profiler_runtime_initialized (void) __attribute__ ((visibility ("hidden")));
># 54 "method-to-ir.c" 2
>
>
># 1 "../../mono/metadata/mono-basic-block.h" 1
>
>
>
>
>
>
>
>
>typedef struct _MonoSimpleBasicBlock MonoSimpleBasicBlock;
>
>struct _MonoSimpleBasicBlock {
> MonoSimpleBasicBlock *next, *left, *right, *parent;
> GSList *out_bb;
> int start, end;
> unsigned colour : 1;
> unsigned dead : 1;
>};
>
>
>MonoSimpleBasicBlock*
>mono_basic_block_split (MonoMethod *method, MonoError *error) __attribute__ ((visibility ("hidden")));
>
>void
>mono_basic_block_free (MonoSimpleBasicBlock *bb) __attribute__ ((visibility ("hidden")));
>
>
>
>int
>mono_opcode_value_and_size (const unsigned char **ip, const unsigned char *end, int *value) __attribute__ ((visibility ("hidden")));
>
>int
>mono_opcode_size (const unsigned char *ip, const unsigned char *end) __attribute__ ((visibility ("hidden")));
>
>
># 57 "method-to-ir.c" 2
>
># 1 "mini.h" 1
>
>
>
># 1 "../../config.h" 1
># 5 "mini.h" 2
># 33 "mini.h"
>typedef gint64 mgreg_t;
>
>
># 1 "mini-arch.h" 1
># 14 "mini-arch.h"
># 1 "mini-s390x.h" 1
>
>
>
># 1 "../../mono/arch/s390x/s390x-codegen.h" 1
>
>
>
>
>
>
>
># 1 "/usr/include/assert.h" 1 3 4
># 64 "/usr/include/assert.h" 3 4
>
>
>
>extern void __assert_fail (const char *__assertion, const char *__file,
>      unsigned int __line, const char *__function)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
>      unsigned int __line, const char *__function)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
># 9 "../../mono/arch/s390x/s390x-codegen.h" 2
># 78 "../../mono/arch/s390x/s390x-codegen.h"
>typedef enum {
> s390_r0 = 0,
> s390_r1,
> s390_r2,
> s390_r3,
> s390_r4,
> s390_r5,
> s390_r6,
> s390_r7,
> s390_r8,
> s390_r9,
> s390_r10,
> s390_r11,
> s390_r12,
> s390_r13,
> s390_r14,
> s390_r15,
>} S390IntRegister;
>
>typedef enum {
> s390_f0 = 0,
> s390_f1,
> s390_f2,
> s390_f3,
> s390_f4,
> s390_f5,
> s390_f6,
> s390_f7,
> s390_f8,
> s390_f9,
> s390_f10,
> s390_f11,
> s390_f12,
> s390_f13,
> s390_f14,
> s390_f15,
>} S390FloatRegister;
>
>typedef enum {
> s390_a0 = 0,
> s390_a1,
> s390_a2,
> s390_a3,
> s390_a4,
> s390_a5,
> s390_a6,
> s390_a7,
> s390_a8,
> s390_a9,
> s390_a10,
> s390_a11,
> s390_a12,
> s390_a13,
> s390_a14,
> s390_a15,
>} S390AccRegister;
>
>typedef enum {
> s390_fpc = 256,
>} S390SpecialRegister;
># 193 "../../mono/arch/s390x/s390x-codegen.h"
>typedef struct {
> short op;
>} E_Format;
>
>typedef struct {
> char op;
> int im;
>} I_Format;
>
>typedef struct {
> char op;
> char r1 : 4;
> char r2 : 4;
>} RR_Format;
>
>typedef struct {
> short op;
> char xx;
> char r1 : 4;
> char r2 : 4;
>} RRE_Format;
>
>typedef struct {
> short op;
> char r1 : 4;
> char xx : 4;
> char r3 : 4;
> char r2 : 4;
>} RRF_Format_1;
>
>typedef struct {
> short op;
> char m3 : 4;
> char xx : 4;
> char r1 : 4;
> char r2 : 4;
>} RRF_Format_2;
>
>typedef struct {
> short op;
> char r3 : 4;
> char m4 : 4;
> char r1 : 4;
> char r2 : 4;
>} RRF_Format_3;
>
>typedef struct {
> char op;
> char r1 : 4;
> char x2 : 4;
> char b2 : 4;
> short d2 : 12;
>} RX_Format;
>
>typedef struct {
> char op1;
> char r1 : 4;
> char x2 : 4;
> char b2 : 4;
> int d2 : 12;
> char xx;
> char op2;
>} RXE_Format;
>
>typedef struct {
> char op1;
> char r3 : 4;
> char x2 : 4;
> char b2 : 4;
> int d2 : 12;
> char r1 : 4;
> char xx : 4;
> char op2;
>} RXF_Format;
>
>typedef struct {
> char op1;
> char r1 : 4;
> char x2 : 4;
> char b2 : 4;
> int d2 : 20;
> char op2;
>} __attribute__ ((packed)) RXY_Format;
>
>typedef struct {
> char op;
> char r1 : 4;
> char r3 : 4;
> char b2 : 4;
> int d2 : 12;
>} RS_Format_1;
>
>typedef struct {
> char op;
> char r1 : 4;
> char m3 : 4;
> char b2 : 4;
> int d2 : 12;
>} RS_Format_2;
>
>typedef struct {
> char op;
> char r1 : 4;
> char xx : 4;
> char b2 : 4;
> int d2 : 12;
>} RS_Format_3;
>
>typedef struct {
> char op1;
> char r1 : 4;
> char r3 : 4;
> char b2 : 4;
> int d2 : 20;
> char op2;
>} __attribute__ ((packed)) RSY_Format_1;
>
>typedef struct {
> char op1;
> char r1 : 4;
> char m3 : 4;
> char b2 : 4;
> int d2 : 20;
> char op2;
>} __attribute__ ((packed)) RSY_Format_2;
>
>typedef struct {
> char op1;
> char l1 : 4;
> char xx : 4;
> char b1 : 4;
> int d1 : 12;
> char yy;
> char op2;
>} RSL_Format;
>
>typedef struct {
> char op;
> char r1 : 4;
> char r3 : 4;
> short i2;
>} RSI_Format;
>
>typedef struct {
> char op1;
> char r1 : 4;
> char op2 : 4;
> short i2;
>} RI_Format;
>
>typedef struct {
> char op1;
> char r1 : 4;
> char r3 : 4;
> short i2;
> char xx;
> char op2;
>} RIE_Format;
>
>typedef struct {
> char op1;
> char r1 : 4;
> char op2 : 4;
> int i2;
>} __attribute__ ((packed)) RIL_Format_1;
>
>typedef struct {
> char op1;
> char m1 : 4;
> char op2 : 4;
> int i2;
>} __attribute__ ((packed)) RIL_Format_2;
>
>typedef struct {
> char op;
> char i2;
> char b1 : 4;
> short d1 : 12;
>} SI_Format;
>
>typedef struct {
> char op1;
> char i2;
> char b1 : 4;
> int d1 : 20;
> char op2;
>} __attribute__ ((packed)) SIY_Format;
>
>typedef struct {
> short op;
> char b2 : 4;
> short d2 : 12;
>} S_Format;
>
>typedef struct {
> char op;
> char ll;
> char b1 : 4;
> short d1 : 12;
> char b2 : 4;
> short d2 : 12;
>} SS_Format_1;
>
>typedef struct {
> char op;
> char l1 : 4;
> char l2 : 4;
> char b1 : 4;
> short d1 : 12;
> char b2 : 4;
> short d2 : 12;
>} SS_Format_2;
>
>typedef struct {
> char op;
> char r1 : 4;
> char r3 : 4;
> char b1 : 4;
> short d1 : 12;
> char b2 : 4;
> short d2 : 12;
>} SS_Format_3;
>
>typedef struct {
> char op;
> char r1 : 4;
> char r3 : 4;
> char b2 : 4;
> short d2 : 12;
> char b4 : 4;
> short d4 : 12;
>} SS_Format_4;
>
>typedef struct {
> short op;
> char b1 : 4;
> short d1 : 12;
> char b2 : 4;
> short d2 : 12;
>} __attribute__ ((packed)) SSE_Format;
># 5 "mini-s390x.h" 2
># 39 "mini-s390x.h"
>struct MonoLMF {
> gpointer previous_lmf;
> gpointer lmf_addr;
> MonoMethod *method;
> gulong ebp;
> gulong eip;
> gulong pregs[6];
> gulong gregs[16];
> gdouble fregs[16];
>};
>
>typedef struct ucontext MonoContext;
>
>typedef struct MonoCompileArch {
> gpointer litpool;
> glong litsize;
> int bkchain_reg;
>} MonoCompileArch;
>
>typedef struct
>{
> void *prev;
> void *unused[5];
> void *regs[8];
> void *return_address;
>} MonoS390StackFrame;
>
>typedef struct
>{
> char n3:1;
> char zArch:1;
> char zAct:1;
> char date:1;
> char idte1:1;
> char idte2:1;
> char asnlx:1;
> char stfle:1;
> char zDATe:1;
> char srstat:1;
> char cSSKE:1;
> char topo:1;
> char xTrans2:1;
> char msgSec:1;
> char longDsp:1;
> char hiPerfLD:1;
> char hfpMAS:1;
> char xImm:1;
> char xTrans3:1;
> char hfpUnX:1;
> char etf2:1;
> char stckf:1;
> char parse:1;
> char mvcos:1;
> char todSteer:1;
> char etf3:1;
> char xCPUtm:1;
> char csst:1;
> char csst2:1;
> char giX:1;
> char exX:1;
> char ibm:1;
> char fps:1;
> char dfp:1;
> char hiDFP:1;
> char pfpo:1;
>} __attribute__((aligned(8))) facilityList_t;
># 225 "mini-s390x.h"
>static void inline
>s390_patch_rel (guchar *code, guint64 target)
>{
> guint32 *offset = (guint32 *) code;
>
> if (target != 0) {
>  *offset = (guint32) target;
> }
>}
># 245 "mini-s390x.h"
>static void inline
>s390_patch_addr (guchar *code, guint64 target)
>{
> guint64 *offset = (guint64 *) code;
>
> if (target != 0) {
>  *offset = target;
> }
>}
># 15 "mini-arch.h" 2
># 37 "mini.h" 2
># 1 "regalloc.h" 1
>
>typedef size_t regmask_t;
>
>enum {
> MONO_REG_INT,
> MONO_REG_DOUBLE,
>
> MONO_REG_INT_REF,
>
> MONO_REG_INT_MP,
> MONO_REG_SIMD
>};
># 21 "regalloc.h"
>typedef struct {
>
> int next_vreg;
>
> regmask_t ifree_mask;
> regmask_t free_mask [4];
>
>
>
>
>
>
> gint32 *vassign;
>
>
> int isymbolic [16];
> int fsymbolic [16];
>
>
>
>
> int *symbolic [4];
>
> int vassign_size;
>} MonoRegState;
>
>MonoRegState* mono_regstate_new (void) __attribute__ ((visibility ("hidden")));
>
>void mono_regstate_free (MonoRegState *rs) __attribute__ ((visibility ("hidden")));
># 38 "mini.h" 2
># 1 "declsec.h" 1
># 31 "declsec.h"
>typedef struct {
> MonoObject obj;
> MonoAppDomain *domain;
> MonoReflectionMethod *method;
> MonoDeclSecurityEntry assert;
> MonoDeclSecurityEntry deny;
> MonoDeclSecurityEntry permitonly;
>} MonoSecurityFrame;
>
>
>
>enum {
> MONO_JITINFO_STACKMOD_ASSERT = 0x01,
> MONO_JITINFO_STACKMOD_DENY = 0x02,
> MONO_JITINFO_STACKMOD_PERMITONLY = 0x04
>};
>
>enum {
> MONO_JIT_SECURITY_OK = 0x00,
> MONO_JIT_LINKDEMAND_PERMISSION = 0x01,
> MONO_JIT_LINKDEMAND_APTC = 0x02,
> MONO_JIT_LINKDEMAND_ECMA = 0x04,
> MONO_JIT_LINKDEMAND_PINVOKE = 0x08
>};
>
>
>MonoBoolean mono_method_has_declsec (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>void mono_declsec_cache_stack_modifiers (MonoJitInfo *jinfo) __attribute__ ((visibility ("hidden")));
>MonoSecurityFrame* mono_declsec_create_frame (MonoDomain *domain, MonoJitInfo *jinfo) __attribute__ ((visibility ("hidden")));
>
>guint32 mono_declsec_linkdemand (MonoDomain *domain, MonoMethod *caller, MonoMethod *callee) __attribute__ ((visibility ("hidden")));
># 39 "mini.h" 2
># 1 "mini-unwind.h" 1
># 13 "mini-unwind.h"
># 1 "mini.h" 1
># 14 "mini-unwind.h" 2
># 58 "mini-unwind.h"
>typedef struct {
> guint8 op;
> guint16 reg;
> gint32 val;
> guint32 when;
>} MonoUnwindOp;
># 89 "mini-unwind.h"
>int
>mono_hw_reg_to_dwarf_reg (int reg) __attribute__ ((visibility ("hidden")));
>
>int
>mono_dwarf_reg_to_hw_reg (int reg) __attribute__ ((visibility ("hidden")));
>
>int
>mono_unwind_get_dwarf_data_align (void) __attribute__ ((visibility ("hidden")));
>
>int
>mono_unwind_get_dwarf_pc_reg (void) __attribute__ ((visibility ("hidden")));
>
>guint8*
>mono_unwind_ops_encode (GSList *unwind_ops, guint32 *out_len) __attribute__ ((visibility ("hidden")));
>
>void
>mono_unwind_frame (guint8 *unwind_info, guint32 unwind_info_len,
>       guint8 *start_ip, guint8 *end_ip, guint8 *ip, mgreg_t *regs, int nregs,
>       mgreg_t **save_locations, int save_locations_len,
>       guint8 **out_cfa) __attribute__ ((visibility ("hidden")));
>
>void mono_unwind_init (void) __attribute__ ((visibility ("hidden")));
>
>void mono_unwind_cleanup (void) __attribute__ ((visibility ("hidden")));
>
>guint32 mono_cache_unwind_info (guint8 *unwind_info, guint32 unwind_info_len) __attribute__ ((visibility ("hidden")));
>
>guint8* mono_get_cached_unwind_info (guint32 index, guint32 *unwind_info_len) __attribute__ ((visibility ("hidden")));
>
>guint8* mono_unwind_decode_fde (guint8 *fde, guint32 *out_len, guint32 *code_len, MonoJitExceptionInfo **ex_info, guint32 *ex_info_len, gpointer **type_info, int *this_reg, int *this_offset) __attribute__ ((visibility ("hidden")));
>
>
>typedef struct {
>
> guint8 *unw_info;
> guint32 unw_info_len;
> MonoJitExceptionInfo *ex_info;
> guint32 ex_info_len;
> gpointer *type_info;
> int this_reg;
> int this_offset;
>} MonoLLVMFDEInfo;
>
>void
>mono_unwind_decode_llvm_mono_fde (guint8 *fde, int fde_len, guint8 *cie, guint8 *code, MonoLLVMFDEInfo *res) __attribute__ ((visibility ("hidden")));
>
>GSList* mono_unwind_get_cie_program (void) __attribute__ ((visibility ("hidden")));
># 40 "mini.h" 2
># 128 "mini.h"
>enum {
> MONO_AOT_METHODREF_MIN = 240,
>
> MONO_AOT_METHODREF_WRAPPER_NAME = 250,
>
> MONO_AOT_METHODREF_ARRAY = 251,
> MONO_AOT_METHODREF_NO_AOT_TRAMPOLINE = 252,
>
> MONO_AOT_METHODREF_WRAPPER = 253,
>
> MONO_AOT_METHODREF_GINST = 254,
>
> MONO_AOT_METHODREF_METHODSPEC = 255,
>};
>
>
>typedef enum {
> MONO_AOT_TRAMP_SPECIFIC = 0,
> MONO_AOT_TRAMP_STATIC_RGCTX = 1,
> MONO_AOT_TRAMP_IMT_THUNK = 2,
> MONO_AOT_TRAMP_NUM = 3
>} MonoAotTrampoline;
>
>typedef enum {
> MONO_AOT_FILE_FLAG_WITH_LLVM = 1,
> MONO_AOT_FILE_FLAG_FULL_AOT = 2,
> MONO_AOT_FILE_FLAG_DEBUG = 4
>} MonoAotFileFlags;
>
>
>typedef struct MonoAotFileInfo
>{
>
> guint32 version;
>
> guint32 dummy;
>
>
>
>
> gpointer got;
>
> gpointer methods;
>
> gpointer mono_eh_frame;
>
> gpointer blob;
> gpointer class_name_table;
> gpointer class_info_offsets;
> gpointer method_info_offsets;
> gpointer ex_info_offsets;
> gpointer code_offsets;
> gpointer extra_method_info_offsets;
> gpointer extra_method_table;
> gpointer got_info_offsets;
> gpointer methods_end;
> gpointer unwind_info;
> gpointer mem_end;
> gpointer image_table;
>
> gpointer plt;
>
> gpointer plt_end;
>
> gpointer assembly_guid;
>
>
>
>
> gpointer runtime_version;
>
> gpointer specific_trampolines;
> gpointer static_rgctx_trampolines;
> gpointer imt_thunks;
>
>
>
> gpointer thumb_end;
>
> gpointer globals;
>
> gpointer assembly_name;
>
>
> guint32 plt_got_offset_base;
>
> guint32 got_size;
>
> guint32 plt_size;
>
> guint32 nmethods;
>
> guint32 flags;
>
> guint32 opts;
>
> gint32 gc_name_index;
>
>
> guint32 num_trampolines [MONO_AOT_TRAMP_NUM];
>
> guint32 trampoline_got_offset_base [MONO_AOT_TRAMP_NUM];
>
> guint32 trampoline_size [MONO_AOT_TRAMP_NUM];
>
>
> guint32 double_align, long_align;
>} MonoAotFileInfo;
>
>
>typedef struct
>{
>
> GHashTable *jump_target_got_slot_hash;
> GHashTable *jump_target_hash;
>
> GHashTable *class_init_trampoline_hash;
> GHashTable *jump_trampoline_hash;
> GHashTable *jit_trampoline_hash;
> GHashTable *delegate_trampoline_hash;
> GHashTable *static_rgctx_trampoline_hash;
> GHashTable *llvm_vcall_trampoline_hash;
>
> GHashTable *dynamic_code_hash;
> GHashTable *method_code_hash;
>
> GHashTable *runtime_invoke_hash;
>
> GHashTable *seq_points;
>
> gpointer agent_info;
>
> GHashTable *arch_seq_points;
>} MonoJitDomainInfo;
>
>typedef struct {
> MonoJitInfo *ji;
> MonoCodeManager *code_mp;
>} MonoJitDynamicMethodInfo;
>
>
>
>
>typedef struct {
> GSList *list;
>} MonoJumpList;
>
>
>typedef struct {
> int dummy;
>} MonoDynCallInfo;
>
>
>
>
>typedef enum {
>
> FRAME_TYPE_MANAGED = 0,
>
> FRAME_TYPE_DEBUGGER_INVOKE = 1,
>
> FRAME_TYPE_MANAGED_TO_NATIVE = 2,
> FRAME_TYPE_SENTINEL = 3
>} StackFrameType;
>
>
>
>
>typedef struct {
> StackFrameType type;
>
>
>
> MonoJitInfo *ji;
>
>
>
> MonoMethod *method;
>
>
>
> MonoMethod *actual_method;
>
> MonoDomain *domain;
> gboolean managed;
> int native_offset;
> int il_offset;
> gpointer lmf;
> guint32 unwind_info_len;
> guint8 *unwind_info;
>} StackFrameInfo;
>
>typedef struct {
> int il_offset, native_offset;
>
> int *next;
>
> int next_len;
>} SeqPoint;
>
>typedef struct {
> int len;
> SeqPoint seq_points [0];
>} MonoSeqPointInfo;
># 354 "mini.h"
>enum {
># 1 "../../mono/cil/opcode.def" 1
>CEE_NOP = 0x00,
>CEE_BREAK = 0x01,
>CEE_LDARG_0 = 0x02,
>CEE_LDARG_1 = 0x03,
>CEE_LDARG_2 = 0x04,
>CEE_LDARG_3 = 0x05,
>CEE_LDLOC_0 = 0x06,
>CEE_LDLOC_1 = 0x07,
>CEE_LDLOC_2 = 0x08,
>CEE_LDLOC_3 = 0x09,
>CEE_STLOC_0 = 0x0A,
>CEE_STLOC_1 = 0x0B,
>CEE_STLOC_2 = 0x0C,
>CEE_STLOC_3 = 0x0D,
>CEE_LDARG_S = 0x0E,
>CEE_LDARGA_S = 0x0F,
>CEE_STARG_S = 0x10,
>CEE_LDLOC_S = 0x11,
>CEE_LDLOCA_S = 0x12,
>CEE_STLOC_S = 0x13,
>CEE_LDNULL = 0x14,
>CEE_LDC_I4_M1 = 0x15,
>CEE_LDC_I4_0 = 0x16,
>CEE_LDC_I4_1 = 0x17,
>CEE_LDC_I4_2 = 0x18,
>CEE_LDC_I4_3 = 0x19,
>CEE_LDC_I4_4 = 0x1A,
>CEE_LDC_I4_5 = 0x1B,
>CEE_LDC_I4_6 = 0x1C,
>CEE_LDC_I4_7 = 0x1D,
>CEE_LDC_I4_8 = 0x1E,
>CEE_LDC_I4_S = 0x1F,
>CEE_LDC_I4 = 0x20,
>CEE_LDC_I8 = 0x21,
>CEE_LDC_R4 = 0x22,
>CEE_LDC_R8 = 0x23,
>CEE_UNUSED99 = 0x24,
>CEE_DUP = 0x25,
>CEE_POP = 0x26,
>CEE_JMP = 0x27,
>CEE_CALL = 0x28,
>CEE_CALLI = 0x29,
>CEE_RET = 0x2A,
>CEE_BR_S = 0x2B,
>CEE_BRFALSE_S = 0x2C,
>CEE_BRTRUE_S = 0x2D,
>CEE_BEQ_S = 0x2E,
>CEE_BGE_S = 0x2F,
>CEE_BGT_S = 0x30,
>CEE_BLE_S = 0x31,
>CEE_BLT_S = 0x32,
>CEE_BNE_UN_S = 0x33,
>CEE_BGE_UN_S = 0x34,
>CEE_BGT_UN_S = 0x35,
>CEE_BLE_UN_S = 0x36,
>CEE_BLT_UN_S = 0x37,
>CEE_BR = 0x38,
>CEE_BRFALSE = 0x39,
>CEE_BRTRUE = 0x3A,
>CEE_BEQ = 0x3B,
>CEE_BGE = 0x3C,
>CEE_BGT = 0x3D,
>CEE_BLE = 0x3E,
>CEE_BLT = 0x3F,
>CEE_BNE_UN = 0x40,
>CEE_BGE_UN = 0x41,
>CEE_BGT_UN = 0x42,
>CEE_BLE_UN = 0x43,
>CEE_BLT_UN = 0x44,
>CEE_SWITCH = 0x45,
>CEE_LDIND_I1 = 0x46,
>CEE_LDIND_U1 = 0x47,
>CEE_LDIND_I2 = 0x48,
>CEE_LDIND_U2 = 0x49,
>CEE_LDIND_I4 = 0x4A,
>CEE_LDIND_U4 = 0x4B,
>CEE_LDIND_I8 = 0x4C,
>CEE_LDIND_I = 0x4D,
>CEE_LDIND_R4 = 0x4E,
>CEE_LDIND_R8 = 0x4F,
>CEE_LDIND_REF = 0x50,
>CEE_STIND_REF = 0x51,
>CEE_STIND_I1 = 0x52,
>CEE_STIND_I2 = 0x53,
>CEE_STIND_I4 = 0x54,
>CEE_STIND_I8 = 0x55,
>CEE_STIND_R4 = 0x56,
>CEE_STIND_R8 = 0x57,
>CEE_ADD = 0x58,
>CEE_SUB = 0x59,
>CEE_MUL = 0x5A,
>CEE_DIV = 0x5B,
>CEE_DIV_UN = 0x5C,
>CEE_REM = 0x5D,
>CEE_REM_UN = 0x5E,
>CEE_AND = 0x5F,
>CEE_OR = 0x60,
>CEE_XOR = 0x61,
>CEE_SHL = 0x62,
>CEE_SHR = 0x63,
>CEE_SHR_UN = 0x64,
>CEE_NEG = 0x65,
>CEE_NOT = 0x66,
>CEE_CONV_I1 = 0x67,
>CEE_CONV_I2 = 0x68,
>CEE_CONV_I4 = 0x69,
>CEE_CONV_I8 = 0x6A,
>CEE_CONV_R4 = 0x6B,
>CEE_CONV_R8 = 0x6C,
>CEE_CONV_U4 = 0x6D,
>CEE_CONV_U8 = 0x6E,
>CEE_CALLVIRT = 0x6F,
>CEE_CPOBJ = 0x70,
>CEE_LDOBJ = 0x71,
>CEE_LDSTR = 0x72,
>CEE_NEWOBJ = 0x73,
>CEE_CASTCLASS = 0x74,
>CEE_ISINST = 0x75,
>CEE_CONV_R_UN = 0x76,
>CEE_UNUSED58 = 0x77,
>CEE_UNUSED1 = 0x78,
>CEE_UNBOX = 0x79,
>CEE_THROW = 0x7A,
>CEE_LDFLD = 0x7B,
>CEE_LDFLDA = 0x7C,
>CEE_STFLD = 0x7D,
>CEE_LDSFLD = 0x7E,
>CEE_LDSFLDA = 0x7F,
>CEE_STSFLD = 0x80,
>CEE_STOBJ = 0x81,
>CEE_CONV_OVF_I1_UN = 0x82,
>CEE_CONV_OVF_I2_UN = 0x83,
>CEE_CONV_OVF_I4_UN = 0x84,
>CEE_CONV_OVF_I8_UN = 0x85,
>CEE_CONV_OVF_U1_UN = 0x86,
>CEE_CONV_OVF_U2_UN = 0x87,
>CEE_CONV_OVF_U4_UN = 0x88,
>CEE_CONV_OVF_U8_UN = 0x89,
>CEE_CONV_OVF_I_UN = 0x8A,
>CEE_CONV_OVF_U_UN = 0x8B,
>CEE_BOX = 0x8C,
>CEE_NEWARR = 0x8D,
>CEE_LDLEN = 0x8E,
>CEE_LDELEMA = 0x8F,
>CEE_LDELEM_I1 = 0x90,
>CEE_LDELEM_U1 = 0x91,
>CEE_LDELEM_I2 = 0x92,
>CEE_LDELEM_U2 = 0x93,
>CEE_LDELEM_I4 = 0x94,
>CEE_LDELEM_U4 = 0x95,
>CEE_LDELEM_I8 = 0x96,
>CEE_LDELEM_I = 0x97,
>CEE_LDELEM_R4 = 0x98,
>CEE_LDELEM_R8 = 0x99,
>CEE_LDELEM_REF = 0x9A,
>CEE_STELEM_I = 0x9B,
>CEE_STELEM_I1 = 0x9C,
>CEE_STELEM_I2 = 0x9D,
>CEE_STELEM_I4 = 0x9E,
>CEE_STELEM_I8 = 0x9F,
>CEE_STELEM_R4 = 0xA0,
>CEE_STELEM_R8 = 0xA1,
>CEE_STELEM_REF = 0xA2,
>CEE_LDELEM = 0xA3,
>CEE_STELEM = 0xA4,
>CEE_UNBOX_ANY = 0xA5,
>CEE_UNUSED5 = 0xA6,
>CEE_UNUSED6 = 0xA7,
>CEE_UNUSED7 = 0xA8,
>CEE_UNUSED8 = 0xA9,
>CEE_UNUSED9 = 0xAA,
>CEE_UNUSED10 = 0xAB,
>CEE_UNUSED11 = 0xAC,
>CEE_UNUSED12 = 0xAD,
>CEE_UNUSED13 = 0xAE,
>CEE_UNUSED14 = 0xAF,
>CEE_UNUSED15 = 0xB0,
>CEE_UNUSED16 = 0xB1,
>CEE_UNUSED17 = 0xB2,
>CEE_CONV_OVF_I1 = 0xB3,
>CEE_CONV_OVF_U1 = 0xB4,
>CEE_CONV_OVF_I2 = 0xB5,
>CEE_CONV_OVF_U2 = 0xB6,
>CEE_CONV_OVF_I4 = 0xB7,
>CEE_CONV_OVF_U4 = 0xB8,
>CEE_CONV_OVF_I8 = 0xB9,
>CEE_CONV_OVF_U8 = 0xBA,
>CEE_UNUSED50 = 0xBB,
>CEE_UNUSED18 = 0xBC,
>CEE_UNUSED19 = 0xBD,
>CEE_UNUSED20 = 0xBE,
>CEE_UNUSED21 = 0xBF,
>CEE_UNUSED22 = 0xC0,
>CEE_UNUSED23 = 0xC1,
>CEE_REFANYVAL = 0xC2,
>CEE_CKFINITE = 0xC3,
>CEE_UNUSED24 = 0xC4,
>CEE_UNUSED25 = 0xC5,
>CEE_MKREFANY = 0xC6,
>CEE_UNUSED59 = 0xC7,
>CEE_UNUSED60 = 0xC8,
>CEE_UNUSED61 = 0xC9,
>CEE_UNUSED62 = 0xCA,
>CEE_UNUSED63 = 0xCB,
>CEE_UNUSED64 = 0xCC,
>CEE_UNUSED65 = 0xCD,
>CEE_UNUSED66 = 0xCE,
>CEE_UNUSED67 = 0xCF,
>CEE_LDTOKEN = 0xD0,
>CEE_CONV_U2 = 0xD1,
>CEE_CONV_U1 = 0xD2,
>CEE_CONV_I = 0xD3,
>CEE_CONV_OVF_I = 0xD4,
>CEE_CONV_OVF_U = 0xD5,
>CEE_ADD_OVF = 0xD6,
>CEE_ADD_OVF_UN = 0xD7,
>CEE_MUL_OVF = 0xD8,
>CEE_MUL_OVF_UN = 0xD9,
>CEE_SUB_OVF = 0xDA,
>CEE_SUB_OVF_UN = 0xDB,
>CEE_ENDFINALLY = 0xDC,
>CEE_LEAVE = 0xDD,
>CEE_LEAVE_S = 0xDE,
>CEE_STIND_I = 0xDF,
>CEE_CONV_U = 0xE0,
>CEE_UNUSED26 = 0xE1,
>CEE_UNUSED27 = 0xE2,
>CEE_UNUSED28 = 0xE3,
>CEE_UNUSED29 = 0xE4,
>CEE_UNUSED30 = 0xE5,
>CEE_UNUSED31 = 0xE6,
>CEE_UNUSED32 = 0xE7,
>CEE_UNUSED33 = 0xE8,
>CEE_UNUSED34 = 0xE9,
>CEE_UNUSED35 = 0xEA,
>CEE_UNUSED36 = 0xEB,
>CEE_UNUSED37 = 0xEC,
>CEE_UNUSED38 = 0xED,
>CEE_UNUSED39 = 0xEE,
>CEE_UNUSED40 = 0xEF,
>CEE_UNUSED41 = 0xF0,
>CEE_UNUSED42 = 0xF1,
>CEE_UNUSED43 = 0xF2,
>CEE_UNUSED44 = 0xF3,
>CEE_UNUSED45 = 0xF4,
>CEE_UNUSED46 = 0xF5,
>CEE_UNUSED47 = 0xF6,
>CEE_UNUSED48 = 0xF7,
>CEE_PREFIX7 = 0xF8,
>CEE_PREFIX6 = 0xF9,
>CEE_PREFIX5 = 0xFA,
>CEE_PREFIX4 = 0xFB,
>CEE_PREFIX3 = 0xFC,
>CEE_PREFIX2 = 0xFD,
>CEE_PREFIX1 = 0xFE,
>CEE_PREFIXREF = 0xFF,
>CEE_ARGLIST = 0x00,
>CEE_CEQ = 0x01,
>CEE_CGT = 0x02,
>CEE_CGT_UN = 0x03,
>CEE_CLT = 0x04,
>CEE_CLT_UN = 0x05,
>CEE_LDFTN = 0x06,
>CEE_LDVIRTFTN = 0x07,
>CEE_UNUSED56 = 0x08,
>CEE_LDARG = 0x09,
>CEE_LDARGA = 0x0A,
>CEE_STARG = 0x0B,
>CEE_LDLOC = 0x0C,
>CEE_LDLOCA = 0x0D,
>CEE_STLOC = 0x0E,
>CEE_LOCALLOC = 0x0F,
>CEE_UNUSED57 = 0x10,
>CEE_ENDFILTER = 0x11,
>CEE_UNALIGNED_ = 0x12,
>CEE_VOLATILE_ = 0x13,
>CEE_TAIL_ = 0x14,
>CEE_INITOBJ = 0x15,
>CEE_CONSTRAINED_ = 0x16,
>CEE_CPBLK = 0x17,
>CEE_INITBLK = 0x18,
>CEE_NO_ = 0x19,
>CEE_RETHROW = 0x1A,
>CEE_UNUSED = 0x1B,
>CEE_SIZEOF = 0x1C,
>CEE_REFANYTYPE = 0x1D,
>CEE_READONLY_ = 0x1E,
>CEE_UNUSED53 = 0x1F,
>CEE_UNUSED54 = 0x20,
>CEE_UNUSED55 = 0x21,
>CEE_UNUSED70 = 0x22,
>CEE_ILLEGAL = 0x00,
>CEE_ENDMAC = 0x00,
>CEE_MONO_ICALL = 0x00,
>CEE_MONO_OBJADDR = 0x01,
>CEE_MONO_LDPTR = 0x02,
>CEE_MONO_VTADDR = 0x03,
>CEE_MONO_NEWOBJ = 0x04,
>CEE_MONO_RETOBJ = 0x05,
>CEE_MONO_LDNATIVEOBJ = 0x06,
>CEE_MONO_CISINST = 0x07,
>CEE_MONO_CCASTCLASS = 0x08,
>CEE_MONO_SAVE_LMF = 0x09,
>CEE_MONO_RESTORE_LMF = 0x0A,
>CEE_MONO_CLASSCONST = 0x0B,
>CEE_MONO_NOT_TAKEN = 0x0C,
>CEE_MONO_TLS = 0x0D,
>CEE_MONO_ICALL_ADDR = 0x0E,
>CEE_MONO_DYN_CALL = 0x0F,
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
># 356 "mini.h" 2
> CEE_LASTOP
>};
># 474 "mini.h"
>typedef struct MonoInstList MonoInstList;
>typedef struct MonoInst MonoInst;
>typedef struct MonoCallInst MonoCallInst;
>typedef struct MonoCallArgParm MonoCallArgParm;
>typedef struct MonoMethodVar MonoMethodVar;
>typedef struct MonoBasicBlock MonoBasicBlock;
>typedef struct MonoLMF MonoLMF;
>typedef struct MonoSpillInfo MonoSpillInfo;
>typedef struct MonoTraceSpec MonoTraceSpec;
>
>extern guint32 mono_jit_tls_id;
>extern MonoTraceSpec *mono_jit_trace_calls;
>extern gboolean mono_break_on_exc;
>extern int mono_exc_esp_offset;
>extern gboolean mono_compile_aot;
>extern gboolean mono_aot_only;
>extern gboolean mono_use_imt;
>extern MonoMethodDesc *mono_inject_async_exc_method;
>extern int mono_inject_async_exc_pos;
>extern MonoMethodDesc *mono_break_at_bb_method;
>extern int mono_break_at_bb_bb_num;
>extern gboolean check_for_pending_exc;
>extern gboolean disable_vtypes_in_regs;
>extern gboolean mono_verify_all;
>extern gboolean mono_dont_free_global_codeman;
>extern gboolean mono_do_x86_stack_align;
>extern const char *mono_build_date;
>extern gboolean mono_do_signal_chaining;
>extern gboolean mono_use_llvm;
>
>
>
>extern const char ins_info[];
>extern const gint8 ins_sreg_counts [];
># 520 "mini.h"
>struct MonoSpillInfo {
> int offset;
>};
>
>
>
>
>typedef struct {
>
> int pc_offset;
>
> MonoBasicBlock *bb;
>
>
>
>
> guint8 *liveness;
>
>
>
>
> GSList *param_slots;
>} GCCallSite;
># 554 "mini.h"
>struct MonoBasicBlock {
> MonoInst *last_ins;
>
>
> MonoBasicBlock *next_bb;
>
>
>
>
>
>
>
> MonoInst *code;
>
>
> gint32 block_num;
>
> gint32 dfn;
>
>
>
> gint16 out_count, in_count;
> MonoBasicBlock **in_bb;
> MonoBasicBlock **out_bb;
>
>
> unsigned char* cil_code;
>
>
> gint32 cil_length;
>
>
> int native_offset;
>
> int native_length;
>
> int real_native_offset;
> int max_offset;
> int max_length;
>
>
> guint32 flags;
>
>
>
>
> MonoBitSet *dominators;
> MonoBitSet *dfrontier;
> MonoBasicBlock *idom;
> GSList *dominated;
>
> MonoBasicBlock *df_parent, *ancestor, *child, *label;
> int size, sdom, idomn;
>
>
> GList *loop_blocks;
> gint8 nesting;
> gint8 loop_body_start;
>
>
>
>
>
> guint out_of_line : 1;
>
> guint not_useless : 1;
>
> guint has_array_access : 1;
>
> guint extended : 1;
>
> guint has_jump_table : 1;
>
> guint has_call_handler : 1;
>
> guint try_start : 1;
>
>
>
>
>
> guint extend_try_block : 1;
>
>
> MonoBitSet *gen_set;
> MonoBitSet *kill_set;
> MonoBitSet *live_in_set;
> MonoBitSet *live_out_set;
>
>
> guint16 out_scount, in_scount;
> MonoInst **out_stack;
> MonoInst **in_stack;
>
>
> guint real_offset;
>
> GSList *seq_points;
> MonoInst *last_seq_point;
>
> GSList *spill_slot_defs;
>
>
> GSList *gc_callsites;
># 672 "mini.h"
> guint region;
>
>
> guint32 max_vreg;
>};
>
>
>enum {
> BB_VISITED = 1 << 0,
> BB_REACHABLE = 1 << 1,
> BB_EXCEPTION_DEAD_OBJ = 1 << 2,
> BB_EXCEPTION_UNSAFE = 1 << 3,
> BB_EXCEPTION_HANDLER = 1 << 4,
>
> BB_INDIRECT_JUMP_TARGET = 1 << 5
>};
>
>typedef struct MonoMemcpyArgs {
> int size, align;
>} MonoMemcpyArgs;
>
>typedef enum {
> LLVMArgNone,
> LLVMArgInIReg,
> LLVMArgInFPReg,
> LLVMArgVtypeInReg,
> LLVMArgVtypeByVal,
> LLVMArgVtypeRetAddr
>} LLVMArgStorage;
>
>typedef struct {
> LLVMArgStorage storage;
>
>
> LLVMArgStorage pair_storage [2];
>} LLVMArgInfo;
>
>typedef struct {
> LLVMArgInfo ret;
>
> gboolean rgctx_arg;
>
> gboolean imt_arg;
>
>
>
>
>
> int vret_arg_index;
>
> LLVMArgInfo args [1];
>} LLVMCallInfo;
>
>
>
>struct MonoInst {
>  guint16 opcode;
> guint8 type;
> guint8 flags;
>
>
> gint32 dreg, sreg1, sreg2, sreg3;
>
> MonoInst *next, *prev;
>
> union {
>  union {
>   MonoInst *src;
>   MonoMethodVar *var;
>   mgreg_t const_val;
>
>
>
>
>
>   gpointer p;
>
>   MonoMethod *method;
>   MonoMethodSignature *signature;
>   MonoBasicBlock **many_blocks;
>   MonoBasicBlock *target_block;
>   MonoInst **args;
>   MonoType *vtype;
>   MonoClass *klass;
>   int *phi_args;
>   MonoCallInst *call_inst;
>   MonoExceptionClause *exception_clause;
>  } op [2];
>  gint64 i8const;
>  double r8const;
> } data;
>
> const unsigned char* cil_code;
>
>
> union {
>  gint32 reg3;
>  gint32 arg_info;
>  gint32 size;
>  MonoMemcpyArgs *memcpy_args;
>  gpointer data;
>  gint shift_amount;
>  gboolean is_pinvoke;
>  gboolean record_cast_details;
>  MonoInst *spill_var;
>  guint16 source_opcode;
>  int pc_offset;
> } backend;
>
> MonoClass *klass;
>};
>
>struct MonoCallInst {
> MonoInst inst;
> MonoMethodSignature *signature;
> MonoMethod *method;
> MonoInst **args;
> MonoInst *out_args;
> MonoInst *vret_var;
> gconstpointer fptr;
> guint stack_usage;
> guint virtual : 1;
> guint tail_call : 1;
>
> guint fptr_is_patch : 1;
>
>
>
>
> guint vret_in_reg : 1;
>
> guint dynamic_imt_arg : 1;
>
> guint32 rgctx_reg : 1;
> regmask_t used_iregs;
> regmask_t used_fregs;
> GSList *out_ireg_args;
> GSList *out_freg_args;
> GSList *outarg_vts;
>
>
>
>
>};
>
>struct MonoCallArgParm {
> MonoInst ins;
> gint32 size;
> gint32 offset;
> gint32 offPrm;
>};
>
>
>
>
>
>
>enum {
> MONO_INST_HAS_METHOD = 1,
> MONO_INST_INIT = 1,
> MONO_INST_SINGLE_STEP_LOC = 1,
> MONO_INST_IS_DEAD = 2,
> MONO_INST_TAILCALL = 4,
> MONO_INST_VOLATILE = 4,
> MONO_INST_NOTYPECHECK = 4,
> MONO_INST_UNALIGNED = 8,
>    MONO_INST_CFOLD_TAKEN = 8,
>    MONO_INST_CFOLD_NOT_TAKEN = 16,
> MONO_INST_DEFINITION_HAS_SIDE_EFFECTS = 8,
>
> MONO_INST_INDIRECT = 16,
> MONO_INST_NORANGECHECK = 16,
>
> MONO_INST_FAULT = 32,
>
> MONO_INST_CONSTANT_LOAD = 64,
>
> MONO_INST_GC_TRACK = 128,
>
>
>
>
> MONO_INST_GC_CALLSITE = 128
>};
># 895 "mini.h"
>enum {
> MONO_INST_DEST,
> MONO_INST_SRC1,
> MONO_INST_SRC2,
> MONO_INST_SRC3,
> MONO_INST_LEN,
> MONO_INST_CLOB,
>
>
>
>
>
>
> MONO_INST_MAX
>};
>
>typedef union {
> struct {
>  guint16 tid;
>  guint16 bid;
> } pos ;
> guint32 abs_pos;
>} MonoPosition;
>
>typedef struct {
> MonoPosition first_use, last_use;
>} MonoLiveRange;
>
>typedef struct MonoLiveRange2 MonoLiveRange2;
>
>struct MonoLiveRange2 {
> int from, to;
> MonoLiveRange2 *next;
>};
>
>typedef struct {
>
> MonoLiveRange2 *range;
> MonoLiveRange2 *last_range;
>} MonoLiveInterval;
>
>
>
>
>struct MonoMethodVar {
> guint idx;
> MonoLiveRange range;
> MonoLiveInterval *interval;
> int reg;
> int spill_costs;
> MonoBitSet *def_in;
> MonoInst *def;
> MonoBasicBlock *def_bb;
> GList *uses;
> char cpstate;
>
> gint32 live_range_start, live_range_end;
>
>
>
>
> gint32 vreg;
>};
>
>
>
>
>typedef struct {
> MonoJitInfo *ji;
> int clause_index;
> MonoContext ctx, new_ctx;
>
> gpointer ex_obj;
> MonoLMF *lmf;
> int first_filter_idx, filter_idx;
>} ResumeState;
>
>typedef struct {
> gpointer end_of_stack;
> guint32 stack_size;
>
> MonoLMF *lmf;
>
> MonoLMF *first_lmf;
> gpointer restore_stack_prot;
> guint32 handling_stack_ovf;
> gpointer signal_stack;
> guint32 signal_stack_size;
> gpointer stack_ovf_guard_base;
> guint32 stack_ovf_guard_size;
> guint stack_ovf_valloced : 1;
> void (*abort_func) (MonoObject *object);
>
> MonoClass *class_cast_from, *class_cast_to;
>
>
> MonoContext ex_ctx;
> ResumeState resume_state;
>
>
>
> gpointer handler_block_return_address;
>
>
>
> MonoJitExceptionInfo *handler_block;
>
>
> MonoContext handler_block_context;
>
>
>
>
> MonoContext orig_ex_ctx;
> gboolean orig_ex_ctx_set;
>} MonoJitTlsData;
>
>
>
>
>typedef struct {
> struct MonoLMF lmf;
> gboolean debugger_invoke;
> MonoContext ctx;
>} MonoLMFExt;
>
>typedef enum {
>
># 1 "patch-info.h" 1
>MONO_PATCH_INFO_BB,
>MONO_PATCH_INFO_ABS,
>MONO_PATCH_INFO_LABEL,
>MONO_PATCH_INFO_METHOD,
>MONO_PATCH_INFO_METHOD_JUMP,
>MONO_PATCH_INFO_METHOD_REL,
>MONO_PATCH_INFO_METHODCONST,
>MONO_PATCH_INFO_INTERNAL_METHOD,
>MONO_PATCH_INFO_SWITCH,
>MONO_PATCH_INFO_EXC,
>MONO_PATCH_INFO_EXC_NAME,
>MONO_PATCH_INFO_CLASS,
>MONO_PATCH_INFO_IMAGE,
>MONO_PATCH_INFO_FIELD,
>MONO_PATCH_INFO_VTABLE,
>MONO_PATCH_INFO_CLASS_INIT,
>MONO_PATCH_INFO_SFLDA,
>MONO_PATCH_INFO_LDSTR,
>MONO_PATCH_INFO_LDTOKEN,
>MONO_PATCH_INFO_TYPE_FROM_HANDLE,
>MONO_PATCH_INFO_R4,
>MONO_PATCH_INFO_R8,
>MONO_PATCH_INFO_IP,
>MONO_PATCH_INFO_IID,
>MONO_PATCH_INFO_ADJUSTED_IID,
>MONO_PATCH_INFO_BB_OVF,
>MONO_PATCH_INFO_EXC_OVF,
>MONO_PATCH_INFO_GOT_OFFSET,
>MONO_PATCH_INFO_DECLSEC,
>MONO_PATCH_INFO_RVA,
>MONO_PATCH_INFO_DELEGATE_TRAMPOLINE,
>MONO_PATCH_INFO_ICALL_ADDR,
>MONO_PATCH_INFO_JIT_ICALL_ADDR,
>MONO_PATCH_INFO_INTERRUPTION_REQUEST_FLAG,
>MONO_PATCH_INFO_METHOD_RGCTX,
>MONO_PATCH_INFO_RGCTX_FETCH,
>MONO_PATCH_INFO_GENERIC_CLASS_INIT,
>MONO_PATCH_INFO_MONITOR_ENTER,
>MONO_PATCH_INFO_MONITOR_EXIT,
>MONO_PATCH_INFO_MSCORLIB_GOT_ADDR,
>MONO_PATCH_INFO_SEQ_POINT_INFO,
>MONO_PATCH_INFO_LLVM_IMT_TRAMPOLINE,
>MONO_PATCH_INFO_GC_CARD_TABLE_ADDR,
>MONO_PATCH_INFO_CASTCLASS_CACHE,
>MONO_PATCH_INFO_NONE,
># 1024 "mini.h" 2
>
> MONO_PATCH_INFO_NUM
>} MonoJumpInfoType;
>
>
>
>
>
>
>typedef struct MonoJumpInfoToken {
> MonoImage *image;
> guint32 token;
> gboolean has_context;
> MonoGenericContext context;
>} MonoJumpInfoToken;
>
>typedef struct MonoJumpInfoBBTable {
> MonoBasicBlock **table;
> int table_size;
>} MonoJumpInfoBBTable;
>
>typedef struct MonoJumpInfoRgctxEntry MonoJumpInfoRgctxEntry;
>
>
>typedef struct MonoJumpInfoImtTramp {
> MonoMethod *method;
> int vt_offset;
>} MonoJumpInfoImtTramp;
>
>typedef struct MonoJumpInfo MonoJumpInfo;
>struct MonoJumpInfo {
> MonoJumpInfo *next;
> union {
>  int i;
>  guint8 *p;
>  MonoInst *label;
> } ip;
>
> MonoJumpInfoType type;
> union {
>  gconstpointer target;
>
>  gint64 offset;
>
>
>
>  MonoBasicBlock *bb;
>  MonoInst *inst;
>  MonoMethod *method;
>  MonoClass *klass;
>  MonoClassField *field;
>  MonoImage *image;
>  MonoVTable *vtable;
>  const char *name;
>  MonoJumpInfoToken *token;
>  MonoJumpInfoBBTable *table;
>  MonoJumpInfoRgctxEntry *rgctx_entry;
>  MonoJumpInfoImtTramp *imt_tramp;
> } data;
>};
>
>
>struct MonoJumpInfoRgctxEntry {
> MonoMethod *method;
> gboolean in_mrgctx;
> MonoJumpInfo *data;
> int info_type;
>};
>
>typedef enum {
> MONO_TRAMPOLINE_JIT,
> MONO_TRAMPOLINE_JUMP,
> MONO_TRAMPOLINE_CLASS_INIT,
> MONO_TRAMPOLINE_GENERIC_CLASS_INIT,
> MONO_TRAMPOLINE_RGCTX_LAZY_FETCH,
> MONO_TRAMPOLINE_AOT,
> MONO_TRAMPOLINE_AOT_PLT,
> MONO_TRAMPOLINE_DELEGATE,
> MONO_TRAMPOLINE_RESTORE_STACK_PROT,
> MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING,
> MONO_TRAMPOLINE_MONITOR_ENTER,
> MONO_TRAMPOLINE_MONITOR_EXIT,
> MONO_TRAMPOLINE_VCALL,
>
>
>
> MONO_TRAMPOLINE_NUM
>} MonoTrampolineType;
># 1123 "mini.h"
>enum {
># 1 "optflags-def.h" 1
>MONO_OPT_PEEPHOLE = 1 << 0,
>MONO_OPT_BRANCH = 1 << 1,
>MONO_OPT_INLINE = 1 << 2,
>MONO_OPT_CFOLD = 1 << 3,
>MONO_OPT_CONSPROP = 1 << 4,
>MONO_OPT_COPYPROP = 1 << 5,
>MONO_OPT_DEADCE = 1 << 6,
>MONO_OPT_LINEARS = 1 << 7,
>MONO_OPT_CMOV = 1 << 8,
>MONO_OPT_SHARED = 1 << 9,
>MONO_OPT_SCHED = 1 << 10,
>MONO_OPT_INTRINS = 1 << 11,
>MONO_OPT_TAILC = 1 << 12,
>MONO_OPT_LOOP = 1 << 13,
>MONO_OPT_FCMOV = 1 << 14,
>MONO_OPT_LEAF = 1 << 15,
>MONO_OPT_AOT = 1 << 16,
>MONO_OPT_PRECOMP = 1 << 17,
>MONO_OPT_ABCREM = 1 << 18,
>MONO_OPT_SSAPRE = 1 << 19,
>MONO_OPT_EXCEPTION = 1 << 20,
>MONO_OPT_SSA = 1 << 21,
>MONO_OPT_SSE2 = 1 << 23,
>MONO_OPT_GSHARED = 1 << 24,
>MONO_OPT_SIMD = 1 << 25,
>MONO_OPT_UNSAFE = 1 << 26,
># 1125 "mini.h" 2
> MONO_OPT_LAST
>};
># 1155 "mini.h"
>typedef struct {
> MonoMethod *method;
> MonoMethodHeader *header;
> MonoMemPool *mempool;
> MonoInst **varinfo;
> MonoMethodVar *vars;
> MonoInst *ret;
> MonoBasicBlock *bb_entry;
> MonoBasicBlock *bb_exit;
> MonoBasicBlock *bb_init;
> MonoBasicBlock **bblocks;
> MonoBasicBlock **cil_offset_to_bb;
> MonoMemPool *state_pool;
> MonoBasicBlock *cbb;
> MonoInst *prev_ins;
> MonoJumpInfo *patch_info;
> MonoJitInfo *jit_info;
> MonoJitDynamicMethodInfo *dynamic_info;
> guint num_bblocks, max_block_num;
> guint locals_start;
> guint num_varinfo;
> guint varinfo_count;
> gint stack_offset;
> gint max_ireg;
> gint cil_offset_to_bb_len;
> MonoRegState *rs;
> MonoSpillInfo *spill_info [16];
> gint spill_count;
> gint spill_info_len [16];
>
> MonoMethod *inlined_method;
> MonoInst *domainvar;
> MonoInst *got_var;
> MonoInst **locals;
> MonoInst *rgctx_var;
> MonoInst **args;
> MonoType **arg_types;
> MonoMethod *current_method;
> MonoMethod *method_to_register;
> MonoGenericContext *generic_context;
>
>
>
>
>
>
> MonoInst *vret_addr;
>
>
>
>
> const unsigned char *ip;
>
> struct MonoAliasingInformation *aliasing_info;
>
>
>
> GHashTable *spvars;
>
>
>
> GHashTable *exvars;
>
> GList *ldstr_list;
>
> MonoDomain *domain;
>
> guint real_offset;
> GHashTable *cbb_hash;
>
>
> guint32 next_vreg;
>
> MonoGenericSharingContext *generic_sharing_context;
>
> unsigned char *cil_start;
>
>
>
>
>
> unsigned char *native_code;
> guint code_size;
> guint code_len;
> guint prolog_end;
> guint epilog_begin;
> regmask_t used_int_regs;
> guint32 opt;
> guint32 prof_options;
> guint32 flags;
> guint32 comp_done;
> guint32 verbose_level;
> guint32 stack_usage;
> guint32 param_area;
> guint32 frame_reg;
> gint32 sig_cookie;
> guint disable_aot : 1;
> guint disable_ssa : 1;
> guint disable_llvm : 1;
> guint enable_extended_bblocks : 1;
> guint run_cctors : 1;
> guint need_lmf_area : 1;
> guint compile_aot : 1;
> guint compile_llvm : 1;
> guint got_var_allocated : 1;
> guint ret_var_is_local : 1;
> guint ret_var_set : 1;
> guint globalra : 1;
> guint unverifiable : 1;
> guint skip_visibility : 1;
> guint disable_reuse_registers : 1;
> guint disable_reuse_stack_slots : 1;
> guint disable_reuse_ref_stack_slots : 1;
> guint disable_ref_noref_stack_slot_share : 1;
> guint disable_initlocals_opt : 1;
> guint disable_initlocals_opt_refs : 1;
> guint disable_omit_fp : 1;
> guint disable_vreg_to_lvreg : 1;
> guint disable_deadce_vars : 1;
> guint disable_out_of_line_bblocks : 1;
> guint gen_write_barriers : 1;
> guint init_ref_vars : 1;
> guint extend_live_ranges : 1;
> guint compute_precise_live_ranges : 1;
> guint has_got_slots : 1;
> guint uses_rgctx_reg : 1;
> guint uses_vtable_reg : 1;
> guint uses_simd_intrinsics : 1;
> guint keep_cil_nops : 1;
> guint gen_seq_points : 1;
> guint explicit_null_checks : 1;
> guint compute_gc_maps : 1;
> guint soft_breakpoints : 1;
> guint arch_eh_jit_info : 1;
> gpointer debug_info;
> guint32 lmf_offset;
>    guint16 *intvars;
> MonoProfileCoverageInfo *coverage_info;
> GHashTable *token_info_hash;
> MonoCompileArch arch;
> guint32 inline_depth;
> guint32 exception_type;
> guint32 exception_data;
> char* exception_message;
> gpointer exception_ptr;
>
> guint8 * encoded_unwind_ops;
> guint32 encoded_unwind_ops_len;
> GSList* unwind_ops;
>
>
> void* reginfo;
> int reginfo_len;
>
>
>
> MonoInst **vreg_to_inst;
>
>
> guint32 vreg_to_inst_len;
>
>
>
> gboolean *vreg_is_ref;
>
>
> guint32 vreg_is_ref_len;
>
>
>
> gboolean *vreg_is_mp;
>
>
> guint32 vreg_is_mp_len;
>
>
>
>
>
> MonoMethod *orig_method;
>
>
> GHashTable *abs_patches;
>
>
>
>
>
>
>
> MonoInst **tailcall_valuetype_addrs;
>
>
>
> MonoInst *iconv_raw_var;
>
>
> MonoInst *fconv_to_r8_x_var;
>
>
> MonoInst *simd_ctor_var;
>
>
> MonoInst *dyn_call_var;
>
>
>
>
>
>
>
> GPtrArray *seq_points;
>
>
> MonoSeqPointInfo *seq_point_info;
>
>
> GSList *headers_to_free;
>
>
> guint32 got_offset, ex_info_offset, method_info_offset;
>
> char *asm_symbol;
> char *llvm_method_name;
>
> MonoJitExceptionInfo *llvm_ex_info;
> guint32 llvm_ex_info_len;
> int llvm_this_reg, llvm_this_offset;
>
> GSList *try_block_holes;
>
>
>
>
> gint locals_min_stack_offset, locals_max_stack_offset;
>
>
> int cfa_reg, cfa_offset;
>
>
> gpointer gc_info;
>
>
>
>
>
> guint8 *gc_map;
> guint32 gc_map_size;
>} MonoCompile;
>
>typedef enum {
> MONO_CFG_HAS_ALLOCA = 1 << 0,
> MONO_CFG_HAS_CALLS = 1 << 1,
> MONO_CFG_HAS_LDELEMA = 1 << 2,
> MONO_CFG_HAS_VARARGS = 1 << 3,
> MONO_CFG_HAS_TAIL = 1 << 4,
> MONO_CFG_HAS_FPOUT = 1 << 5,
> MONO_CFG_HAS_SPILLUP = 1 << 6,
> MONO_CFG_HAS_CHECK_THIS = 1 << 7,
> MONO_CFG_HAS_ARRAY_ACCESS = 1 << 8
>} MonoCompileFlags;
>
>typedef struct {
> gulong methods_compiled;
> gulong methods_aot;
> gulong methods_lookups;
> gulong allocate_var;
> gulong cil_code_size;
> gulong native_code_size;
> gulong code_reallocs;
> gulong max_code_size_ratio;
> gulong biggest_method_size;
> gulong allocated_code_size;
> gulong inlineable_methods;
> gulong inlined_methods;
> gulong basic_blocks;
> gulong max_basic_blocks;
> gulong locals_stack_size;
> gulong regvars;
> gulong cas_declsec_check;
> gulong cas_linkdemand_icall;
> gulong cas_linkdemand_pinvoke;
> gulong cas_linkdemand_aptc;
> gulong cas_linkdemand;
> gulong cas_demand_generation;
> gulong generic_virtual_invocations;
>    int methods_with_llvm;
> int methods_without_llvm;
> char *max_ratio_method;
> char *biggest_method;
> double jit_time;
> gboolean enabled;
>} MonoJitStats;
>
>extern MonoJitStats mono_jit_stats;
># 1460 "mini.h"
>enum {
> OP_START = MONO_CEE_LAST - 1,
># 1 "mini-ops.h" 1
>
>OP_LOAD,
>OP_LDADDR,
>OP_STORE,
>OP_NOP,
>OP_HARD_NOP,
>OP_RELAXED_NOP,
>OP_PHI,
>OP_FPHI,
>OP_VPHI,
>OP_COMPARE,
>OP_COMPARE_IMM,
>OP_FCOMPARE,
>OP_LCOMPARE,
>OP_ICOMPARE,
>OP_ICOMPARE_IMM,
>OP_LCOMPARE_IMM,
>OP_LOCAL,
>OP_ARG,
>
>
>
>
>OP_OUTARG_VT,
>OP_OUTARG_VTRETADDR,
>OP_SETRET,
>OP_SETFRET,
>OP_SETLRET,
>OP_LOCALLOC,
>OP_LOCALLOC_IMM,
>OP_CHECK_THIS,
>OP_SEQ_POINT,
>OP_IMPLICIT_EXCEPTION,
>
>OP_VOIDCALL,
>OP_VOIDCALLVIRT,
>OP_VOIDCALL_REG,
>OP_VOIDCALL_MEMBASE,
>OP_CALL,
>OP_CALL_REG,
>OP_CALL_MEMBASE,
>OP_CALLVIRT,
>OP_FCALL,
>OP_FCALLVIRT,
>OP_FCALL_REG,
>OP_FCALL_MEMBASE,
>OP_LCALL,
>OP_LCALLVIRT,
>OP_LCALL_REG,
>OP_LCALL_MEMBASE,
>OP_VCALL,
>OP_VCALLVIRT,
>OP_VCALL_REG,
>OP_VCALL_MEMBASE,
>
>OP_VCALL2,
>OP_VCALL2_REG,
>OP_VCALL2_MEMBASE,
>OP_DYN_CALL,
>
>OP_ICONST,
>OP_I8CONST,
>OP_R4CONST,
>OP_R8CONST,
>OP_REGVAR,
>OP_REGOFFSET,
>OP_VTARG_ADDR,
>OP_LABEL,
>OP_SWITCH,
>OP_THROW,
>OP_RETHROW,
># 88 "mini-ops.h"
>OP_ARGLIST,
>
>
>OP_STORE_MEMBASE_REG,
>OP_STOREI1_MEMBASE_REG,
>OP_STOREI2_MEMBASE_REG,
>OP_STOREI4_MEMBASE_REG,
>OP_STOREI8_MEMBASE_REG,
>OP_STORER4_MEMBASE_REG,
>OP_STORER8_MEMBASE_REG,
>
>
>
>
>
>
>
>OP_STORE_MEMBASE_IMM,
>OP_STOREI1_MEMBASE_IMM,
>OP_STOREI2_MEMBASE_IMM,
>OP_STOREI4_MEMBASE_IMM,
>OP_STOREI8_MEMBASE_IMM,
>OP_STOREX_MEMBASE,
>OP_STOREV_MEMBASE,
>
>
>OP_LOAD_MEMBASE,
>OP_LOADI1_MEMBASE,
>OP_LOADU1_MEMBASE,
>OP_LOADI2_MEMBASE,
>OP_LOADU2_MEMBASE,
>OP_LOADI4_MEMBASE,
>OP_LOADU4_MEMBASE,
>OP_LOADI8_MEMBASE,
>OP_LOADR4_MEMBASE,
>OP_LOADR8_MEMBASE,
>
>OP_LOADX_MEMBASE,
>
>
>
>
>
>OP_LOADV_MEMBASE,
>
>
>OP_LOAD_MEMINDEX,
>OP_LOADI1_MEMINDEX,
>OP_LOADU1_MEMINDEX,
>OP_LOADI2_MEMINDEX,
>OP_LOADU2_MEMINDEX,
>OP_LOADI4_MEMINDEX,
>OP_LOADU4_MEMINDEX,
>OP_LOADI8_MEMINDEX,
>OP_LOADR4_MEMINDEX,
>OP_LOADR8_MEMINDEX,
>
>
>OP_STORE_MEMINDEX,
>OP_STOREI1_MEMINDEX,
>OP_STOREI2_MEMINDEX,
>OP_STOREI4_MEMINDEX,
>OP_STOREI8_MEMINDEX,
>OP_STORER4_MEMINDEX,
>OP_STORER8_MEMINDEX,
>
>OP_LOAD_MEM,
>OP_LOADU1_MEM,
>OP_LOADU2_MEM,
>OP_LOADI4_MEM,
>OP_LOADU4_MEM,
>OP_LOADI8_MEM,
>OP_STORE_MEM_IMM,
>
>OP_MOVE,
>OP_LMOVE,
>OP_FMOVE,
>OP_VMOVE,
>
>OP_VZERO,
>
>OP_ADD_IMM,
>OP_SUB_IMM,
>OP_MUL_IMM,
>OP_DIV_IMM,
>OP_DIV_UN_IMM,
>OP_REM_IMM,
>OP_REM_UN_IMM,
>OP_AND_IMM,
>OP_OR_IMM,
>OP_XOR_IMM,
>OP_SHL_IMM,
>OP_SHR_IMM,
>OP_SHR_UN_IMM,
>
>OP_BR,
>OP_JMP,
>
>OP_TAILCALL,
>OP_BREAK,
>
>OP_CEQ,
>OP_CGT,
>OP_CGT_UN,
>OP_CLT,
>OP_CLT_UN,
>
>
>OP_COND_EXC_EQ,
>OP_COND_EXC_GE,
>OP_COND_EXC_GT,
>OP_COND_EXC_LE,
>OP_COND_EXC_LT,
>OP_COND_EXC_NE_UN,
>OP_COND_EXC_GE_UN,
>OP_COND_EXC_GT_UN,
>OP_COND_EXC_LE_UN,
>OP_COND_EXC_LT_UN,
>
>OP_COND_EXC_OV,
>OP_COND_EXC_NO,
>OP_COND_EXC_C,
>OP_COND_EXC_NC,
>
>OP_COND_EXC_IEQ,
>OP_COND_EXC_IGE,
>OP_COND_EXC_IGT,
>OP_COND_EXC_ILE,
>OP_COND_EXC_ILT,
>OP_COND_EXC_INE_UN,
>OP_COND_EXC_IGE_UN,
>OP_COND_EXC_IGT_UN,
>OP_COND_EXC_ILE_UN,
>OP_COND_EXC_ILT_UN,
>
>OP_COND_EXC_IOV,
>OP_COND_EXC_INO,
>OP_COND_EXC_IC,
>OP_COND_EXC_INC,
>
>
>OP_LADD,
>OP_LSUB,
>OP_LMUL,
>OP_LDIV,
>OP_LDIV_UN,
>OP_LREM,
>OP_LREM_UN,
>OP_LAND,
>OP_LOR,
>OP_LXOR,
>OP_LSHL,
>OP_LSHR,
>OP_LSHR_UN,
>
>
>OP_LNEG,
>OP_LNOT,
>OP_LCONV_TO_I1,
>OP_LCONV_TO_I2,
>OP_LCONV_TO_I4,
>OP_LCONV_TO_I8,
>OP_LCONV_TO_R4,
>OP_LCONV_TO_R8,
>OP_LCONV_TO_U4,
>OP_LCONV_TO_U8,
>
>OP_LCONV_TO_U2,
>OP_LCONV_TO_U1,
>OP_LCONV_TO_I,
>OP_LCONV_TO_OVF_I,
>OP_LCONV_TO_OVF_U,
>
>OP_LADD_OVF,
>OP_LADD_OVF_UN,
>OP_LMUL_OVF,
>OP_LMUL_OVF_UN,
>OP_LSUB_OVF,
>OP_LSUB_OVF_UN,
>
>OP_LCONV_TO_OVF_I1_UN,
>OP_LCONV_TO_OVF_I2_UN,
>OP_LCONV_TO_OVF_I4_UN,
>OP_LCONV_TO_OVF_I8_UN,
>OP_LCONV_TO_OVF_U1_UN,
>OP_LCONV_TO_OVF_U2_UN,
>OP_LCONV_TO_OVF_U4_UN,
>OP_LCONV_TO_OVF_U8_UN,
>OP_LCONV_TO_OVF_I_UN,
>OP_LCONV_TO_OVF_U_UN,
>
>OP_LCONV_TO_OVF_I1,
>OP_LCONV_TO_OVF_U1,
>OP_LCONV_TO_OVF_I2,
>OP_LCONV_TO_OVF_U2,
>OP_LCONV_TO_OVF_I4,
>OP_LCONV_TO_OVF_U4,
>OP_LCONV_TO_OVF_I8,
>OP_LCONV_TO_OVF_U8,
>
>
>OP_LCEQ,
>OP_LCGT,
>OP_LCGT_UN,
>OP_LCLT,
>OP_LCLT_UN,
>
>OP_LCONV_TO_R_UN,
>OP_LCONV_TO_U,
>
>OP_LADD_IMM,
>OP_LSUB_IMM,
>OP_LMUL_IMM,
>OP_LAND_IMM,
>OP_LOR_IMM,
>OP_LXOR_IMM,
>OP_LSHL_IMM,
>OP_LSHR_IMM,
>OP_LSHR_UN_IMM,
>OP_LDIV_IMM,
>OP_LDIV_UN_IMM,
>OP_LREM_IMM,
>OP_LREM_UN_IMM,
>
>
>OP_LBEQ,
>OP_LBGE,
>OP_LBGT,
>OP_LBLE,
>OP_LBLT,
>OP_LBNE_UN,
>OP_LBGE_UN,
>OP_LBGT_UN,
>OP_LBLE_UN,
>OP_LBLT_UN,
>
>
>OP_LCONV_TO_R8_2,
>OP_LCONV_TO_R4_2,
>OP_LCONV_TO_R_UN_2,
>OP_LCONV_TO_OVF_I4_2,
>
>
>OP_IADD,
>OP_ISUB,
>OP_IMUL,
>OP_IDIV,
>OP_IDIV_UN,
>OP_IREM,
>OP_IREM_UN,
>OP_IAND,
>OP_IOR,
>OP_IXOR,
>OP_ISHL,
>OP_ISHR,
>OP_ISHR_UN,
>
>
>OP_INEG,
>OP_INOT,
>OP_ICONV_TO_I1,
>OP_ICONV_TO_I2,
>OP_ICONV_TO_I4,
>OP_ICONV_TO_I8,
>OP_ICONV_TO_R4,
>OP_ICONV_TO_R8,
>OP_ICONV_TO_U4,
>OP_ICONV_TO_U8,
>
>OP_ICONV_TO_R_UN,
>OP_ICONV_TO_U,
>
>
>OP_ICONV_TO_U2,
>OP_ICONV_TO_U1,
>OP_ICONV_TO_I,
>OP_ICONV_TO_OVF_I,
>OP_ICONV_TO_OVF_U,
>OP_IADD_OVF,
>OP_IADD_OVF_UN,
>OP_IMUL_OVF,
>OP_IMUL_OVF_UN,
>OP_ISUB_OVF,
>OP_ISUB_OVF_UN,
>
>
>OP_ICONV_TO_OVF_I1_UN,
>OP_ICONV_TO_OVF_I2_UN,
>OP_ICONV_TO_OVF_I4_UN,
>OP_ICONV_TO_OVF_I8_UN,
>OP_ICONV_TO_OVF_U1_UN,
>OP_ICONV_TO_OVF_U2_UN,
>OP_ICONV_TO_OVF_U4_UN,
>OP_ICONV_TO_OVF_U8_UN,
>OP_ICONV_TO_OVF_I_UN,
>OP_ICONV_TO_OVF_U_UN,
>
>
>OP_ICONV_TO_OVF_I1,
>OP_ICONV_TO_OVF_U1,
>OP_ICONV_TO_OVF_I2,
>OP_ICONV_TO_OVF_U2,
>OP_ICONV_TO_OVF_I4,
>OP_ICONV_TO_OVF_U4,
>OP_ICONV_TO_OVF_I8,
>OP_ICONV_TO_OVF_U8,
>
>OP_IADC,
>OP_IADC_IMM,
>OP_ISBB,
>OP_ISBB_IMM,
>OP_IADDCC,
>OP_ISUBCC,
>
>OP_IADD_IMM,
>OP_ISUB_IMM,
>OP_IMUL_IMM,
>OP_IDIV_IMM,
>OP_IDIV_UN_IMM,
>OP_IREM_IMM,
>OP_IREM_UN_IMM,
>OP_IAND_IMM,
>OP_IOR_IMM,
>OP_IXOR_IMM,
>OP_ISHL_IMM,
>OP_ISHR_IMM,
>OP_ISHR_UN_IMM,
>
>OP_ICEQ,
>OP_ICGT,
>OP_ICGT_UN,
>OP_ICLT,
>OP_ICLT_UN,
>
>OP_IBEQ,
>OP_IBGE,
>OP_IBGT,
>OP_IBLE,
>OP_IBLT,
>OP_IBNE_UN,
>OP_IBGE_UN,
>OP_IBGT_UN,
>OP_IBLE_UN,
>OP_IBLT_UN,
>
>OP_FBEQ,
>OP_FBGE,
>OP_FBGT,
>OP_FBLE,
>OP_FBLT,
>OP_FBNE_UN,
>OP_FBGE_UN,
>OP_FBGT_UN,
>OP_FBLE_UN,
>OP_FBLT_UN,
>
>
>OP_FADD,
>OP_FSUB,
>OP_FMUL,
>OP_FDIV,
>OP_FDIV_UN,
>OP_FREM,
>OP_FREM_UN,
>
>
>OP_FNEG,
>OP_FNOT,
>OP_FCONV_TO_I1,
>OP_FCONV_TO_I2,
>OP_FCONV_TO_I4,
>OP_FCONV_TO_I8,
>OP_FCONV_TO_R4,
>OP_FCONV_TO_R8,
>OP_FCONV_TO_U4,
>OP_FCONV_TO_U8,
>
>OP_FCONV_TO_U2,
>OP_FCONV_TO_U1,
>OP_FCONV_TO_I,
>OP_FCONV_TO_OVF_I,
>OP_FCONV_TO_OVF_U,
>
>OP_FADD_OVF,
>OP_FADD_OVF_UN,
>OP_FMUL_OVF,
>OP_FMUL_OVF_UN,
>OP_FSUB_OVF,
>OP_FSUB_OVF_UN,
>
>OP_FCONV_TO_OVF_I1_UN,
>OP_FCONV_TO_OVF_I2_UN,
>OP_FCONV_TO_OVF_I4_UN,
>OP_FCONV_TO_OVF_I8_UN,
>OP_FCONV_TO_OVF_U1_UN,
>OP_FCONV_TO_OVF_U2_UN,
>OP_FCONV_TO_OVF_U4_UN,
>OP_FCONV_TO_OVF_U8_UN,
>OP_FCONV_TO_OVF_I_UN,
>OP_FCONV_TO_OVF_U_UN,
>
>OP_FCONV_TO_OVF_I1,
>OP_FCONV_TO_OVF_U1,
>OP_FCONV_TO_OVF_I2,
>OP_FCONV_TO_OVF_U2,
>OP_FCONV_TO_OVF_I4,
>OP_FCONV_TO_OVF_U4,
>OP_FCONV_TO_OVF_I8,
>OP_FCONV_TO_OVF_U8,
>
>
>OP_FCEQ,
>OP_FCGT,
>OP_FCGT_UN,
>OP_FCLT,
>OP_FCLT_UN,
>
>OP_FCEQ_MEMBASE,
>OP_FCGT_MEMBASE,
>OP_FCGT_UN_MEMBASE,
>OP_FCLT_MEMBASE,
>OP_FCLT_UN_MEMBASE,
>
>OP_FCONV_TO_U,
>OP_CKFINITE,
>
>
>OP_FGETLOW32,
>
>OP_FGETHIGH32,
>
>OP_JUMP_TABLE,
>
>
>OP_AOTCONST,
>OP_PATCH_INFO,
>OP_GOT_ENTRY,
>
>
>OP_CALL_HANDLER,
>OP_START_HANDLER,
>OP_ENDFILTER,
>OP_ENDFINALLY,
>
>
>OP_BIGMUL,
>OP_BIGMUL_UN,
>OP_IMIN_UN,
>OP_IMAX_UN,
>OP_LMIN_UN,
>OP_LMAX_UN,
>
>OP_MIN,
>OP_MAX,
>
>OP_IMIN,
>OP_IMAX,
>OP_LMIN,
>OP_LMAX,
>
>
>OP_ADC,
>OP_ADC_IMM,
>OP_SBB,
>OP_SBB_IMM,
>OP_ADDCC,
>OP_ADDCC_IMM,
>OP_SUBCC,
>OP_SUBCC_IMM,
>OP_BR_REG,
>OP_SEXT_I1,
>OP_SEXT_I2,
>OP_SEXT_I4,
>OP_ZEXT_I1,
>OP_ZEXT_I2,
>OP_ZEXT_I4,
>OP_CNE,
>OP_TRUNC_I4,
>
>OP_ADD_OVF_CARRY,
>OP_SUB_OVF_CARRY,
>OP_ADD_OVF_UN_CARRY,
>OP_SUB_OVF_UN_CARRY,
>
>
>OP_SIN,
>OP_COS,
>OP_ABS,
>OP_TAN,
>OP_ATAN,
>OP_SQRT,
>OP_ROUND,
>
>OP_STRLEN,
>OP_NEWARR,
>OP_LDLEN,
>OP_BOUNDS_CHECK,
>
>OP_LDELEMA2D,
>
>OP_MEMCPY,
>
>OP_MEMSET,
>OP_SAVE_LMF,
>OP_RESTORE_LMF,
>
>
>OP_CARD_TABLE_WBARRIER,
>
>
>OP_TLS_GET,
>
>OP_LOAD_GOTADDR,
>OP_DUMMY_USE,
>OP_DUMMY_STORE,
>OP_NOT_REACHED,
>OP_NOT_NULL,
># 821 "mini-ops.h"
>OP_XMOVE,
>OP_XZERO,
>OP_XPHI,
># 836 "mini-ops.h"
>OP_ATOMIC_ADD_I4,
>OP_ATOMIC_ADD_NEW_I4,
>OP_ATOMIC_ADD_IMM_I4,
>OP_ATOMIC_ADD_IMM_NEW_I4,
>OP_ATOMIC_EXCHANGE_I4,
>
>OP_ATOMIC_ADD_I8,
>OP_ATOMIC_ADD_NEW_I8,
>OP_ATOMIC_ADD_IMM_I8,
>OP_ATOMIC_ADD_IMM_NEW_I8,
>OP_ATOMIC_EXCHANGE_I8,
>OP_MEMORY_BARRIER,
>
>OP_ATOMIC_CAS_I4,
>OP_ATOMIC_CAS_I8,
># 861 "mini-ops.h"
>OP_CMOV_IEQ,
>OP_CMOV_IGE,
>OP_CMOV_IGT,
>OP_CMOV_ILE,
>OP_CMOV_ILT,
>OP_CMOV_INE_UN,
>OP_CMOV_IGE_UN,
>OP_CMOV_IGT_UN,
>OP_CMOV_ILE_UN,
>OP_CMOV_ILT_UN,
>
>OP_CMOV_LEQ,
>OP_CMOV_LGE,
>OP_CMOV_LGT,
>OP_CMOV_LLE,
>OP_CMOV_LLT,
>OP_CMOV_LNE_UN,
>OP_CMOV_LGE_UN,
>OP_CMOV_LGT_UN,
>OP_CMOV_LLE_UN,
>OP_CMOV_LLT_UN,
>
>
>
>
>
>
>OP_LIVERANGE_START,
>
>
>
>
>OP_LIVERANGE_END,
>
>
>
>
>
>
>OP_GC_LIVENESS_DEF,
>OP_GC_LIVENESS_USE,
>
>
>
>
>
>OP_GC_SPILL_SLOT_LIVENESS_DEF,
>
>
>
>
>
>OP_GC_PARAM_SLOT_LIVENESS_DEF,
># 1032 "mini-ops.h"
>OP_S390_LOADARG,
>OP_S390_ARGREG,
>OP_S390_ARGPTR,
>OP_S390_STKARG,
>OP_S390_MOVE,
>OP_S390_SETF4RET,
>OP_S390_BKCHAIN,
>OP_S390_LADD,
>OP_S390_LADD_OVF,
>OP_S390_LADD_OVF_UN,
>OP_S390_LSUB,
>OP_S390_LSUB_OVF,
>OP_S390_LSUB_OVF_UN,
>OP_S390_LNEG,
>OP_S390_IADD_OVF,
>OP_S390_IADD_OVF_UN,
>OP_S390_ISUB_OVF,
>OP_S390_ISUB_OVF_UN,
># 1463 "mini.h" 2
> OP_LAST
>};
># 1525 "mini.h"
>typedef enum {
> STACK_INV,
> STACK_I4,
> STACK_I8,
> STACK_PTR,
> STACK_R8,
> STACK_MP,
> STACK_OBJ,
> STACK_VTYPE,
> STACK_MAX
>} MonoStackType;
>
>typedef struct {
> union {
>  double r8;
>  gint32 i4;
>  gint64 i8;
>  gpointer p;
>  MonoClass *klass;
> } data;
> int type;
>} StackSlot;
>
>
>extern const guint8 mono_burg_arity [];
>
>
>
>
>extern const char s390x_cpu_desc [] __attribute__ ((visibility ("hidden")));
>
>
>extern const guint16 s390x_cpu_desc_idx [] __attribute__ ((visibility ("hidden")));
>
>
>enum {
> MONO_COMP_DOM = 1,
> MONO_COMP_IDOM = 2,
> MONO_COMP_DFRONTIER = 4,
> MONO_COMP_DOM_REV = 8,
> MONO_COMP_LIVENESS = 16,
> MONO_COMP_SSA = 32,
> MONO_COMP_SSA_DEF_USE = 64,
> MONO_COMP_REACHABILITY = 128,
> MONO_COMP_LOOPS = 256
>};
>
>typedef enum {
> MONO_GRAPH_CFG = 1,
> MONO_GRAPH_DTREE = 2,
> MONO_GRAPH_CFG_CODE = 4,
> MONO_GRAPH_CFG_SSA = 8,
> MONO_GRAPH_CFG_OPTCODE = 16
>} MonoGraphOptions;
>
>typedef struct {
> guint16 size;
> guint16 offset;
> guint8 pad;
>} MonoJitArgumentInfo;
>
>typedef struct {
> gboolean handle_sigint;
> gboolean keep_delegates;
> gboolean reverse_pinvoke_exceptions;
> gboolean collect_pagefault_stats;
> gboolean break_on_unverified;
> gboolean better_cast_details;
> gboolean mdb_optimizations;
> gboolean no_gdb_backtrace;
> gboolean suspend_on_sigsegv;
> gboolean suspend_on_unhandled;
> gboolean dyn_runtime_invoke;
> gboolean gdb;
> gboolean gen_seq_points;
> gboolean explicit_null_checks;
>
>
>
>
> gboolean init_stacks;
>
>
>
>
>
>
>
> gboolean soft_breakpoints;
>} MonoDebugOptions;
>
>enum {
> BRANCH_NOT_TAKEN,
> BRANCH_TAKEN,
> BRANCH_UNDEF
>};
>
>typedef enum {
> CMP_EQ,
> CMP_NE,
> CMP_LE,
> CMP_GE,
> CMP_LT,
> CMP_GT,
> CMP_LE_UN,
> CMP_GE_UN,
> CMP_LT_UN,
> CMP_GT_UN
>} CompRelation;
>
>typedef enum {
> CMP_TYPE_L,
> CMP_TYPE_I,
> CMP_TYPE_F
>} CompType;
>
>
>enum {
> MONO_EXC_INDEX_OUT_OF_RANGE,
> MONO_EXC_OVERFLOW,
> MONO_EXC_ARITHMETIC,
> MONO_EXC_DIVIDE_BY_ZERO,
> MONO_EXC_INVALID_CAST,
> MONO_EXC_NULL_REF,
> MONO_EXC_ARRAY_TYPE_MISMATCH,
> MONO_EXC_ARGUMENT,
> MONO_EXC_INTRINS_NUM
>};
>
>enum {
> MINI_TOKEN_SOURCE_CLASS,
> MINI_TOKEN_SOURCE_METHOD,
> MINI_TOKEN_SOURCE_FIELD
>};
>
>
>
>
> typedef struct
> {
>
>
>
>  guint8 *code;
>  guint32 code_size;
>
>
>
>
>  char *name;
>
>
>
> MonoJumpInfo *ji;
>
>
>
> GSList *unwind_ops;
>} MonoTrampInfo;
>
>typedef void (*MonoInstFunc) (MonoInst *tree, gpointer data);
>
>
>int mono_main (int argc, char* argv[]);
>void mono_set_defaults (int verbose_level, guint32 opts);
>MonoDomain* mini_init (const char *filename, const char *runtime_version) __attribute__ ((visibility ("hidden")));
>void mini_cleanup (MonoDomain *domain) __attribute__ ((visibility ("hidden")));
>MonoDebugOptions *mini_get_debug_options (void) __attribute__ ((visibility ("hidden")));
>char* mono_get_runtime_build_info (void) __attribute__ ((visibility ("hidden")));
>
>
>void mono_disable_optimizations (guint32 opts) __attribute__ ((visibility ("hidden")));
>MonoJumpInfoToken* mono_jump_info_token_new (MonoMemPool *mp, MonoImage *image, guint32 token) __attribute__ ((visibility ("hidden")));
>MonoJumpInfoToken* mono_jump_info_token_new2 (MonoMemPool *mp, MonoImage *image, guint32 token, MonoGenericContext *context) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_find_spvar_for_region (MonoCompile *cfg, int region) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_find_exvar_for_offset (MonoCompile *cfg, int offset) __attribute__ ((visibility ("hidden")));
>int mono_get_block_region_notry (MonoCompile *cfg, int region) __attribute__ ((visibility ("hidden")));
>
>void mono_precompile_assemblies (void) __attribute__ ((visibility ("hidden")));
>int mono_parse_default_optimizations (const char* p);
>void mono_bblock_add_inst (MonoBasicBlock *bb, MonoInst *inst) __attribute__ ((visibility ("hidden")));
>void mono_bblock_insert_after_ins (MonoBasicBlock *bb, MonoInst *ins, MonoInst *ins_to_insert) __attribute__ ((visibility ("hidden")));
>void mono_bblock_insert_before_ins (MonoBasicBlock *bb, MonoInst *ins, MonoInst *ins_to_insert) __attribute__ ((visibility ("hidden")));
>void mono_verify_bblock (MonoBasicBlock *bb) __attribute__ ((visibility ("hidden")));
>void mono_verify_cfg (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_constant_fold (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_constant_fold_ins (MonoCompile *cfg, MonoInst *ins, MonoInst *arg1, MonoInst *arg2, gboolean overwrite) __attribute__ ((visibility ("hidden")));
>int mono_eval_cond_branch (MonoInst *branch) __attribute__ ((visibility ("hidden")));
>int mono_is_power_of_two (guint32 val) __attribute__ ((visibility ("hidden")));
>void mono_cprop_local (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst **acp, int acp_size) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_compile_create_var (MonoCompile *cfg, MonoType *type, int opcode) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_compile_create_var_for_vreg (MonoCompile *cfg, MonoType *type, int opcode, int vreg) __attribute__ ((visibility ("hidden")));
>void mono_compile_make_var_load (MonoCompile *cfg, MonoInst *dest, gssize var_index) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_compile_create_var_load (MonoCompile *cfg, gssize var_index) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_compile_create_var_store (MonoCompile *cfg, gssize var_index, MonoInst *value) __attribute__ ((visibility ("hidden")));
>MonoType* mono_type_from_stack_type (MonoInst *ins) __attribute__ ((visibility ("hidden")));
>guint32 mono_alloc_ireg (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>guint32 mono_alloc_freg (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>guint32 mono_alloc_preg (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>guint32 mono_alloc_dreg (MonoCompile *cfg, MonoStackType stack_type) __attribute__ ((visibility ("hidden")));
>guint32 mono_alloc_ireg_ref (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>guint32 mono_alloc_ireg_mp (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>guint32 mono_alloc_ireg_copy (MonoCompile *cfg, guint32 vreg) __attribute__ ((visibility ("hidden")));
>void mono_mark_vreg_as_ref (MonoCompile *cfg, int vreg) __attribute__ ((visibility ("hidden")));
>void mono_mark_vreg_as_mp (MonoCompile *cfg, int vreg) __attribute__ ((visibility ("hidden")));
>
>void mono_link_bblock (MonoCompile *cfg, MonoBasicBlock *from, MonoBasicBlock* to) __attribute__ ((visibility ("hidden")));
>void mono_unlink_bblock (MonoCompile *cfg, MonoBasicBlock *from, MonoBasicBlock* to) __attribute__ ((visibility ("hidden")));
>gboolean mono_bblocks_linked (MonoBasicBlock *bb1, MonoBasicBlock *bb2) __attribute__ ((visibility ("hidden")));
>void mono_remove_bblock (MonoCompile *cfg, MonoBasicBlock *bb) __attribute__ ((visibility ("hidden")));
>void mono_nullify_basic_block (MonoBasicBlock *bb) __attribute__ ((visibility ("hidden")));
>void mono_merge_basic_blocks (MonoCompile *cfg, MonoBasicBlock *bb, MonoBasicBlock *bbn) __attribute__ ((visibility ("hidden")));
>void mono_optimize_branches (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>
>void mono_blockset_print (MonoCompile *cfg, MonoBitSet *set, const char *name, guint idom) __attribute__ ((visibility ("hidden")));
>void mono_print_ins_index (int i, MonoInst *ins) __attribute__ ((visibility ("hidden")));
>void mono_print_ins (MonoInst *ins) __attribute__ ((visibility ("hidden")));
>void mono_print_bb (MonoBasicBlock *bb, const char *msg) __attribute__ ((visibility ("hidden")));
>void mono_print_code (MonoCompile *cfg, const char *msg) __attribute__ ((visibility ("hidden")));
>void mono_print_method_from_ip (void *ip);
>char *mono_pmip (void *ip);
>const char* mono_inst_name (int op);
>void mono_inst_set_src_registers (MonoInst *ins, int *regs) __attribute__ ((visibility ("hidden")));
>int mono_op_to_op_imm (int opcode) __attribute__ ((visibility ("hidden")));
>int mono_op_imm_to_op (int opcode) __attribute__ ((visibility ("hidden")));
>int mono_load_membase_to_load_mem (int opcode) __attribute__ ((visibility ("hidden")));
>guint mono_type_to_load_membase (MonoCompile *cfg, MonoType *type) __attribute__ ((visibility ("hidden")));
>guint mono_type_to_store_membase (MonoCompile *cfg, MonoType *type) __attribute__ ((visibility ("hidden")));
>guint mini_type_to_stind (MonoCompile* cfg, MonoType *type) __attribute__ ((visibility ("hidden")));
>guint32 mono_reverse_branch_op (guint32 opcode) __attribute__ ((visibility ("hidden")));
>void mono_disassemble_code (MonoCompile *cfg, guint8 *code, int size, char *id) __attribute__ ((visibility ("hidden")));
>void mono_add_patch_info (MonoCompile *cfg, int ip, MonoJumpInfoType type, gconstpointer target) __attribute__ ((visibility ("hidden")));
>void mono_remove_patch_info (MonoCompile *cfg, int ip) __attribute__ ((visibility ("hidden")));
>MonoJumpInfo* mono_patch_info_dup_mp (MonoMemPool *mp, MonoJumpInfo *patch_info) __attribute__ ((visibility ("hidden")));
>guint mono_patch_info_hash (gconstpointer data) __attribute__ ((visibility ("hidden")));
>gint mono_patch_info_equal (gconstpointer ka, gconstpointer kb) __attribute__ ((visibility ("hidden")));
>MonoJumpInfo *mono_patch_info_list_prepend (MonoJumpInfo *list, int ip, MonoJumpInfoType type, gconstpointer target) __attribute__ ((visibility ("hidden")));
>gpointer mono_resolve_patch_target (MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *patch_info, gboolean run_cctors) __attribute__ ((visibility ("hidden")));
>gpointer mono_jit_find_compiled_method_with_jit_info (MonoDomain *domain, MonoMethod *method, MonoJitInfo **ji) __attribute__ ((visibility ("hidden")));
>gpointer mono_jit_find_compiled_method (MonoDomain *domain, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>gpointer mono_jit_compile_method (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>MonoLMF * mono_get_lmf (void) __attribute__ ((visibility ("hidden")));
>MonoLMF** mono_get_lmf_addr (void) __attribute__ ((visibility ("hidden")));
>void mono_set_lmf (MonoLMF *lmf) __attribute__ ((visibility ("hidden")));
>void mono_jit_thread_attach (MonoDomain *domain);
>guint32 mono_get_jit_tls_key (void) __attribute__ ((visibility ("hidden")));
>gint32 mono_get_jit_tls_offset (void) __attribute__ ((visibility ("hidden")));
>gint32 mono_get_lmf_tls_offset (void) __attribute__ ((visibility ("hidden")));
>gint32 mono_get_lmf_addr_tls_offset (void) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_get_jit_tls_intrinsic (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_get_domain_intrinsic (MonoCompile* cfg) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_get_thread_intrinsic (MonoCompile* cfg) __attribute__ ((visibility ("hidden")));
>GList *mono_varlist_insert_sorted (MonoCompile *cfg, GList *list, MonoMethodVar *mv, int sort_type) __attribute__ ((visibility ("hidden")));
>GList *mono_varlist_sort (MonoCompile *cfg, GList *list, int sort_type) __attribute__ ((visibility ("hidden")));
>void mono_analyze_liveness (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_analyze_liveness_gc (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_linear_scan (MonoCompile *cfg, GList *vars, GList *regs, regmask_t *used_mask) __attribute__ ((visibility ("hidden")));
>void mono_global_regalloc (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_create_jump_table (MonoCompile *cfg, MonoInst *label, MonoBasicBlock **bbs, int num_blocks) __attribute__ ((visibility ("hidden")));
>int mono_compile_assembly (MonoAssembly *ass, guint32 opts, const char *aot_options) __attribute__ ((visibility ("hidden")));
>MonoCompile *mini_method_compile (MonoMethod *method, guint32 opts, MonoDomain *domain, gboolean run_cctors, gboolean compile_aot, int parts) __attribute__ ((visibility ("hidden")));
>void mono_destroy_compile (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>MonoJitICallInfo *mono_find_jit_opcode_emulation (int opcode) __attribute__ ((visibility ("hidden")));
>void mono_print_ins_index (int i, MonoInst *ins) __attribute__ ((visibility ("hidden")));
>void mono_print_ins (MonoInst *ins) __attribute__ ((visibility ("hidden")));
>gboolean mini_assembly_can_skip_verification (MonoDomain *domain, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>gboolean mono_compile_is_broken (MonoCompile *cfg, MonoMethod *method, gboolean fail_compile) __attribute__ ((visibility ("hidden")));
>MonoInst *mono_get_got_var (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_add_seq_point (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst *ins, int native_offset) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_emit_jit_icall (MonoCompile *cfg, gconstpointer func, MonoInst **args) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_emit_method_call (MonoCompile *cfg, MonoMethod *method, MonoInst **args, MonoInst *this) __attribute__ ((visibility ("hidden")));
>void mono_create_helper_signatures (void) __attribute__ ((visibility ("hidden")));
>
>gboolean mini_class_is_system_array (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>MonoMethodSignature *mono_get_element_address_signature (int arity) __attribute__ ((visibility ("hidden")));
>MonoJitICallInfo *mono_get_element_address_icall (int rank) __attribute__ ((visibility ("hidden")));
>MonoJitICallInfo *mono_get_array_new_va_icall (int rank) __attribute__ ((visibility ("hidden")));
>
>void mono_linterval_add_range (MonoCompile *cfg, MonoLiveInterval *interval, int from, int to) __attribute__ ((visibility ("hidden")));
>void mono_linterval_print (MonoLiveInterval *interval) __attribute__ ((visibility ("hidden")));
>void mono_linterval_print_nl (MonoLiveInterval *interval) __attribute__ ((visibility ("hidden")));
>gboolean mono_linterval_covers (MonoLiveInterval *interval, int pos) __attribute__ ((visibility ("hidden")));
>gint32 mono_linterval_get_intersect_pos (MonoLiveInterval *i1, MonoLiveInterval *i2) __attribute__ ((visibility ("hidden")));
>void mono_linterval_split (MonoCompile *cfg, MonoLiveInterval *interval, MonoLiveInterval **i1, MonoLiveInterval **i2, int pos) __attribute__ ((visibility ("hidden")));
>void mono_liveness_handle_exception_clauses (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>
>
>gpointer mono_realloc_native_code(MonoCompile *cfg);
># 1838 "mini.h"
>void mono_aot_init (void) __attribute__ ((visibility ("hidden")));
>void mono_aot_cleanup (void) __attribute__ ((visibility ("hidden")));
>gpointer mono_aot_get_method (MonoDomain *domain,
>            MonoMethod *method) __attribute__ ((visibility ("hidden")));
>gpointer mono_aot_get_method_from_token (MonoDomain *domain, MonoImage *image, guint32 token) __attribute__ ((visibility ("hidden")));
>gboolean mono_aot_is_got_entry (guint8 *code, guint8 *addr) __attribute__ ((visibility ("hidden")));
>guint8* mono_aot_get_plt_entry (guint8 *code) __attribute__ ((visibility ("hidden")));
>guint32 mono_aot_get_plt_info_offset (mgreg_t *regs, guint8 *code) __attribute__ ((visibility ("hidden")));
>gboolean mono_aot_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res) __attribute__ ((visibility ("hidden")));
>gboolean mono_aot_get_class_from_name (MonoImage *image, const char *name_space, const char *name, MonoClass **klass) __attribute__ ((visibility ("hidden")));
>MonoJitInfo* mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) __attribute__ ((visibility ("hidden")));
>gpointer mono_aot_plt_resolve (gpointer aot_module, guint32 plt_info_offset, guint8 *code) __attribute__ ((visibility ("hidden")));
>void mono_aot_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr) __attribute__ ((visibility ("hidden")));
>gpointer mono_aot_get_method_from_vt_slot (MonoDomain *domain, MonoVTable *vtable, int slot) __attribute__ ((visibility ("hidden")));
>gpointer mono_aot_create_specific_trampoline (MonoImage *image, gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) __attribute__ ((visibility ("hidden")));
>gpointer mono_aot_get_trampoline (const char *name) __attribute__ ((visibility ("hidden")));
>gpointer mono_aot_get_unbox_trampoline (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>gpointer mono_aot_get_lazy_fetch_trampoline (guint32 slot) __attribute__ ((visibility ("hidden")));
>gpointer mono_aot_get_static_rgctx_trampoline (gpointer ctx, gpointer addr) __attribute__ ((visibility ("hidden")));
>gpointer mono_aot_get_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp) __attribute__ ((visibility ("hidden")));
>guint8* mono_aot_get_unwind_info (MonoJitInfo *ji, guint32 *unwind_info_len) __attribute__ ((visibility ("hidden")));
>guint32 mono_aot_method_hash (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>char* mono_aot_wrapper_name (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>MonoMethod* mono_aot_get_array_helper_from_wrapper (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>guint32 mono_aot_get_got_offset (MonoJumpInfo *ji) __attribute__ ((visibility ("hidden")));
>char* mono_aot_get_method_name (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>char* mono_aot_get_plt_symbol (MonoJumpInfoType type, gconstpointer data) __attribute__ ((visibility ("hidden")));
>MonoJumpInfo* mono_aot_patch_info_dup (MonoJumpInfo* ji) __attribute__ ((visibility ("hidden")));
>void mono_aot_set_make_unreadable (gboolean unreadable) __attribute__ ((visibility ("hidden")));
>gboolean mono_aot_is_pagefault (void *ptr) __attribute__ ((visibility ("hidden")));
>void mono_aot_handle_pagefault (void *ptr) __attribute__ ((visibility ("hidden")));
>void mono_aot_register_jit_icall (const char *name, gpointer addr) __attribute__ ((visibility ("hidden")));
>
>
>void mono_aot_register_globals (gpointer *globals);
>
>void mono_aot_register_module (gpointer *aot_info);
>
>void mono_xdebug_init (char *xdebug_opts) __attribute__ ((visibility ("hidden")));
>void mono_save_xdebug_info (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_save_trampoline_xdebug_info (MonoTrampInfo *info) __attribute__ ((visibility ("hidden")));
>
>void mono_xdebug_flush (void);
>
>
>void mono_llvm_init (void) __attribute__ ((visibility ("hidden")));
>void mono_llvm_cleanup (void) __attribute__ ((visibility ("hidden")));
>void mono_llvm_emit_method (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_llvm_emit_call (MonoCompile *cfg, MonoCallInst *call) __attribute__ ((visibility ("hidden")));
>void mono_llvm_create_aot_module (const char *got_symbol) __attribute__ ((visibility ("hidden")));
>void mono_llvm_emit_aot_module (const char *filename, int got_size) __attribute__ ((visibility ("hidden")));
>void mono_llvm_check_method_supported (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_method_blittable (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>gboolean mono_method_same_domain (MonoJitInfo *caller, MonoJitInfo *callee) __attribute__ ((visibility ("hidden")));
>
>void mono_register_opcode_emulation (int opcode, const char* name, const char *sigstr, gpointer func, gboolean no_throw) __attribute__ ((visibility ("hidden")));
>void mono_draw_graph (MonoCompile *cfg, MonoGraphOptions draw_options) __attribute__ ((visibility ("hidden")));
>void mono_add_ins_to_end (MonoBasicBlock *bb, MonoInst *inst) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_ftnptr (MonoDomain *domain, gpointer addr) __attribute__ ((visibility ("hidden")));
>
>void mono_replace_ins (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst *ins, MonoInst **prev, MonoBasicBlock *first_bb, MonoBasicBlock *last_bb);
>
>int mono_find_method_opcode (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>MonoJitICallInfo *mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save) __attribute__ ((visibility ("hidden")));
>gconstpointer mono_icall_get_wrapper (MonoJitICallInfo* callinfo) __attribute__ ((visibility ("hidden")));
>
>void mono_trampolines_init (void) __attribute__ ((visibility ("hidden")));
>void mono_trampolines_cleanup (void) __attribute__ ((visibility ("hidden")));
>guint8 * mono_get_trampoline_code (MonoTrampolineType tramp_type) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_jump_trampoline (MonoDomain *domain,
>              MonoMethod *method,
>              gboolean add_sync_wrapper) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_class_init_trampoline (MonoVTable *vtable) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_generic_class_init_trampoline (void) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_jit_trampoline (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_jit_trampoline_from_token (MonoImage *image, guint32 token) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_jit_trampoline_in_domain (MonoDomain *domain, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_delegate_trampoline (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_rgctx_lazy_fetch_trampoline (guint32 offset) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_monitor_enter_trampoline (void) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_monitor_exit_trampoline (void) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_static_rgctx_trampoline (MonoMethod *m, gpointer addr) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_llvm_imt_trampoline (MonoDomain *domain, MonoMethod *m, int vt_offset) __attribute__ ((visibility ("hidden")));
>MonoVTable* mono_find_class_init_trampoline_by_addr (gconstpointer addr) __attribute__ ((visibility ("hidden")));
>guint32 mono_find_rgctx_lazy_fetch_trampoline_by_addr (gconstpointer addr) __attribute__ ((visibility ("hidden")));
>gpointer mono_magic_trampoline (mgreg_t *regs, guint8 *code, gpointer arg, guint8* tramp) __attribute__ ((visibility ("hidden")));
>gpointer mono_generic_virtual_remoting_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, guint8 *tramp) __attribute__ ((visibility ("hidden")));
>gpointer mono_delegate_trampoline (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp) __attribute__ ((visibility ("hidden")));
>gpointer mono_aot_trampoline (mgreg_t *regs, guint8 *code, guint8 *token_info,
>            guint8* tramp) __attribute__ ((visibility ("hidden")));
>gpointer mono_aot_plt_trampoline (mgreg_t *regs, guint8 *code, guint8 *token_info,
>             guint8* tramp) __attribute__ ((visibility ("hidden")));
>void mono_class_init_trampoline (mgreg_t *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp) __attribute__ ((visibility ("hidden")));
>void mono_generic_class_init_trampoline (mgreg_t *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp) __attribute__ ((visibility ("hidden")));
>void mono_monitor_enter_trampoline (mgreg_t *regs, guint8 *code, MonoObject *obj, guint8 *tramp) __attribute__ ((visibility ("hidden")));
>void mono_monitor_exit_trampoline (mgreg_t *regs, guint8 *code, MonoObject *obj, guint8 *tramp) __attribute__ ((visibility ("hidden")));
>gconstpointer mono_get_trampoline_func (MonoTrampolineType tramp_type);
>gpointer mini_get_vtable_trampoline (int slot_index) __attribute__ ((visibility ("hidden")));
>char* mono_get_generic_trampoline_name (MonoTrampolineType tramp_type) __attribute__ ((visibility ("hidden")));
>char* mono_get_rgctx_fetch_trampoline_name (int slot) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_running_on_valgrind (void) __attribute__ ((visibility ("hidden")));
>void* mono_global_codeman_reserve (int size) __attribute__ ((visibility ("hidden")));
>void* nacl_global_codeman_get_dest(void *data) __attribute__ ((visibility ("hidden")));
>void mono_global_codeman_commit(void *data, int size, int newsize) __attribute__ ((visibility ("hidden")));
>void nacl_global_codeman_validate(guint8 **buf_base, int buf_size, guint8 **code_end) __attribute__ ((visibility ("hidden")));
>const char *mono_regname_full (int reg, int bank) __attribute__ ((visibility ("hidden")));
>gint32* mono_allocate_stack_slots_full (MonoCompile *cfg, gboolean backward, guint32 *stack_size, guint32 *stack_align) __attribute__ ((visibility ("hidden")));
>gint32* mono_allocate_stack_slots (MonoCompile *cfg, guint32 *stack_size, guint32 *stack_align) __attribute__ ((visibility ("hidden")));
>void mono_local_regalloc (MonoCompile *cfg, MonoBasicBlock *bb) __attribute__ ((visibility ("hidden")));
>MonoInst *mono_branch_optimize_exception_target (MonoCompile *cfg, MonoBasicBlock *bb, const char * exname) __attribute__ ((visibility ("hidden")));
>void mono_remove_critical_edges (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>gboolean mono_is_regsize_var (MonoType *t) __attribute__ ((visibility ("hidden")));
>void mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align) __attribute__ ((visibility ("hidden")));
>CompRelation mono_opcode_to_cond (int opcode) __attribute__ ((visibility ("hidden")));
>CompType mono_opcode_to_type (int opcode, int cmp_opcode) __attribute__ ((visibility ("hidden")));
>CompRelation mono_negate_cond (CompRelation cond) __attribute__ ((visibility ("hidden")));
>int mono_op_imm_to_op (int opcode) __attribute__ ((visibility ("hidden")));
>void mono_decompose_op_imm (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst *ins) __attribute__ ((visibility ("hidden")));
>void mono_peephole_ins (MonoBasicBlock *bb, MonoInst *ins) __attribute__ ((visibility ("hidden")));
>MonoUnwindOp *mono_create_unwind_op (int when,
>           int tag, int reg,
>           int val) __attribute__ ((visibility ("hidden")));
>void mono_emit_unwind_op (MonoCompile *cfg, int when,
>            int tag, int reg,
>            int val) __attribute__ ((visibility ("hidden")));
>MonoTrampInfo* mono_tramp_info_create (const char *name, guint8 *code, guint32 code_size, MonoJumpInfo *ji, GSList *unwind_ops) __attribute__ ((visibility ("hidden")));
>void mono_tramp_info_free (MonoTrampInfo *info) __attribute__ ((visibility ("hidden")));
>
>int mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
>          MonoInst *return_var, GList *dont_inline, MonoInst **inline_args,
>          guint inline_offset, gboolean is_virtual_call) __attribute__ ((visibility ("hidden")));
>
>MonoInst *mono_decompose_opcode (MonoCompile *cfg, MonoInst *ins) __attribute__ ((visibility ("hidden")));
>void mono_decompose_long_opts (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_decompose_vtype_opts (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_decompose_array_access_opts (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_decompose_soft_float (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_handle_global_vregs (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_spill_global_vars (MonoCompile *cfg, gboolean *need_local_opts) __attribute__ ((visibility ("hidden")));
>void mono_if_conversion (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>
>
>void mono_arch_init (void) __attribute__ ((visibility ("hidden")));
>void mono_arch_cleanup (void) __attribute__ ((visibility ("hidden")));
>void mono_arch_cpu_init (void) __attribute__ ((visibility ("hidden")));
>guint32 mono_arch_cpu_optimizazions (guint32 *exclude_mask) __attribute__ ((visibility ("hidden")));
>void mono_arch_instrument_mem_needs (MonoMethod *method, int *stack, int *code) __attribute__ ((visibility ("hidden")));
>void *mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) __attribute__ ((visibility ("hidden")));
>void *mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) __attribute__ ((visibility ("hidden")));
>void *mono_arch_instrument_epilog_full (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments, gboolean preserve_argument_registers) __attribute__ ((visibility ("hidden")));
>void mono_codegen (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_call_inst_add_outarg_reg (MonoCompile *cfg, MonoCallInst *call, int vreg, int hreg, int bank) __attribute__ ((visibility ("hidden")));
>void mono_call_inst_add_outarg_vt (MonoCompile *cfg, MonoCallInst *call, MonoInst *outarg_vt) __attribute__ ((visibility ("hidden")));
>const char *mono_arch_regname (int reg) __attribute__ ((visibility ("hidden")));
>const char *mono_arch_fregname (int reg) __attribute__ ((visibility ("hidden")));
>void mono_arch_exceptions_init (void) __attribute__ ((visibility ("hidden")));
>guchar* mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_create_generic_class_init_trampoline (MonoTrampInfo **info, gboolean aot) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_nullified_class_init_trampoline (MonoTrampInfo **info) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_create_monitor_enter_trampoline (MonoTrampInfo **info, gboolean aot) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_create_monitor_exit_trampoline (MonoTrampInfo **info, gboolean aot) __attribute__ ((visibility ("hidden")));
>GList *mono_arch_get_allocatable_int_vars (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>GList *mono_arch_get_global_int_regs (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>GList *mono_arch_get_global_fp_regs (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>GList *mono_arch_get_iregs_clobbered_by_call (MonoCallInst *call) __attribute__ ((visibility ("hidden")));
>GList *mono_arch_get_fregs_clobbered_by_call (MonoCallInst *call) __attribute__ ((visibility ("hidden")));
>guint32 mono_arch_regalloc_cost (MonoCompile *cfg, MonoMethodVar *vmv) __attribute__ ((visibility ("hidden")));
>void mono_arch_patch_code (MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *ji, MonoCodeManager *dyn_code_mp, gboolean run_cctors) __attribute__ ((visibility ("hidden")));
>void mono_arch_flush_icache (guint8 *code, gint size) __attribute__ ((visibility ("hidden")));
>int mono_arch_max_epilog_size (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>guint8 *mono_arch_emit_prolog (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_arch_emit_epilog (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_arch_emit_exceptions (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_arch_lowering_pass (MonoCompile *cfg, MonoBasicBlock *bb) __attribute__ ((visibility ("hidden")));
>void mono_arch_peephole_pass_1 (MonoCompile *cfg, MonoBasicBlock *bb) __attribute__ ((visibility ("hidden")));
>void mono_arch_peephole_pass_2 (MonoCompile *cfg, MonoBasicBlock *bb) __attribute__ ((visibility ("hidden")));
>void mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) __attribute__ ((visibility ("hidden")));
>gboolean mono_arch_has_unwind_info (gconstpointer addr) __attribute__ ((visibility ("hidden")));
>void mono_arch_setup_jit_tls_data (MonoJitTlsData *tls) __attribute__ ((visibility ("hidden")));
>void mono_arch_free_jit_tls_data (MonoJitTlsData *tls) __attribute__ ((visibility ("hidden")));
>void mono_arch_fill_argument_info (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_arch_allocate_vars (MonoCompile *m) __attribute__ ((visibility ("hidden")));
>int mono_arch_get_argument_info (MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info) __attribute__ ((visibility ("hidden")));
>gboolean mono_arch_print_tree (MonoInst *tree, int arity) __attribute__ ((visibility ("hidden")));
>void mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call) __attribute__ ((visibility ("hidden")));
>void mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src) __attribute__ ((visibility ("hidden")));
>void mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val) __attribute__ ((visibility ("hidden")));
>MonoDynCallInfo *mono_arch_dyn_call_prepare (MonoMethodSignature *sig) __attribute__ ((visibility ("hidden")));
>void mono_arch_dyn_call_free (MonoDynCallInfo *info) __attribute__ ((visibility ("hidden")));
>void mono_arch_start_dyn_call (MonoDynCallInfo *info, gpointer **args, guint8 *ret, guint8 *buf, int buf_len) __attribute__ ((visibility ("hidden")));
>void mono_arch_finish_dyn_call (MonoDynCallInfo *info, guint8 *buf) __attribute__ ((visibility ("hidden")));
>MonoInst *mono_arch_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args) __attribute__ ((visibility ("hidden")));
>void mono_arch_decompose_opts (MonoCompile *cfg, MonoInst *ins) __attribute__ ((visibility ("hidden")));
>void mono_arch_decompose_long_opts (MonoCompile *cfg, MonoInst *ins) __attribute__ ((visibility ("hidden")));
>GSList* mono_arch_get_delegate_invoke_impls (void) __attribute__ ((visibility ("hidden")));
>LLVMCallInfo* mono_arch_get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig) __attribute__ ((visibility ("hidden")));
>guint8* mono_arch_emit_load_got_addr (guint8 *start, guint8 *code, MonoCompile *cfg, MonoJumpInfo **ji) __attribute__ ((visibility ("hidden")));
>guint8* mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, int tramp_type, gconstpointer target) __attribute__ ((visibility ("hidden")));
>GSList* mono_arch_get_cie_program (void) __attribute__ ((visibility ("hidden")));
>void mono_arch_set_target (char *mtriple) __attribute__ ((visibility ("hidden")));
># 2059 "mini.h"
>gboolean
>mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
>       MonoJitInfo *ji, MonoContext *ctx,
>       MonoContext *new_ctx, MonoLMF **lmf,
>       mgreg_t **save_locations,
>       StackFrameInfo *frame_info) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_throw_exception_by_name (void) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_throw_pending_exception (MonoTrampInfo **info, gboolean aot) __attribute__ ((visibility ("hidden")));
>gboolean mono_arch_handle_exception (void *sigctx, gpointer obj, gboolean test_only) __attribute__ ((visibility ("hidden")));
>void mono_arch_handle_altstack_exception (void *sigctx, gpointer fault_addr, gboolean stack_ovf) __attribute__ ((visibility ("hidden")));
>gboolean mono_handle_soft_stack_ovf (MonoJitTlsData *jit_tls, MonoJitInfo *ji, void *ctx, guint8* fault_addr) __attribute__ ((visibility ("hidden")));
>void mono_handle_hard_stack_ovf (MonoJitTlsData *jit_tls, MonoJitInfo *ji, void *ctx, guint8* fault_addr) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_ip_from_context (void *sigctx) __attribute__ ((visibility ("hidden")));
>void mono_arch_sigctx_to_monoctx (void *sigctx, MonoContext *ctx) __attribute__ ((visibility ("hidden")));
>void mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *ctx) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_context_get_int_reg (MonoContext *ctx, int reg) __attribute__ ((visibility ("hidden")));
>void mono_arch_flush_register_windows (void) __attribute__ ((visibility ("hidden")));
>gboolean mono_arch_is_inst_imm (gint64 imm) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_arch_get_domain_intrinsic (MonoCompile* cfg) __attribute__ ((visibility ("hidden")));
>gboolean mono_arch_is_int_overflow (void *sigctx, void *info) __attribute__ ((visibility ("hidden")));
>void mono_arch_invalidate_method (MonoJitInfo *ji, void *func, gpointer func_arg) __attribute__ ((visibility ("hidden")));
>guint32 mono_arch_get_patch_offset (guint8 *code) __attribute__ ((visibility ("hidden")));
>gpointer*mono_arch_get_delegate_method_ptr_addr (guint8* code, mgreg_t *regs) __attribute__ ((visibility ("hidden")));
>void mono_arch_create_vars (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_arch_save_unwind_info (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_arch_register_lowlevel_calls (void) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_static_rgctx_trampoline (MonoMethod *m, MonoMethodRuntimeGenericContext *mrgctx, gpointer addr) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_llvm_imt_trampoline (MonoDomain *domain, MonoMethod *method, int vt_offset) __attribute__ ((visibility ("hidden")));
>void mono_arch_patch_callsite (guint8 *method_start, guint8 *code, guint8 *addr) __attribute__ ((visibility ("hidden")));
>void mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr) __attribute__ ((visibility ("hidden")));
>void mono_arch_nullify_class_init_trampoline(guint8 *code, mgreg_t *regs) __attribute__ ((visibility ("hidden")));
>void mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs) __attribute__ ((visibility ("hidden")));
>int mono_arch_get_this_arg_reg (guint8 *code) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_this_arg_from_call (mgreg_t *regs, guint8 *code) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_get_delegate_invoke_impl (MonoMethodSignature *sig, gboolean has_target) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) __attribute__ ((visibility ("hidden")));
>void mono_arch_emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoInst *imt_arg) __attribute__ ((visibility ("hidden")));
>MonoMethod* mono_arch_find_imt_method (mgreg_t *regs, guint8 *code) __attribute__ ((visibility ("hidden")));
>MonoVTable* mono_arch_find_static_call_vtable (mgreg_t *regs, guint8 *code) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp) __attribute__ ((visibility ("hidden")));
>void mono_arch_notify_pending_exc (void) __attribute__ ((visibility ("hidden")));
>guint8* mono_arch_get_call_target (guint8 *code) __attribute__ ((visibility ("hidden")));
>guint32 mono_arch_get_plt_info_offset (guint8 *plt_entry, mgreg_t *regs, guint8 *code) __attribute__ ((visibility ("hidden")));
>GSList *mono_arch_get_trampolines (gboolean aot) __attribute__ ((visibility ("hidden")));
>
>
>gpointer mono_arch_install_handler_block_guard (MonoJitInfo *ji, MonoJitExceptionInfo *clause, MonoContext *ctx, gpointer new_value) __attribute__ ((visibility ("hidden")));
>gpointer mono_arch_create_handler_block_trampoline (void) __attribute__ ((visibility ("hidden")));
>gpointer mono_create_handler_block_trampoline (void) __attribute__ ((visibility ("hidden")));
>gboolean mono_install_handler_block_guard (MonoInternalThread *thread, MonoContext *ctx) __attribute__ ((visibility ("hidden")));
>
>
>
>typedef enum {
> MONO_UNWIND_NONE = 0x0,
> MONO_UNWIND_LOOKUP_IL_OFFSET = 0x1,
> MONO_UNWIND_LOOKUP_ACTUAL_METHOD = 0x2,
> MONO_UNWIND_DEFAULT = MONO_UNWIND_LOOKUP_ACTUAL_METHOD,
> MONO_UNWIND_SIGNAL_SAFE = MONO_UNWIND_NONE,
> MONO_UNWIND_LOOKUP_ALL = MONO_UNWIND_LOOKUP_IL_OFFSET | MONO_UNWIND_LOOKUP_ACTUAL_METHOD,
>} MonoUnwindOptions;
>
>typedef gboolean (*MonoJitStackWalk) (StackFrameInfo *frame, MonoContext *ctx, gpointer data);
>
>void mono_exceptions_init (void) __attribute__ ((visibility ("hidden")));
>gboolean mono_handle_exception (MonoContext *ctx, gpointer obj,
>       gpointer original_ip, gboolean test_only) __attribute__ ((visibility ("hidden")));
>void mono_handle_native_sigsegv (int signal, void *sigctx) __attribute__ ((visibility ("hidden")));
>void mono_print_thread_dump (void *sigctx);
>void mono_print_thread_dump_from_ctx (MonoContext *ctx);
>void mono_jit_walk_stack (MonoStackWalk func, gboolean do_il_offset, gpointer user_data) __attribute__ ((visibility ("hidden")));
>void mono_jit_walk_stack_from_ctx (MonoStackWalk func, MonoContext *ctx, MonoUnwindOptions unwind_options, gpointer user_data) __attribute__ ((visibility ("hidden")));
>void mono_walk_stack (MonoJitStackWalk func, MonoDomain *domain, MonoContext *start_ctx, MonoUnwindOptions unwind_options, MonoInternalThread *thread, MonoLMF *lmf, gpointer user_data) __attribute__ ((visibility ("hidden")));
>void mono_setup_altstack (MonoJitTlsData *tls) __attribute__ ((visibility ("hidden")));
>void mono_free_altstack (MonoJitTlsData *tls) __attribute__ ((visibility ("hidden")));
>gpointer mono_altstack_restore_prot (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp) __attribute__ ((visibility ("hidden")));
>MonoJitInfo* mini_jit_info_table_find (MonoDomain *domain, char *addr, MonoDomain **out_domain) __attribute__ ((visibility ("hidden")));
>void mono_resume_unwind (MonoContext *ctx) __attribute__ ((visibility ("hidden")));
>
>MonoJitInfo * mono_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx, MonoContext *new_ctx, char **trace, MonoLMF **lmf, int *native_offset, gboolean *managed) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_find_jit_info_ext (MonoDomain *domain, MonoJitTlsData *jit_tls,
>      MonoJitInfo *prev_ji, MonoContext *ctx,
>      MonoContext *new_ctx, char **trace, MonoLMF **lmf,
>      mgreg_t **save_locations,
>      StackFrameInfo *frame) __attribute__ ((visibility ("hidden")));
>
>gpointer mono_get_throw_exception (void) __attribute__ ((visibility ("hidden")));
>gpointer mono_get_rethrow_exception (void) __attribute__ ((visibility ("hidden")));
>gpointer mono_get_call_filter (void) __attribute__ ((visibility ("hidden")));
>gpointer mono_get_restore_context (void) __attribute__ ((visibility ("hidden")));
>gpointer mono_get_throw_exception_by_name (void) __attribute__ ((visibility ("hidden")));
>gpointer mono_get_throw_corlib_exception (void) __attribute__ ((visibility ("hidden")));
>
>MonoArray *ves_icall_get_trace (MonoException *exc, gint32 skip, MonoBoolean need_file_info) __attribute__ ((visibility ("hidden")));
>MonoBoolean ves_icall_get_frame_info (gint32 skip, MonoBoolean need_file_info,
>       MonoReflectionMethod **method,
>       gint32 *iloffset, gint32 *native_offset,
>       MonoString **file, gint32 *line, gint32 *column) __attribute__ ((visibility ("hidden")));
>MonoString *ves_icall_System_Exception_get_trace (MonoException *exc) __attribute__ ((visibility ("hidden")));
>void mono_set_cast_details (MonoClass *from, MonoClass *to) __attribute__ ((visibility ("hidden")));
>
>
>void mono_compile_dominator_info (MonoCompile *cfg, int dom_flags) __attribute__ ((visibility ("hidden")));
>void mono_compute_natural_loops (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>MonoBitSet* mono_compile_iterated_dfrontier (MonoCompile *cfg, MonoBitSet *set) __attribute__ ((visibility ("hidden")));
>void mono_ssa_compute (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_ssa_remove (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_ssa_cprop (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_ssa_deadce (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_ssa_strength_reduction (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_free_loop_info (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>
>void mono_ssa_compute2 (MonoCompile *cfg);
>void mono_ssa_remove2 (MonoCompile *cfg);
>void mono_ssa_cprop2 (MonoCompile *cfg);
>void mono_ssa_deadce2 (MonoCompile *cfg);
>
>
>void mono_debug_init_method (MonoCompile *cfg, MonoBasicBlock *start_block,
>       guint32 breakpoint_id) __attribute__ ((visibility ("hidden")));
>void mono_debug_open_method (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_debug_close_method (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_debug_free_method (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>void mono_debug_open_block (MonoCompile *cfg, MonoBasicBlock *bb, guint32 address) __attribute__ ((visibility ("hidden")));
>void mono_debug_record_line_number (MonoCompile *cfg, MonoInst *ins, guint32 address) __attribute__ ((visibility ("hidden")));
>void mono_debug_serialize_debug_info (MonoCompile *cfg, guint8 **out_buf, guint32 *buf_len) __attribute__ ((visibility ("hidden")));
>void mono_debug_add_aot_method (MonoDomain *domain,
>       MonoMethod *method, guint8 *code_start,
>       guint8 *debug_info, guint32 debug_info_len) __attribute__ ((visibility ("hidden")));
>void mono_debug_add_icall_wrapper (MonoMethod *method, MonoJitICallInfo* info) __attribute__ ((visibility ("hidden")));
>void mono_debug_print_vars (gpointer ip, gboolean only_arguments);
>void mono_debugger_run_finally (MonoContext *start_ctx);
>
>extern gssize mono_breakpoint_info_index [64];
>
>gboolean mono_breakpoint_clean_code (guint8 *method_start, guint8 *code, int offset, guint8 *buf, int size);
># 2215 "mini.h"
>MonoTraceSpec *mono_trace_parse_options (const char *options) __attribute__ ((visibility ("hidden")));
>void mono_trace_set_assembly (MonoAssembly *assembly) __attribute__ ((visibility ("hidden")));
>gboolean mono_trace_eval (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>extern void
>mono_perform_abc_removal (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>extern void
>mono_perform_abc_removal (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>extern void
>mono_perform_ssapre (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>extern void
>mono_local_cprop (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>extern void
>mono_local_cprop (MonoCompile *cfg);
>extern void
>mono_local_deadce (MonoCompile *cfg);
>
>
>MonoSecurityFrame* ves_icall_System_Security_SecurityFrame_GetSecurityFrame (gint32 skip) __attribute__ ((visibility ("hidden")));
>MonoArray* ves_icall_System_Security_SecurityFrame_GetSecurityStack (gint32 skip) __attribute__ ((visibility ("hidden")));
>
>
>
>
>void
>mono_set_generic_sharing_supported (gboolean supported) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_class_generic_sharing_enabled (MonoClass *class) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_class_fill_runtime_generic_context (MonoVTable *class_vtable, guint32 slot) __attribute__ ((visibility ("hidden")));
>
>gpointer
>mono_method_fill_runtime_generic_context (MonoMethodRuntimeGenericContext *mrgctx, guint32 slot) __attribute__ ((visibility ("hidden")));
>
>MonoMethodRuntimeGenericContext*
>mono_method_lookup_rgctx (MonoVTable *class_vtable, MonoGenericInst *method_inst) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_method_needs_static_rgctx_invoke (MonoMethod *method, gboolean allow_type_vars) __attribute__ ((visibility ("hidden")));
>
>int
>mono_class_rgctx_get_array_size (int n, gboolean mrgctx) __attribute__ ((visibility ("hidden")));
>
>guint32
>mono_method_lookup_or_register_other_info (MonoMethod *method, gboolean in_mrgctx, gpointer data,
> int info_type, MonoGenericContext *generic_context) __attribute__ ((visibility ("hidden")));
>
>MonoGenericContext
>mono_method_construct_object_context (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>int
>mono_generic_context_check_used (MonoGenericContext *context) __attribute__ ((visibility ("hidden")));
>
>int
>mono_class_check_context_used (MonoClass *class) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_generic_context_is_sharable (MonoGenericContext *context, gboolean allow_type_vars) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_generic_context_is_sharable_full (MonoGenericContext *context, gboolean allow_type_vars, gboolean allow_partial) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_method_is_generic_impl (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_method_is_generic_sharable_impl (MonoMethod *method, gboolean allow_type_vars) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_method_is_generic_sharable_impl_full (MonoMethod *method, gboolean allow_type_vars, gboolean allow_partial) __attribute__ ((visibility ("hidden")));
>
>gboolean
>mono_is_partially_sharable_inst (MonoGenericInst *inst) __attribute__ ((visibility ("hidden")));
>
>MonoGenericSharingContext* mono_get_generic_context_from_code (guint8 *code) __attribute__ ((visibility ("hidden")));
>
>MonoGenericContext* mini_method_get_context (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>int mono_method_check_context_used (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_generic_context_equal_deep (MonoGenericContext *context1, MonoGenericContext *context2) __attribute__ ((visibility ("hidden")));
>
>gpointer mono_helper_get_rgctx_other_ptr (MonoClass *caller_class, MonoVTable *vtable,
>       guint32 token, guint32 token_source, guint32 rgctx_type,
>       gint32 rgctx_index) __attribute__ ((visibility ("hidden")));
>
>void mono_generic_sharing_init (void) __attribute__ ((visibility ("hidden")));
>void mono_generic_sharing_cleanup (void) __attribute__ ((visibility ("hidden")));
>
>MonoClass* mini_class_get_container_class (MonoClass *class) __attribute__ ((visibility ("hidden")));
>MonoGenericContext* mini_class_get_context (MonoClass *class) __attribute__ ((visibility ("hidden")));
>
>MonoType* mini_get_basic_type_from_generic (MonoGenericSharingContext *gsctx, MonoType *type) __attribute__ ((visibility ("hidden")));
>MonoType* mini_type_get_underlying_type (MonoGenericSharingContext *gsctx, MonoType *type) __attribute__ ((visibility ("hidden")));
>MonoMethod* mini_get_shared_method (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>MonoMethod* mini_get_shared_method_to_register (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>int mini_type_stack_size (MonoGenericSharingContext *gsctx, MonoType *t, int *align) __attribute__ ((visibility ("hidden")));
>int mini_type_stack_size_full (MonoGenericSharingContext *gsctx, MonoType *t, guint32 *align, gboolean pinvoke) __attribute__ ((visibility ("hidden")));
>void type_to_eval_stack_type (MonoCompile *cfg, MonoType *type, MonoInst *inst) __attribute__ ((visibility ("hidden")));
>guint mono_type_to_regmove (MonoCompile *cfg, MonoType *type) __attribute__ ((visibility ("hidden")));
>
>void mono_cfg_add_try_hole (MonoCompile *cfg, MonoExceptionClause *clause, guint8 *start, MonoBasicBlock *bb) __attribute__ ((visibility ("hidden")));
>
>void mono_cfg_set_exception (MonoCompile *cfg, int type) __attribute__ ((visibility ("hidden")));
>
>
>int mini_wapi_hps (int argc, char **argv) __attribute__ ((visibility ("hidden")));
>
>int mini_wapi_semdel (int argc, char **argv) __attribute__ ((visibility ("hidden")));
>
>int mini_wapi_seminfo (int argc, char **argv) __attribute__ ((visibility ("hidden")));
>
>
>
>
>
>
>enum {
> SIMD_VERSION_SSE1 = 1 << 0,
> SIMD_VERSION_SSE2 = 1 << 1,
> SIMD_VERSION_SSE3 = 1 << 2,
> SIMD_VERSION_SSSE3 = 1 << 3,
> SIMD_VERSION_SSE41 = 1 << 4,
> SIMD_VERSION_SSE42 = 1 << 5,
> SIMD_VERSION_SSE4a = 1 << 6,
> SIMD_VERSION_ALL = SIMD_VERSION_SSE1 | SIMD_VERSION_SSE2 |
>     SIMD_VERSION_SSE3 | SIMD_VERSION_SSSE3 |
>     SIMD_VERSION_SSE41 | SIMD_VERSION_SSE42 |
>     SIMD_VERSION_SSE4a,
>
>
>
>
> SIMD_VERSION_INDEX_END = 6
>};
>
>
>
>enum {
> SIMD_COMP_EQ,
> SIMD_COMP_LT,
> SIMD_COMP_LE,
> SIMD_COMP_UNORD,
> SIMD_COMP_NEQ,
> SIMD_COMP_NLT,
> SIMD_COMP_NLE,
> SIMD_COMP_ORD
>};
>
>enum {
> SIMD_PREFETCH_MODE_NTA,
> SIMD_PREFETCH_MODE_0,
> SIMD_PREFETCH_MODE_1,
> SIMD_PREFETCH_MODE_2,
>};
>
>const char *mono_arch_xregname (int reg) __attribute__ ((visibility ("hidden")));
>void mono_simd_simplify_indirection (MonoCompile *cfg) __attribute__ ((visibility ("hidden")));
>MonoInst* mono_emit_simd_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args) __attribute__ ((visibility ("hidden")));
>guint32 mono_arch_cpu_enumerate_simd_versions (void) __attribute__ ((visibility ("hidden")));
>void mono_simd_intrinsics_init (void) __attribute__ ((visibility ("hidden")));
>
>
>
>
>void mono_enable_jit_map (void) __attribute__ ((visibility ("hidden")));
>void mono_emit_jit_map (MonoJitInfo *jinfo) __attribute__ ((visibility ("hidden")));
>void mono_emit_jit_tramp (void *start, int size, const char *desc) __attribute__ ((visibility ("hidden")));
>gboolean mono_jit_map_is_enabled (void) __attribute__ ((visibility ("hidden")));
># 2397 "mini.h"
>void mono_runtime_install_handlers (void) __attribute__ ((visibility ("hidden")));
>void mono_runtime_cleanup_handlers (void) __attribute__ ((visibility ("hidden")));
>void mono_runtime_setup_stat_profiler (void) __attribute__ ((visibility ("hidden")));
>void mono_runtime_shutdown_stat_profiler (void) __attribute__ ((visibility ("hidden")));
>void mono_runtime_posix_install_handlers (void) __attribute__ ((visibility ("hidden")));
>pid_t mono_runtime_syscall_fork (void) __attribute__ ((visibility ("hidden")));
>gboolean mono_gdb_render_native_backtraces (pid_t crashed_pid) __attribute__ ((visibility ("hidden")));
># 2445 "mini.h"
>void mono_sigfpe_signal_handler (int _dummy, siginfo_t *info, void *context) __attribute__ ((visibility ("hidden")));
>void mono_sigill_signal_handler (int _dummy, siginfo_t *info, void *context) __attribute__ ((visibility ("hidden")));
>void mono_sigsegv_signal_handler (int _dummy, siginfo_t *info, void *context) __attribute__ ((visibility ("hidden")));
>void mono_sigint_signal_handler (int _dummy, siginfo_t *info, void *context) __attribute__ ((visibility ("hidden")));
>gboolean mono_chain_signal (int _dummy, siginfo_t *info, void *context) __attribute__ ((visibility ("hidden")));
>
>
>enum {
> MONO_AOT_WRAPPER_MONO_ENTER,
> MONO_AOT_WRAPPER_MONO_EXIT,
> MONO_AOT_WRAPPER_ELEMENT_ADDR,
> MONO_AOT_WRAPPER_PTR_TO_STRUCTURE,
> MONO_AOT_WRAPPER_STRUCTURE_TO_PTR,
> MONO_AOT_WRAPPER_CASTCLASS_WITH_CACHE,
> MONO_AOT_WRAPPER_ISINST_WITH_CACHE,
> MONO_AOT_WRAPPER_LAST
>};
># 59 "method-to-ir.c" 2
># 1 "trace.h" 1
>
>
>
>
>
>typedef enum {
> MONO_TRACEOP_ALL,
> MONO_TRACEOP_PROGRAM,
> MONO_TRACEOP_METHOD,
> MONO_TRACEOP_ASSEMBLY,
> MONO_TRACEOP_CLASS,
> MONO_TRACEOP_NAMESPACE,
> MONO_TRACEOP_EXCEPTION,
>} MonoTraceOpcode;
>
>typedef struct {
> MonoTraceOpcode op;
> int exclude;
> void *data, *data2;
>} MonoTraceOperation;
>
>struct MonoTraceSpec {
> int len;
> gboolean enabled;
> MonoTraceOperation *ops;
>
> MonoAssembly *assembly;
>};
>
>
>
>void
>mono_trace_enter_method (MonoMethod *method, char *ebp) __attribute__ ((visibility ("hidden")));
>
>void
>mono_trace_leave_method (MonoMethod *method, ...) __attribute__ ((visibility ("hidden")));
>
>void mono_trace_enable (gboolean enable) __attribute__ ((visibility ("hidden")));
>gboolean mono_trace_is_enabled (void) __attribute__ ((visibility ("hidden")));
>gboolean mono_trace_eval_exception (MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>
># 60 "method-to-ir.c" 2
>
># 1 "ir-emit.h" 1
># 15 "ir-emit.h"
>
>
>static inline guint32
>alloc_ireg (MonoCompile *cfg)
>{
> return cfg->next_vreg ++;
>}
>
>static inline guint32
>alloc_preg (MonoCompile *cfg)
>{
> return alloc_ireg (cfg);
>}
>
>static inline guint32
>alloc_lreg (MonoCompile *cfg)
>{
>
> return cfg->next_vreg ++;
># 42 "ir-emit.h"
>}
>
>static inline guint32
>alloc_freg (MonoCompile *cfg)
>{
>
>
>
>
>
> return cfg->next_vreg ++;
>
>}
>
>static inline guint32
>alloc_ireg_ref (MonoCompile *cfg)
>{
> int vreg = alloc_ireg (cfg);
>
>
>
>
>
>
> return vreg;
>}
>
>static inline guint32
>alloc_ireg_mp (MonoCompile *cfg)
>{
> int vreg = alloc_ireg (cfg);
>
>
>
>
>
>
> return vreg;
>}
>
>static inline guint32
>alloc_dreg (MonoCompile *cfg, MonoStackType stack_type)
>{
> switch (stack_type) {
> case STACK_I4:
> case STACK_PTR:
>  return alloc_ireg (cfg);
> case STACK_MP:
>  return alloc_ireg_mp (cfg);
> case STACK_OBJ:
>  return alloc_ireg_ref (cfg);
> case STACK_R8:
>  return alloc_freg (cfg);
> case STACK_I8:
>  return alloc_lreg (cfg);
> case STACK_VTYPE:
>  return alloc_ireg (cfg);
> default:
>  monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_WARNING, "Unknown stack type %x\n", stack_type);
>  do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ir-emit.h", 101); } while (0);
>  return -1;
> }
>}
># 895 "ir-emit.h"
>
># 62 "method-to-ir.c" 2
>
># 1 "jit-icalls.h" 1
>
>
>
>
>
>
>
>void* mono_ldftn (MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>void* mono_ldvirtfn (MonoObject *obj, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>void* mono_ldvirtfn_gshared (MonoObject *obj, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>void mono_helper_stelem_ref_check (MonoArray *array, MonoObject *val) __attribute__ ((visibility ("hidden")));
>
>gint64 mono_llmult (gint64 a, gint64 b) __attribute__ ((visibility ("hidden")));
>
>guint64 mono_llmult_ovf_un (guint64 a, guint64 b) __attribute__ ((visibility ("hidden")));
>
>guint64 mono_llmult_ovf (gint64 a, gint64 b) __attribute__ ((visibility ("hidden")));
>
>gint32 mono_idiv (gint32 a, gint32 b) __attribute__ ((visibility ("hidden")));
>
>guint32 mono_idiv_un (guint32 a, guint32 b) __attribute__ ((visibility ("hidden")));
>
>gint32 mono_irem (gint32 a, gint32 b) __attribute__ ((visibility ("hidden")));
>
>guint32 mono_irem_un (guint32 a, guint32 b) __attribute__ ((visibility ("hidden")));
>
>gint32 mono_imul (gint32 a, gint32 b) __attribute__ ((visibility ("hidden")));
>
>gint32 mono_imul_ovf (gint32 a, gint32 b) __attribute__ ((visibility ("hidden")));
>
>gint32 mono_imul_ovf_un (guint32 a, guint32 b) __attribute__ ((visibility ("hidden")));
>
>double mono_fdiv (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gint64 mono_lldiv (gint64 a, gint64 b) __attribute__ ((visibility ("hidden")));
>
>gint64 mono_llrem (gint64 a, gint64 b) __attribute__ ((visibility ("hidden")));
>
>guint64 mono_lldiv_un (guint64 a, guint64 b) __attribute__ ((visibility ("hidden")));
>
>guint64 mono_llrem_un (guint64 a, guint64 b) __attribute__ ((visibility ("hidden")));
>
>guint64 mono_lshl (guint64 a, gint32 shamt) __attribute__ ((visibility ("hidden")));
>
>guint64 mono_lshr_un (guint64 a, gint32 shamt) __attribute__ ((visibility ("hidden")));
>
>gint64 mono_lshr (gint64 a, gint32 shamt) __attribute__ ((visibility ("hidden")));
>
>MonoArray *mono_array_new_va (MonoMethod *cm, ...) __attribute__ ((visibility ("hidden")));
>
>MonoArray *mono_array_new_1 (MonoMethod *cm, guint32 length) __attribute__ ((visibility ("hidden")));
>
>MonoArray *mono_array_new_2 (MonoMethod *cm, guint32 length1, guint32 length2) __attribute__ ((visibility ("hidden")));
>
>MonoArray *mono_array_new_3 (MonoMethod *cm, guint32 length1, guint32 length2, guint32 length3) __attribute__ ((visibility ("hidden")));
>
>gpointer mono_class_static_field_address (MonoDomain *domain, MonoClassField *field) __attribute__ ((visibility ("hidden")));
>
>gpointer mono_ldtoken_wrapper (MonoImage *image, int token, MonoGenericContext *context) __attribute__ ((visibility ("hidden")));
>
>gpointer mono_ldtoken_wrapper_generic_shared (MonoImage *image, int token, MonoMethod *method) __attribute__ ((visibility ("hidden")));
>
>guint64 mono_fconv_u8 (double v) __attribute__ ((visibility ("hidden")));
>
>gint64 mono_fconv_i8 (double v) __attribute__ ((visibility ("hidden")));
>
>guint32 mono_fconv_u4 (double v) __attribute__ ((visibility ("hidden")));
>
>gint64 mono_fconv_ovf_i8 (double v) __attribute__ ((visibility ("hidden")));
>
>guint64 mono_fconv_ovf_u8 (double v) __attribute__ ((visibility ("hidden")));
>
>double mono_lconv_to_r8 (gint64 a) __attribute__ ((visibility ("hidden")));
>
>double mono_conv_to_r8 (gint32 a) __attribute__ ((visibility ("hidden")));
>
>double mono_conv_to_r4 (gint32 a) __attribute__ ((visibility ("hidden")));
>
>float mono_lconv_to_r4 (gint64 a) __attribute__ ((visibility ("hidden")));
>
>double mono_conv_to_r8_un (guint32 a) __attribute__ ((visibility ("hidden")));
>
>double mono_lconv_to_r8_un (guint64 a) __attribute__ ((visibility ("hidden")));
>
>
>
>
>
>gpointer mono_helper_compile_generic_method (MonoObject *obj, MonoMethod *method, gpointer *this_arg) __attribute__ ((visibility ("hidden")));
>
>MonoString *mono_helper_ldstr (MonoImage *image, guint32 idx) __attribute__ ((visibility ("hidden")));
>
>MonoString *mono_helper_ldstr_mscorlib (guint32 idx) __attribute__ ((visibility ("hidden")));
>
>MonoObject *mono_helper_newobj_mscorlib (guint32 idx) __attribute__ ((visibility ("hidden")));
>
>double mono_fsub (double a, double b) __attribute__ ((visibility ("hidden")));
>
>double mono_fadd (double a, double b) __attribute__ ((visibility ("hidden")));
>
>double mono_fmul (double a, double b) __attribute__ ((visibility ("hidden")));
>
>double mono_fneg (double a) __attribute__ ((visibility ("hidden")));
>
>double mono_fconv_r4 (double a) __attribute__ ((visibility ("hidden")));
>
>gint8 mono_fconv_i1 (double a) __attribute__ ((visibility ("hidden")));
>
>gint16 mono_fconv_i2 (double a) __attribute__ ((visibility ("hidden")));
>
>gint32 mono_fconv_i4 (double a) __attribute__ ((visibility ("hidden")));
>
>guint8 mono_fconv_u1 (double a) __attribute__ ((visibility ("hidden")));
>
>guint16 mono_fconv_u2 (double a) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fcmp_eq (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fcmp_ge (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fcmp_gt (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fcmp_le (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fcmp_lt (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fcmp_ne_un (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fcmp_ge_un (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fcmp_gt_un (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fcmp_le_un (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fcmp_lt_un (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fceq (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fcgt (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fcgt_un (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fclt (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_fclt_un (double a, double b) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_isfinite (double a) __attribute__ ((visibility ("hidden")));
>
>double mono_fload_r4 (float *ptr) __attribute__ ((visibility ("hidden")));
>
>void mono_fstore_r4 (double val, float *ptr) __attribute__ ((visibility ("hidden")));
>
>guint32 mono_fload_r4_arg (double val) __attribute__ ((visibility ("hidden")));
>
>void mono_break (void) __attribute__ ((visibility ("hidden")));
>
>MonoException *mono_create_corlib_exception_0 (guint32 token) __attribute__ ((visibility ("hidden")));
>
>MonoException *mono_create_corlib_exception_1 (guint32 token, MonoString *arg) __attribute__ ((visibility ("hidden")));
>
>MonoException *mono_create_corlib_exception_2 (guint32 token, MonoString *arg1, MonoString *arg2) __attribute__ ((visibility ("hidden")));
>
>MonoObject* mono_object_castclass (MonoObject *obj, MonoClass *klass) __attribute__ ((visibility ("hidden")));
>
>gpointer mono_get_native_calli_wrapper (MonoImage *image, MonoMethodSignature *sig, gpointer func) __attribute__ ((visibility ("hidden")));
>
>MonoObject*
>mono_object_isinst_with_cache (MonoObject *obj, MonoClass *klass, gpointer *cache);
>
>MonoObject*
>mono_object_castclass_with_cache (MonoObject *obj, MonoClass *klass, gpointer *cache);
># 64 "method-to-ir.c" 2
># 1 "jit.h" 1
># 13 "jit.h"
>
>
>MonoDomain *
>mono_jit_init (const char *file);
>
>MonoDomain *
>mono_jit_init_version (const char *root_domain_name, const char *runtime_version);
>
>int
>mono_jit_exec (MonoDomain *domain, MonoAssembly *assembly,
>       int argc, char *argv[]);
>void
>mono_jit_cleanup (MonoDomain *domain);
>
>mono_bool
>mono_jit_set_trace_options (const char* options);
>
>void
>mono_set_signal_chaining (mono_bool chain_signals);
>
>void
>mono_jit_set_aot_only (mono_bool aot_only);
>
>
>
>
>
>typedef enum {
>
> MONO_BREAK_POLICY_ALWAYS,
>
> MONO_BREAK_POLICY_NEVER,
>
>
>
>
> MONO_BREAK_POLICY_ON_DBG
>} MonoBreakPolicy;
>
>typedef MonoBreakPolicy (*MonoBreakPolicyFunc) (MonoMethod *method);
>void mono_set_break_policy (MonoBreakPolicyFunc policy_callback);
>
>void
>mono_jit_parse_options (int argc, char * argv[]);
>
>
># 65 "method-to-ir.c" 2
># 1 "debugger-agent.h" 1
># 10 "debugger-agent.h"
>void
>mono_debugger_agent_parse_options (char *options) __attribute__ ((visibility ("hidden")));
>
>void
>mono_debugger_agent_init (void) __attribute__ ((visibility ("hidden")));
>
>void
>mono_debugger_agent_breakpoint_hit (void *sigctx) __attribute__ ((visibility ("hidden")));
>
>void
>mono_debugger_agent_single_step_event (void *sigctx) __attribute__ ((visibility ("hidden")));
>
>void
>debugger_agent_single_step_from_context (MonoContext *ctx) __attribute__ ((visibility ("hidden")));
>
>void
>debugger_agent_breakpoint_from_context (MonoContext *ctx) __attribute__ ((visibility ("hidden")));
>
>void
>mono_debugger_agent_free_domain_info (MonoDomain *domain) __attribute__ ((visibility ("hidden")));
>
>gboolean mono_debugger_agent_thread_interrupt (void *sigctx, MonoJitInfo *ji) __attribute__ ((visibility ("hidden")));
>
>void
>mono_debugger_agent_handle_exception (MonoException *ext, MonoContext *throw_ctx, MonoContext *catch_ctx) __attribute__ ((visibility ("hidden")));
>
>void
>mono_debugger_agent_begin_exception_filter (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx) __attribute__ ((visibility ("hidden")));
>
>void
>mono_debugger_agent_end_exception_filter (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx) __attribute__ ((visibility ("hidden")));
># 66 "method-to-ir.c" 2
># 110 "method-to-ir.c"
>static int ldind_to_load_membase (int opcode);
>static int stind_to_store_membase (int opcode);
>
>int mono_op_to_op_imm (int opcode);
>int mono_op_to_op_imm_noemul (int opcode);
>
>MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
>void mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native);
>void mini_emit_initobj (MonoCompile *cfg, MonoInst *dest, const guchar *ip, MonoClass *klass);
>
>
>static MonoMethodSignature *helper_sig_class_init_trampoline = ((void *)0);
>static MonoMethodSignature *helper_sig_domain_get = ((void *)0);
>static MonoMethodSignature *helper_sig_generic_class_init_trampoline = ((void *)0);
>static MonoMethodSignature *helper_sig_generic_class_init_trampoline_llvm = ((void *)0);
>static MonoMethodSignature *helper_sig_rgctx_lazy_fetch_trampoline = ((void *)0);
>static MonoMethodSignature *helper_sig_monitor_enter_exit_trampoline = ((void *)0);
>static MonoMethodSignature *helper_sig_monitor_enter_exit_trampoline_llvm = ((void *)0);
># 151 "method-to-ir.c"
>const char
>ins_info[] = {
># 1 "mini-ops.h" 1
>
>' ', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'f', ' ', ' ', ' ',
>'v', ' ', ' ', ' ',
>' ', 'i', 'i', ' ',
>' ', 'i', ' ', ' ',
>' ', 'f', 'f', ' ',
>' ', 'i', 'i', ' ',
>' ', 'i', 'i', ' ',
>' ', 'i', ' ', ' ',
>' ', 'i', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>
>
>
>' ', 'v', ' ', ' ',
>'i', ' ', ' ', ' ',
>' ', 'i', ' ', ' ',
>'f', 'f', ' ', ' ',
>' ', 'i', 'i', ' ',
>'i', 'i', ' ', ' ',
>'i', ' ', ' ', ' ',
>' ', 'i', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', 'i', ' ', ' ',
>' ', 'i', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', ' ', ' ', ' ',
>'f', ' ', ' ', ' ',
>'f', ' ', ' ', ' ',
>'f', 'i', ' ', ' ',
>'f', 'i', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'v', ' ', ' ', ' ',
>'v', ' ', ' ', ' ',
>'v', 'i', ' ', ' ',
>'v', 'i', ' ', ' ',
>
>' ', ' ', ' ', ' ',
>' ', 'i', ' ', ' ',
>' ', 'i', ' ', ' ',
>' ', 'i', 'i', ' ',
>
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'f', ' ', ' ', ' ',
>'f', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', 'i', ' ', ' ',
>' ', 'i', ' ', ' ',
>' ', 'i', ' ', ' ',
># 88 "mini-ops.h"
>' ', 'i', ' ', ' ',
>
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>
>
>
>
>
>
>
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', 'x', ' ', ' ',
>'i', 'v', ' ', ' ',
>
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'f', 'i', ' ', ' ',
>'f', 'i', ' ', ' ',
>
>'x', 'i', ' ', ' ',
>
>
>
>
>
>'v', 'i', ' ', ' ',
>
>
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'f', 'i', 'i', ' ',
>'f', 'i', 'i', ' ',
>
>
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'f', 'i', ' ',
>'i', 'f', 'i', ' ',
>
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'f', 'f', ' ', ' ',
>'v', 'v', ' ', ' ',
>
>'v', ' ', ' ', ' ',
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'f', 'i', ' ', ' ',
>'f', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>
>'f', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>
>'f', 'i', 'i', ' ',
>'f', 'i', 'i', ' ',
>'f', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>
>
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'f', 'i', ' ', ' ',
>'f', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>'f', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>'i', 'i', 'i', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>'i', ' ', ' ', ' ',
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>
>'f', 'f', 'f', ' ',
>'f', 'f', 'f', ' ',
>'f', 'f', 'f', ' ',
>'f', 'f', 'f', ' ',
>'f', 'f', 'f', ' ',
>'f', 'f', 'f', ' ',
>'f', 'f', 'f', ' ',
>
>
>'f', 'f', ' ', ' ',
>'f', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'f', 'f', ' ', ' ',
>'f', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>
>'f', 'f', 'f', ' ',
>'f', 'f', 'f', ' ',
>'f', 'f', 'f', ' ',
>'f', 'f', 'f', ' ',
>'f', 'f', 'f', ' ',
>'f', 'f', 'f', ' ',
>
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>'i', 'f', ' ', ' ',
>
>
>'i', 'f', 'f', ' ',
>'i', 'f', 'f', ' ',
>'i', 'f', 'f', ' ',
>'i', 'f', 'f', ' ',
>'i', 'f', 'f', ' ',
>
>'i', 'f', 'i', ' ',
>'i', 'f', 'i', ' ',
>'i', 'f', 'i', ' ',
>'i', 'f', 'i', ' ',
>'i', 'f', 'i', ' ',
>
>'i', 'f', ' ', ' ',
>'f', 'f', ' ', ' ',
>
>
>'i', 'f', ' ', ' ',
>
>'i', 'f', ' ', ' ',
>
>'i', ' ', ' ', ' ',
>
>
>'i', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', 'i', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>
>
>'i', 'i', 'i', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', ' ', ' ',
>' ', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>' ', ' ', ' ', ' ',
>'i', 'i', ' ', ' ',
>
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>
>
>'f', 'f', ' ', ' ',
>'f', 'f', ' ', ' ',
>'f', 'f', ' ', ' ',
>'f', 'f', ' ', ' ',
>'f', 'f', ' ', ' ',
>'f', 'f', ' ', ' ',
>'f', 'f', ' ', ' ',
>
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>' ', 'i', 'i', ' ',
>
>' ', ' ', ' ', ' ',
>
>' ', ' ', ' ', ' ',
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>
>' ', 'i', 'i', ' ',
>
>
>'i', ' ', ' ', ' ',
>
>'i', ' ', ' ', ' ',
>' ', 'i', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', 'i', ' ', ' ',
># 821 "mini-ops.h"
>'x', 'x', ' ', ' ',
>'x', ' ', ' ', ' ',
>'x', ' ', ' ', ' ',
># 836 "mini-ops.h"
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', 'i', ' ',
>
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', ' ', ' ',
>'i', 'i', 'i', ' ',
>' ', ' ', ' ', ' ',
>
>'i', 'i', 'i', 'i',
>'i', 'i', 'i', 'i',
># 861 "mini-ops.h"
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>
>
>
>
>
>
>' ', ' ', ' ', ' ',
>
>
>
>
>' ', ' ', ' ', ' ',
>
>
>
>
>
>
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>
>
>
>
>
>' ', ' ', ' ', ' ',
>
>
>
>
>
>' ', ' ', ' ', ' ',
># 1032 "mini-ops.h"
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>' ', ' ', ' ', ' ',
>'i', 'i', ' ', ' ',
>'f', 'f', ' ', ' ',
>' ', ' ', ' ', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
>'i', 'i', 'i', ' ',
># 154 "method-to-ir.c" 2
>};
># 164 "method-to-ir.c"
>const gint8 ins_sreg_counts[] = {
># 1 "mini-ops.h" 1
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>
>
>
>((' ') != ' ' ? 2 : (('v') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
># 88 "mini-ops.h"
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>
>
>
>
>
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('x') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('v') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>
>
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('v') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('f') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>(('i') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
># 821 "mini-ops.h"
>((' ') != ' ' ? 2 : (('x') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
># 836 "mini-ops.h"
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>(('i') != ' ' ? 3 : (('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0))),
>(('i') != ' ' ? 3 : (('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0))),
># 861 "mini-ops.h"
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>
>
>
>
>
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>
>
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>
>
>
>
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>
>
>
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>
>
>
>
>
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
># 1032 "mini-ops.h"
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : (('f') != ' ' ? 1 : 0)),
>((' ') != ' ' ? 2 : ((' ') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
>(('i') != ' ' ? 2 : (('i') != ' ' ? 1 : 0)),
># 166 "method-to-ir.c" 2
>};
># 176 "method-to-ir.c"
>void
>mono_inst_set_src_registers (MonoInst *ins, int *regs)
>{
> ins->sreg1 = regs [0];
> ins->sreg2 = regs [1];
> ins->sreg3 = regs [2];
>}
>
>guint32
>mono_alloc_ireg (MonoCompile *cfg)
>{
> return alloc_ireg (cfg);
>}
>
>guint32
>mono_alloc_freg (MonoCompile *cfg)
>{
> return alloc_freg (cfg);
>}
>
>guint32
>mono_alloc_preg (MonoCompile *cfg)
>{
> return alloc_preg (cfg);
>}
>
>guint32
>mono_alloc_dreg (MonoCompile *cfg, MonoStackType stack_type)
>{
> return alloc_dreg (cfg, stack_type);
>}
>
>
>
>
>
>
>guint32
>mono_alloc_ireg_ref (MonoCompile *cfg)
>{
> return alloc_ireg_ref (cfg);
>}
>
>
>
>
>
>
>guint32
>mono_alloc_ireg_mp (MonoCompile *cfg)
>{
> return alloc_ireg_mp (cfg);
>}
>
>
>
>
>
>
>guint32
>mono_alloc_ireg_copy (MonoCompile *cfg, guint32 vreg)
>{
> if (0)
>  return alloc_ireg_ref (cfg);
> else if (0)
>  return alloc_ireg_mp (cfg);
> else
>  return alloc_ireg (cfg);
>}
>
>guint
>mono_type_to_regmove (MonoCompile *cfg, MonoType *type)
>{
> if (type->byref)
>  return OP_MOVE;
>
>handle_enum:
> switch (type->type) {
> case MONO_TYPE_I1:
> case MONO_TYPE_U1:
> case MONO_TYPE_BOOLEAN:
>  return OP_MOVE;
> case MONO_TYPE_I2:
> case MONO_TYPE_U2:
> case MONO_TYPE_CHAR:
>  return OP_MOVE;
> case MONO_TYPE_I4:
> case MONO_TYPE_U4:
>  return OP_MOVE;
> case MONO_TYPE_I:
> case MONO_TYPE_U:
> case MONO_TYPE_PTR:
> case MONO_TYPE_FNPTR:
>  return OP_MOVE;
> case MONO_TYPE_CLASS:
> case MONO_TYPE_STRING:
> case MONO_TYPE_OBJECT:
> case MONO_TYPE_SZARRAY:
> case MONO_TYPE_ARRAY:
>  return OP_MOVE;
> case MONO_TYPE_I8:
> case MONO_TYPE_U8:
>
>  return OP_MOVE;
>
>
>
> case MONO_TYPE_R4:
>  return OP_FMOVE;
> case MONO_TYPE_R8:
>  return OP_FMOVE;
> case MONO_TYPE_VALUETYPE:
>  if (type->data.klass->enumtype) {
>   type = mono_class_enum_basetype (type->data.klass);
>   goto handle_enum;
>  }
>  if ((0))
>   return OP_XMOVE;
>  return OP_VMOVE;
> case MONO_TYPE_TYPEDBYREF:
>  return OP_VMOVE;
> case MONO_TYPE_GENERICINST:
>  type = &type->data.generic_class->container_class->byval_arg;
>  goto handle_enum;
> case MONO_TYPE_VAR:
> case MONO_TYPE_MVAR:
>  do { if (!(cfg->generic_sharing_context)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 302, "cfg->generic_sharing_context"); } while (0);
>  return OP_MOVE;
> default:
>  do { monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "unknown type 0x%02x in type_to_regstore", type->type); for (;;); } while (0);
> }
> return -1;
>}
>
>void
>mono_print_bb (MonoBasicBlock *bb, const char *msg)
>{
> int i;
> MonoInst *tree;
>
> printf ("\n%s %d: [IN: ", msg, bb->block_num);
> for (i = 0; i < bb->in_count; ++i)
>  printf (" BB%d(%d)", bb->in_bb [i]->block_num, bb->in_bb [i]->dfn);
> printf (", OUT: ");
> for (i = 0; i < bb->out_count; ++i)
>  printf (" BB%d(%d)", bb->out_bb [i]->block_num, bb->out_bb [i]->dfn);
> printf (" ]\n");
> for (tree = bb->code; tree; tree = tree->next)
>  mono_print_ins_index (-1, tree);
>}
>
>void
>mono_create_helper_signatures (void)
>{
> helper_sig_domain_get = mono_create_icall_signature ("ptr");
> helper_sig_class_init_trampoline = mono_create_icall_signature ("void");
> helper_sig_generic_class_init_trampoline = mono_create_icall_signature ("void");
> helper_sig_generic_class_init_trampoline_llvm = mono_create_icall_signature ("void ptr");
> helper_sig_rgctx_lazy_fetch_trampoline = mono_create_icall_signature ("ptr ptr");
> helper_sig_monitor_enter_exit_trampoline = mono_create_icall_signature ("void");
> helper_sig_monitor_enter_exit_trampoline_llvm = mono_create_icall_signature ("void object");
>}
># 448 "method-to-ir.c"
>static void
>link_bblock (MonoCompile *cfg, MonoBasicBlock *from, MonoBasicBlock* to)
>{
> MonoBasicBlock **newa;
> int i, found;
># 468 "method-to-ir.c"
> found = 0;
> for (i = 0; i < from->out_count; ++i) {
>  if (to == from->out_bb [i]) {
>   found = 1;
>   break;
>  }
> }
> if (!found) {
>  newa = mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (from->out_count + 1));
>  for (i = 0; i < from->out_count; ++i) {
>   newa [i] = from->out_bb [i];
>  }
>  newa [i] = to;
>  from->out_count++;
>  from->out_bb = newa;
> }
>
> found = 0;
> for (i = 0; i < to->in_count; ++i) {
>  if (from == to->in_bb [i]) {
>   found = 1;
>   break;
>  }
> }
> if (!found) {
>  newa = mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (to->in_count + 1));
>  for (i = 0; i < to->in_count; ++i) {
>   newa [i] = to->in_bb [i];
>  }
>  newa [i] = from;
>  to->in_count++;
>  to->in_bb = newa;
> }
>}
>
>void
>mono_link_bblock (MonoCompile *cfg, MonoBasicBlock *from, MonoBasicBlock* to)
>{
> link_bblock (cfg, from, to);
>}
># 523 "method-to-ir.c"
>static int
>mono_find_block_region (MonoCompile *cfg, int offset)
>{
> MonoMethodHeader *header = cfg->header;
> MonoExceptionClause *clause;
> int i;
>
> for (i = 0; i < header->num_clauses; ++i) {
>  clause = &header->clauses [i];
>  if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
>      (offset < (clause->handler_offset)))
>   return ((i + 1) << 8) | 128 | clause->flags;
>
>  if (((clause)->handler_offset <= (offset) && (offset) < ((clause)->handler_offset + (clause)->handler_len))) {
>   if (clause->flags == MONO_EXCEPTION_CLAUSE_FINALLY)
>    return ((i + 1) << 8) | 16 | clause->flags;
>   else if (clause->flags == MONO_EXCEPTION_CLAUSE_FAULT)
>    return ((i + 1) << 8) | 64 | clause->flags;
>   else
>    return ((i + 1) << 8) | 32 | clause->flags;
>  }
>
>  if (((clause)->try_offset <= (offset) && (offset) < ((clause)->try_offset + (clause)->try_len)))
>   return ((i + 1) << 8) | clause->flags;
> }
>
> return -1;
>}
>
>static GList*
>mono_find_final_block (MonoCompile *cfg, unsigned char *ip, unsigned char *target, int type)
>{
> MonoMethodHeader *header = cfg->header;
> MonoExceptionClause *clause;
> int i;
> GList *res = ((void *)0);
>
> for (i = 0; i < header->num_clauses; ++i) {
>  clause = &header->clauses [i];
>  if (((clause)->try_offset <= ((ip - header->code)) && ((ip - header->code)) < ((clause)->try_offset + (clause)->try_len)) &&
>      (!((clause)->try_offset <= ((target - header->code)) && ((target - header->code)) < ((clause)->try_offset + (clause)->try_len)))) {
>   if (clause->flags == type)
>    res = monoeg_g_list_append (res, clause);
>  }
> }
> return res;
>}
>
>static void
>mono_create_spvar_for_region (MonoCompile *cfg, int region)
>{
> MonoInst *var;
>
> var = monoeg_g_hash_table_lookup (cfg->spvars, ((gpointer)(glong) (region)));
> if (var)
>  return;
>
> var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
>
> var->flags |= MONO_INST_INDIRECT;
>
> monoeg_g_hash_table_insert_replace ((cfg->spvars),(((gpointer)(glong) (region))),(var),0);
>}
>
>MonoInst *
>mono_find_exvar_for_offset (MonoCompile *cfg, int offset)
>{
> return monoeg_g_hash_table_lookup (cfg->exvars, ((gpointer)(glong) (offset)));
>}
>
>static MonoInst*
>mono_create_exvar_for_offset (MonoCompile *cfg, int offset)
>{
> MonoInst *var;
>
> var = monoeg_g_hash_table_lookup (cfg->exvars, ((gpointer)(glong) (offset)));
> if (var)
>  return var;
>
> var = mono_compile_create_var (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL);
>
> var->flags |= MONO_INST_INDIRECT;
>
> monoeg_g_hash_table_insert_replace ((cfg->exvars),(((gpointer)(glong) (offset))),(var),0);
>
> return var;
>}
>
>
>
>
>
>void
>type_to_eval_stack_type (MonoCompile *cfg, MonoType *type, MonoInst *inst)
>{
> MonoClass *klass;
>
> inst->klass = klass = mono_class_from_mono_type (type);
> if (type->byref) {
>  inst->type = STACK_MP;
>  return;
> }
>
>handle_enum:
> switch (type->type) {
> case MONO_TYPE_VOID:
>  inst->type = STACK_INV;
>  return;
> case MONO_TYPE_I1:
> case MONO_TYPE_U1:
> case MONO_TYPE_BOOLEAN:
> case MONO_TYPE_I2:
> case MONO_TYPE_U2:
> case MONO_TYPE_CHAR:
> case MONO_TYPE_I4:
> case MONO_TYPE_U4:
>  inst->type = STACK_I4;
>  return;
> case MONO_TYPE_I:
> case MONO_TYPE_U:
> case MONO_TYPE_PTR:
> case MONO_TYPE_FNPTR:
>  inst->type = STACK_PTR;
>  return;
> case MONO_TYPE_CLASS:
> case MONO_TYPE_STRING:
> case MONO_TYPE_OBJECT:
> case MONO_TYPE_SZARRAY:
> case MONO_TYPE_ARRAY:
>  inst->type = STACK_OBJ;
>  return;
> case MONO_TYPE_I8:
> case MONO_TYPE_U8:
>  inst->type = STACK_I8;
>  return;
> case MONO_TYPE_R4:
> case MONO_TYPE_R8:
>  inst->type = STACK_R8;
>  return;
> case MONO_TYPE_VALUETYPE:
>  if (type->data.klass->enumtype) {
>   type = mono_class_enum_basetype (type->data.klass);
>   goto handle_enum;
>  } else {
>   inst->klass = klass;
>   inst->type = STACK_VTYPE;
>   return;
>  }
> case MONO_TYPE_TYPEDBYREF:
>  inst->klass = mono_defaults.typed_reference_class;
>  inst->type = STACK_VTYPE;
>  return;
> case MONO_TYPE_GENERICINST:
>  type = &type->data.generic_class->container_class->byval_arg;
>  goto handle_enum;
> case MONO_TYPE_VAR :
> case MONO_TYPE_MVAR :
>
>
>
>
>  do { if (!(cfg->generic_sharing_context)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 684, "cfg->generic_sharing_context"); } while (0);
>  inst->type = STACK_OBJ;
>  return;
> default:
>  do { monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "unknown type 0x%02x in eval stack type", type->type); for (;;); } while (0);
> }
>}
>
>
>
>
>static const char
>bin_num_table [STACK_MAX] [STACK_MAX] = {
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_I4, STACK_INV, STACK_PTR, STACK_INV, STACK_MP, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_I8, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_PTR, STACK_INV, STACK_PTR, STACK_INV, STACK_MP, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_R8, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_MP, STACK_INV, STACK_MP, STACK_INV, STACK_PTR, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV}
>};
>
>static const char
>neg_table [] = {
> STACK_INV, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_INV, STACK_INV, STACK_INV
>};
>
>
>static const char
>bin_int_table [STACK_MAX] [STACK_MAX] = {
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_I4, STACK_INV, STACK_PTR, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_I8, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_PTR, STACK_INV, STACK_PTR, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV}
>};
>
>static const char
>bin_comp_table [STACK_MAX] [STACK_MAX] = {
>
> {0},
> {0, 1, 0, 1, 0, 0, 0, 0},
> {0, 0, 1, 0, 0, 0, 0, 0},
> {0, 1, 0, 1, 0, 2, 4, 0},
> {0, 0, 0, 0, 1, 0, 0, 0},
> {0, 0, 0, 2, 0, 1, 0, 0},
> {0, 0, 0, 4, 0, 0, 3, 0},
> {0, 0, 0, 0, 0, 0, 0, 0},
>};
>
>
>static const char
>shift_table [STACK_MAX] [STACK_MAX] = {
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_I4, STACK_INV, STACK_I4, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_I8, STACK_INV, STACK_I8, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_PTR, STACK_INV, STACK_PTR, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
> {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV}
>};
>
>
>
>
>
>
>static const guint16
>binops_op_map [STACK_MAX] = {
> 0, OP_IADD-CEE_ADD, OP_LADD-CEE_ADD, OP_LADD-CEE_ADD, OP_FADD-CEE_ADD, OP_LADD-CEE_ADD
>};
>
>
>static const guint16
>unops_op_map [STACK_MAX] = {
> 0, OP_INEG-CEE_NEG, OP_LNEG-CEE_NEG, OP_LNEG-CEE_NEG, OP_FNEG-CEE_NEG, OP_LNEG-CEE_NEG
>};
>
>
>static const guint16
>ovfops_op_map [STACK_MAX] = {
> 0, OP_ICONV_TO_U2-CEE_CONV_U2, OP_LCONV_TO_U2-CEE_CONV_U2, OP_LCONV_TO_U2-CEE_CONV_U2, OP_FCONV_TO_U2-CEE_CONV_U2, OP_LCONV_TO_U2-CEE_CONV_U2, OP_LCONV_TO_U2-CEE_CONV_U2
>};
>
>
>static const guint16
>ovf2ops_op_map [STACK_MAX] = {
> 0, OP_ICONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, OP_LCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, OP_LCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, OP_FCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, OP_LCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN
>};
>
>
>static const guint16
>ovf3ops_op_map [STACK_MAX] = {
> 0, OP_ICONV_TO_OVF_I1-CEE_CONV_OVF_I1, OP_LCONV_TO_OVF_I1-CEE_CONV_OVF_I1, OP_LCONV_TO_OVF_I1-CEE_CONV_OVF_I1, OP_FCONV_TO_OVF_I1-CEE_CONV_OVF_I1, OP_LCONV_TO_OVF_I1-CEE_CONV_OVF_I1
>};
>
>
>static const guint16
>beqops_op_map [STACK_MAX] = {
> 0, OP_IBEQ-CEE_BEQ, OP_LBEQ-CEE_BEQ, OP_LBEQ-CEE_BEQ, OP_FBEQ-CEE_BEQ, OP_LBEQ-CEE_BEQ, OP_LBEQ-CEE_BEQ
>};
>
>
>static const guint16
>ceqops_op_map [STACK_MAX] = {
> 0, OP_ICEQ-OP_CEQ, OP_LCEQ-OP_CEQ, OP_LCEQ-OP_CEQ, OP_FCEQ-OP_CEQ, OP_LCEQ-OP_CEQ, OP_LCEQ-OP_CEQ
>};
># 805 "method-to-ir.c"
>static void
>type_from_op (MonoInst *ins, MonoInst *src1, MonoInst *src2) {
>
> switch (ins->opcode) {
>
> case CEE_ADD:
> case CEE_SUB:
> case CEE_MUL:
> case CEE_DIV:
> case CEE_REM:
>
>  ins->type = bin_num_table [src1->type] [src2->type];
>  ins->opcode += binops_op_map [ins->type];
>  break;
> case CEE_DIV_UN:
> case CEE_REM_UN:
> case CEE_AND:
> case CEE_OR:
> case CEE_XOR:
>  ins->type = bin_int_table [src1->type] [src2->type];
>  ins->opcode += binops_op_map [ins->type];
>  break;
> case CEE_SHL:
> case CEE_SHR:
> case CEE_SHR_UN:
>  ins->type = shift_table [src1->type] [src2->type];
>  ins->opcode += binops_op_map [ins->type];
>  break;
> case OP_COMPARE:
> case OP_LCOMPARE:
> case OP_ICOMPARE:
>  ins->type = bin_comp_table [src1->type] [src2->type] ? STACK_I4: STACK_INV;
>  if ((src1->type == STACK_I8) || ((8 == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
>   ins->opcode = OP_LCOMPARE;
>  else if (src1->type == STACK_R8)
>   ins->opcode = OP_FCOMPARE;
>  else
>   ins->opcode = OP_ICOMPARE;
>  break;
> case OP_ICOMPARE_IMM:
>  ins->type = bin_comp_table [src1->type] [src1->type] ? STACK_I4 : STACK_INV;
>  if ((src1->type == STACK_I8) || ((8 == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
>   ins->opcode = OP_LCOMPARE_IMM;
>  break;
> case CEE_BEQ:
> case CEE_BGE:
> case CEE_BGT:
> case CEE_BLE:
> case CEE_BLT:
> case CEE_BNE_UN:
> case CEE_BGE_UN:
> case CEE_BGT_UN:
> case CEE_BLE_UN:
> case CEE_BLT_UN:
>  ins->opcode += beqops_op_map [src1->type];
>  break;
> case OP_CEQ:
>  ins->type = bin_comp_table [src1->type] [src2->type] ? STACK_I4: STACK_INV;
>  ins->opcode += ceqops_op_map [src1->type];
>  break;
> case OP_CGT:
> case OP_CGT_UN:
> case OP_CLT:
> case OP_CLT_UN:
>  ins->type = (bin_comp_table [src1->type] [src2->type] & 1) ? STACK_I4: STACK_INV;
>  ins->opcode += ceqops_op_map [src1->type];
>  break;
>
> case CEE_NEG:
>  ins->type = neg_table [src1->type];
>  ins->opcode += unops_op_map [ins->type];
>  break;
> case CEE_NOT:
>  if (src1->type >= STACK_I4 && src1->type <= STACK_PTR)
>   ins->type = src1->type;
>  else
>   ins->type = STACK_INV;
>  ins->opcode += unops_op_map [ins->type];
>  break;
> case CEE_CONV_I1:
> case CEE_CONV_I2:
> case CEE_CONV_I4:
> case CEE_CONV_U4:
>  ins->type = STACK_I4;
>  ins->opcode += unops_op_map [src1->type];
>  break;
> case CEE_CONV_R_UN:
>  ins->type = STACK_R8;
>  switch (src1->type) {
>  case STACK_I4:
>  case STACK_PTR:
>   ins->opcode = OP_ICONV_TO_R_UN;
>   break;
>  case STACK_I8:
>   ins->opcode = OP_LCONV_TO_R_UN;
>   break;
>  }
>  break;
> case CEE_CONV_OVF_I1:
> case CEE_CONV_OVF_U1:
> case CEE_CONV_OVF_I2:
> case CEE_CONV_OVF_U2:
> case CEE_CONV_OVF_I4:
> case CEE_CONV_OVF_U4:
>  ins->type = STACK_I4;
>  ins->opcode += ovf3ops_op_map [src1->type];
>  break;
> case CEE_CONV_OVF_I_UN:
> case CEE_CONV_OVF_U_UN:
>  ins->type = STACK_PTR;
>  ins->opcode += ovf2ops_op_map [src1->type];
>  break;
> case CEE_CONV_OVF_I1_UN:
> case CEE_CONV_OVF_I2_UN:
> case CEE_CONV_OVF_I4_UN:
> case CEE_CONV_OVF_U1_UN:
> case CEE_CONV_OVF_U2_UN:
> case CEE_CONV_OVF_U4_UN:
>  ins->type = STACK_I4;
>  ins->opcode += ovf2ops_op_map [src1->type];
>  break;
> case CEE_CONV_U:
>  ins->type = STACK_PTR;
>  switch (src1->type) {
>  case STACK_I4:
>   ins->opcode = OP_ICONV_TO_U;
>   break;
>  case STACK_PTR:
>  case STACK_MP:
>
>   ins->opcode = OP_LCONV_TO_U;
>
>
>
>   break;
>  case STACK_I8:
>   ins->opcode = OP_LCONV_TO_U;
>   break;
>  case STACK_R8:
>   ins->opcode = OP_FCONV_TO_U;
>   break;
>  }
>  break;
> case CEE_CONV_I8:
> case CEE_CONV_U8:
>  ins->type = STACK_I8;
>  ins->opcode += unops_op_map [src1->type];
>  break;
> case CEE_CONV_OVF_I8:
> case CEE_CONV_OVF_U8:
>  ins->type = STACK_I8;
>  ins->opcode += ovf3ops_op_map [src1->type];
>  break;
> case CEE_CONV_OVF_U8_UN:
> case CEE_CONV_OVF_I8_UN:
>  ins->type = STACK_I8;
>  ins->opcode += ovf2ops_op_map [src1->type];
>  break;
> case CEE_CONV_R4:
> case CEE_CONV_R8:
>  ins->type = STACK_R8;
>  ins->opcode += unops_op_map [src1->type];
>  break;
> case OP_CKFINITE:
>  ins->type = STACK_R8;
>  break;
> case CEE_CONV_U2:
> case CEE_CONV_U1:
>  ins->type = STACK_I4;
>  ins->opcode += ovfops_op_map [src1->type];
>  break;
> case CEE_CONV_I:
> case CEE_CONV_OVF_I:
> case CEE_CONV_OVF_U:
>  ins->type = STACK_PTR;
>  ins->opcode += ovfops_op_map [src1->type];
>  break;
> case CEE_ADD_OVF:
> case CEE_ADD_OVF_UN:
> case CEE_MUL_OVF:
> case CEE_MUL_OVF_UN:
> case CEE_SUB_OVF:
> case CEE_SUB_OVF_UN:
>  ins->type = bin_num_table [src1->type] [src2->type];
>  ins->opcode += ovfops_op_map [src1->type];
>  if (ins->type == STACK_R8)
>   ins->type = STACK_INV;
>  break;
> case OP_LOAD_MEMBASE:
>  ins->type = STACK_PTR;
>  break;
> case OP_LOADI1_MEMBASE:
> case OP_LOADU1_MEMBASE:
> case OP_LOADI2_MEMBASE:
> case OP_LOADU2_MEMBASE:
> case OP_LOADI4_MEMBASE:
> case OP_LOADU4_MEMBASE:
>  ins->type = STACK_PTR;
>  break;
> case OP_LOADI8_MEMBASE:
>  ins->type = STACK_I8;
>  break;
> case OP_LOADR4_MEMBASE:
> case OP_LOADR8_MEMBASE:
>  ins->type = STACK_R8;
>  break;
> default:
>  do { monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "opcode 0x%04x not handled in type from op", ins->opcode); for (;;); } while (0);
>  break;
> }
>
> if (ins->type == STACK_MP)
>  ins->klass = mono_defaults.object_class;
>}
>
>static const char
>ldind_type [] = {
> STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
>};
># 1093 "method-to-ir.c"
>inline static MonoInst *
>mono_get_domainvar (MonoCompile *cfg)
>{
> if (!cfg->domainvar)
>  cfg->domainvar = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
> return cfg->domainvar;
>}
>
>
>
>
>
>MonoInst *
>mono_get_got_var (MonoCompile *cfg)
>{
># 1116 "method-to-ir.c"
> return ((void *)0);
>
>}
>
>static MonoInst *
>mono_get_vtable_var (MonoCompile *cfg)
>{
> do { if (!(cfg->generic_sharing_context)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 1123, "cfg->generic_sharing_context"); } while (0);
>
> if (!cfg->rgctx_var) {
>  cfg->rgctx_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
>
>  cfg->rgctx_var->flags |= MONO_INST_INDIRECT;
> }
>
> return cfg->rgctx_var;
>}
>
>static MonoType*
>type_from_stack_type (MonoInst *ins) {
> switch (ins->type) {
> case STACK_I4: return &mono_defaults.int32_class->byval_arg;
> case STACK_I8: return &mono_defaults.int64_class->byval_arg;
> case STACK_PTR: return &mono_defaults.int_class->byval_arg;
> case STACK_R8: return &mono_defaults.double_class->byval_arg;
> case STACK_MP:
>  return &ins->klass->this_arg;
> case STACK_OBJ: return &mono_defaults.object_class->byval_arg;
> case STACK_VTYPE: return &ins->klass->byval_arg;
> default:
>  do { monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "stack type %d to monotype not handled\n", ins->type); for (;;); } while (0);
> }
> return ((void *)0);
>}
>
>static __attribute__((__unused__)) int
>type_to_stack_type (MonoType *t)
>{
> t = mono_type_get_underlying_type (t);
> switch (t->type) {
> case MONO_TYPE_I1:
> case MONO_TYPE_U1:
> case MONO_TYPE_BOOLEAN:
> case MONO_TYPE_I2:
> case MONO_TYPE_U2:
> case MONO_TYPE_CHAR:
> case MONO_TYPE_I4:
> case MONO_TYPE_U4:
>  return STACK_I4;
> case MONO_TYPE_I:
> case MONO_TYPE_U:
> case MONO_TYPE_PTR:
> case MONO_TYPE_FNPTR:
>  return STACK_PTR;
> case MONO_TYPE_CLASS:
> case MONO_TYPE_STRING:
> case MONO_TYPE_OBJECT:
> case MONO_TYPE_SZARRAY:
> case MONO_TYPE_ARRAY:
>  return STACK_OBJ;
> case MONO_TYPE_I8:
> case MONO_TYPE_U8:
>  return STACK_I8;
> case MONO_TYPE_R4:
> case MONO_TYPE_R8:
>  return STACK_R8;
> case MONO_TYPE_VALUETYPE:
> case MONO_TYPE_TYPEDBYREF:
>  return STACK_VTYPE;
> case MONO_TYPE_GENERICINST:
>  if (mono_type_generic_inst_is_valuetype (t))
>   return STACK_VTYPE;
>  else
>   return STACK_OBJ;
>  break;
> default:
>  do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 1192); } while (0);
> }
>
> return -1;
>}
>
>static MonoClass*
>array_access_to_klass (int opcode)
>{
> switch (opcode) {
> case CEE_LDELEM_U1:
>  return mono_defaults.byte_class;
> case CEE_LDELEM_U2:
>  return mono_defaults.uint16_class;
> case CEE_LDELEM_I:
> case CEE_STELEM_I:
>  return mono_defaults.int_class;
> case CEE_LDELEM_I1:
> case CEE_STELEM_I1:
>  return mono_defaults.sbyte_class;
> case CEE_LDELEM_I2:
> case CEE_STELEM_I2:
>  return mono_defaults.int16_class;
> case CEE_LDELEM_I4:
> case CEE_STELEM_I4:
>  return mono_defaults.int32_class;
> case CEE_LDELEM_U4:
>  return mono_defaults.uint32_class;
> case CEE_LDELEM_I8:
> case CEE_STELEM_I8:
>  return mono_defaults.int64_class;
> case CEE_LDELEM_R4:
> case CEE_STELEM_R4:
>  return mono_defaults.single_class;
> case CEE_LDELEM_R8:
> case CEE_STELEM_R8:
>  return mono_defaults.double_class;
> case CEE_LDELEM_REF:
> case CEE_STELEM_REF:
>  return mono_defaults.object_class;
> default:
>  do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 1233); } while (0);
> }
> return ((void *)0);
>}
>
>
>
>
>static MonoInst *
>mono_compile_get_interface_var (MonoCompile *cfg, int slot, MonoInst *ins)
>{
> MonoInst *res;
> int pos, vnum;
>
>
> if (slot >= cfg->header->max_stack)
>  return mono_compile_create_var (cfg, type_from_stack_type (ins), OP_LOCAL);
>
> pos = ins->type - 1 + slot * STACK_MAX;
>
> switch (ins->type) {
> case STACK_I4:
> case STACK_I8:
> case STACK_R8:
> case STACK_PTR:
> case STACK_MP:
> case STACK_OBJ:
>  if ((vnum = cfg->intvars [pos]))
>   return cfg->varinfo [vnum];
>  res = mono_compile_create_var (cfg, type_from_stack_type (ins), OP_LOCAL);
>  cfg->intvars [pos] = res->data.op[0].const_val;
>  break;
> default:
>  res = mono_compile_create_var (cfg, type_from_stack_type (ins), OP_LOCAL);
> }
> return res;
>}
>
>static void
>mono_save_token_info (MonoCompile *cfg, MonoImage *image, guint32 token, gpointer key)
>{
>
>
>
>
>
> if (cfg->compile_aot && !cfg->generic_context && (((token) >> 24) > 0)) {
>  MonoJumpInfoToken *jump_info_token = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
>  jump_info_token->image = image;
>  jump_info_token->token = token;
>  monoeg_g_hash_table_insert_replace ((cfg->token_info_hash),(key),(jump_info_token),0);
> }
>}
># 1299 "method-to-ir.c"
>static void
>handle_stack_args (MonoCompile *cfg, MonoInst **sp, int count)
>{
> int i, bindex;
> MonoBasicBlock *bb = cfg->cbb;
> MonoBasicBlock *outb;
> MonoInst *inst, **locals;
> gboolean found;
>
> if (!count)
>  return;
> if (cfg->verbose_level > 3)
>  printf ("%d item(s) on exit from B%d\n", count, bb->block_num);
> if (!bb->out_scount) {
>  bb->out_scount = count;
>
>  found = 0;
>  for (i = 0; i < bb->out_count; ++i) {
>   outb = bb->out_bb [i];
>
>   if (outb->flags & BB_EXCEPTION_HANDLER)
>    continue;
>
>   if (outb->in_stack) {
>    found = 1;
>    bb->out_stack = outb->in_stack;
>    break;
>   }
>  }
>
>  if (!found) {
>   bb->out_stack = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * count);
>   for (i = 0; i < count; ++i) {
># 1344 "method-to-ir.c"
>    if (cfg->inlined_method)
>     bb->out_stack [i] = mono_compile_create_var (cfg, type_from_stack_type (sp [i]), OP_LOCAL);
>    else
>     bb->out_stack [i] = mono_compile_get_interface_var (cfg, i, sp [i]);
>   }
>  }
> }
>
> for (i = 0; i < bb->out_count; ++i) {
>  outb = bb->out_bb [i];
>
>  if (outb->flags & BB_EXCEPTION_HANDLER)
>   continue;
>  if (outb->in_scount) {
>   if (outb->in_scount != bb->out_scount) {
>    cfg->unverifiable = 1;
>    return;
>   }
>   continue;
>  }
>  outb->in_scount = count;
>  outb->in_stack = bb->out_stack;
> }
>
> locals = bb->out_stack;
> cfg->cbb = bb;
> for (i = 0; i < count; ++i) {
>  do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = (OP_MOVE); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((locals [i]->data.op[0].const_val))]->data.op[1].vtype)); (((inst)))->klass = (((cfg))->varinfo [((locals [i]->data.op[0].const_val))])->klass; (((inst)))->sreg1 = (((sp [i])))->dreg; (((inst)))->dreg = (((cfg))->varinfo [((locals [i]->data.op[0].const_val))])->dreg; if ((((inst)))->opcode == OP_VMOVE) (((inst)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((locals [i]->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((inst)); ((inst))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((inst)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((inst)); } } while (0); } while (0);
>  inst->cil_code = sp [i]->cil_code;
>  sp [i] = locals [i];
>  if (cfg->verbose_level > 3)
>   printf ("storing %d to temp %d\n", i, (int)locals [i]->data.op[0].const_val);
> }
>
>
>
>
>
>
>
> found = 1;
> bindex = 0;
> while (found) {
>
>  found = 0;
>  while (bindex < bb->out_count) {
>   outb = bb->out_bb [bindex];
>
>   if (outb->flags & BB_EXCEPTION_HANDLER) {
>    bindex++;
>    continue;
>   }
>   if (outb->in_stack != locals) {
>    for (i = 0; i < count; ++i) {
>     do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = (OP_MOVE); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((outb->in_stack [i]->data.op[0].const_val))]->data.op[1].vtype)); (((inst)))->klass = (((cfg))->varinfo [((outb->in_stack [i]->data.op[0].const_val))])->klass; (((inst)))->sreg1 = (((sp [i])))->dreg; (((inst)))->dreg = (((cfg))->varinfo [((outb->in_stack [i]->data.op[0].const_val))])->dreg; if ((((inst)))->opcode == OP_VMOVE) (((inst)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((outb->in_stack [i]->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((inst)); ((inst))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((inst)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((inst)); } } while (0); } while (0);
>     inst->cil_code = sp [i]->cil_code;
>     sp [i] = locals [i];
>     if (cfg->verbose_level > 3)
>      printf ("storing %d to temp %d\n", i, (int)outb->in_stack [i]->data.op[0].const_val);
>    }
>    locals = outb->in_stack;
>    found = 1;
>    break;
>   }
>   bindex ++;
>  }
> }
>}
>
>
>
>
>static void
>mini_emit_load_intf_reg_vtable (MonoCompile *cfg, int intf_reg, int vtable_reg, MonoClass *klass)
>{
> if (cfg->compile_aot) {
>  int ioffset_reg = alloc_preg (cfg);
>  int iid_reg = alloc_preg (cfg);
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = iid_reg; inst->data.op[0].p = klass; inst->data.op[1].const_val = MONO_PATCH_INFO_ADJUSTED_IID; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LADD)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = ioffset_reg; inst->sreg1 = iid_reg; inst->sreg2 = vtable_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (intf_reg); inst->sreg1 = (ioffset_reg); inst->data.op[0].const_val = (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> }
> else {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (intf_reg); inst->sreg1 = (vtable_reg); inst->data.op[0].const_val = (-((klass->interface_id + 1) * 8)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> }
>}
>
>static void
>mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_reg, int offset, MonoClass *klass)
>{
> int ibitmap_reg = alloc_preg (cfg);
># 1449 "method-to-ir.c"
> int ibitmap_byte_reg = alloc_preg (cfg);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (ibitmap_reg); inst->sreg1 = (base_reg); inst->data.op[0].const_val = (offset); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
> if (cfg->compile_aot) {
>  int iid_reg = alloc_preg (cfg);
>  int shifted_iid_reg = alloc_preg (cfg);
>  int ibitmap_byte_address_reg = alloc_preg (cfg);
>  int masked_iid_reg = alloc_preg (cfg);
>  int iid_one_bit_reg = alloc_preg (cfg);
>  int iid_bit_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = iid_reg; inst->data.op[0].p = klass; inst->data.op[1].const_val = MONO_PATCH_INFO_IID; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_SHR_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = shifted_iid_reg; inst->sreg1 = iid_reg; inst->data.op[1].const_val = (mgreg_t)(3); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LADD)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = ibitmap_byte_address_reg; inst->sreg1 = ibitmap_reg; inst->sreg2 = shifted_iid_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADU1_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = ibitmap_byte_reg; inst->sreg1 = ibitmap_byte_address_reg; inst->data.op[0].const_val = 0; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_IAND_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = masked_iid_reg; inst->sreg1 = iid_reg; inst->data.op[1].const_val = (mgreg_t)(7); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_ICONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = iid_one_bit_reg; inst->data.op[0].const_val = 1; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_ISHL)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = iid_bit_reg; inst->sreg1 = iid_one_bit_reg; inst->sreg2 = masked_iid_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_IAND)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = intf_bit_reg; inst->sreg1 = ibitmap_byte_reg; inst->sreg2 = iid_bit_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> } else {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI1_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = ibitmap_byte_reg; inst->sreg1 = ibitmap_reg; inst->data.op[0].const_val = klass->interface_id >> 3; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_AND_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = intf_bit_reg; inst->sreg1 = ibitmap_byte_reg; inst->data.op[1].const_val = (mgreg_t)(1 << (klass->interface_id & 7)); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> }
>
>}
>
>
>
>
>
>static void
>mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
>{
> mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, __builtin_offsetof (MonoClass, interface_bitmap), klass);
>}
>
>
>
>
>
>static void
>mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
>{
> mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, __builtin_offsetof (MonoVTable, interface_bitmap), klass);
>}
>
>
>
>
>
>static void
>mini_emit_max_iid_check (MonoCompile *cfg, int max_iid_reg, MonoClass *klass,
>       MonoBasicBlock *false_target)
>{
> if (cfg->compile_aot) {
>  int iid_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = iid_reg; inst->data.op[0].p = klass; inst->data.op[1].const_val = MONO_PATCH_INFO_IID; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = max_iid_reg; inst->sreg2 = iid_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> }
> else
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = max_iid_reg; inst->data.op[1].const_val = (mgreg_t)(klass->interface_id); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> if (false_target)
>  do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBLT_UN)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBLT_UN) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (false_target); mono_link_bblock ((cfg), (cfg)->cbb, (false_target)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (false_target); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (false_target)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
> else
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_LT_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"InvalidCastException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>}
>
>
>static void
>mini_emit_max_iid_check_vtable (MonoCompile *cfg, int vtable_reg, MonoClass *klass,
>         MonoBasicBlock *false_target)
>{
> int max_iid_reg = alloc_preg (cfg);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADU2_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = max_iid_reg; inst->sreg1 = vtable_reg; inst->data.op[0].const_val = __builtin_offsetof (MonoVTable, max_interface_id); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> mini_emit_max_iid_check (cfg, max_iid_reg, klass, false_target);
>}
>
>
>static void
>mini_emit_max_iid_check_class (MonoCompile *cfg, int klass_reg, MonoClass *klass,
>         MonoBasicBlock *false_target)
>{
> int max_iid_reg = alloc_preg (cfg);
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADU2_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = max_iid_reg; inst->sreg1 = klass_reg; inst->data.op[0].const_val = __builtin_offsetof (MonoClass, max_interface_id); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> mini_emit_max_iid_check (cfg, max_iid_reg, klass, false_target);
>}
>
>static void
>mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_ins, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
>{
> int idepth_reg = alloc_preg (cfg);
> int stypes_reg = alloc_preg (cfg);
> int stype = alloc_preg (cfg);
>
> if (klass->idepth > 6) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADU2_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = idepth_reg; inst->sreg1 = klass_reg; inst->data.op[0].const_val = __builtin_offsetof (MonoClass, idepth); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = idepth_reg; inst->data.op[1].const_val = (mgreg_t)(klass->idepth); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBLT_UN)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBLT_UN) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (false_target); mono_link_bblock ((cfg), (cfg)->cbb, (false_target)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (false_target); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (false_target)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
> }
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (stypes_reg); inst->sreg1 = (klass_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoClass, supertypes)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (stype); inst->sreg1 = (stypes_reg); inst->data.op[0].const_val = (((klass->idepth - 1) * 8)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> if (klass_ins) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = stype; inst->sreg2 = klass_ins->dreg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> } else if (cfg->compile_aot) {
>  int const_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = const_reg; inst->data.op[0].p = klass; inst->data.op[1].const_val = MONO_PATCH_INFO_CLASS; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = stype; inst->sreg2 = const_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> } else {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = stype; inst->data.op[1].const_val = (mgreg_t)(klass); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> }
> do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBEQ)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBEQ) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (true_target); mono_link_bblock ((cfg), (cfg)->cbb, (true_target)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (true_target); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (true_target)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>}
>
>static void
>mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
>{
> mini_emit_isninst_cast_inst (cfg, klass_reg, klass, ((void *)0), false_target, true_target);
>}
>
>static void
>mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
>{
> int intf_reg = alloc_preg (cfg);
>
> mini_emit_max_iid_check_vtable (cfg, vtable_reg, klass, false_target);
> mini_emit_load_intf_bit_reg_vtable (cfg, intf_reg, vtable_reg, klass);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = intf_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> if (true_target)
>  do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBNE_UN)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBNE_UN) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (true_target); mono_link_bblock ((cfg), (cfg)->cbb, (true_target)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (true_target); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (true_target)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
> else
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"InvalidCastException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>}
>
>
>
>
>static void
>mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
>{
> int intf_bit_reg = alloc_preg (cfg);
>
> mini_emit_max_iid_check_class (cfg, klass_reg, klass, false_target);
> mini_emit_load_intf_bit_reg_class (cfg, intf_bit_reg, klass_reg, klass);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = intf_bit_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> if (true_target)
>  do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBNE_UN)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBNE_UN) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (true_target); mono_link_bblock ((cfg), (cfg)->cbb, (true_target)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (true_target); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (true_target)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
> else
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"InvalidCastException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>}
>
>static inline void
>mini_emit_class_check_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_inst)
>{
> if (klass_inst) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = klass_reg; inst->sreg2 = klass_inst->dreg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> } else if (cfg->compile_aot) {
>  int const_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = const_reg; inst->data.op[0].p = klass; inst->data.op[1].const_val = MONO_PATCH_INFO_CLASS; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = klass_reg; inst->sreg2 = const_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> } else {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = klass_reg; inst->data.op[1].const_val = (mgreg_t)(klass); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> }
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_NE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"InvalidCastException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>}
>
>static inline void
>mini_emit_class_check (MonoCompile *cfg, int klass_reg, MonoClass *klass)
>{
> return mini_emit_class_check_inst (cfg, klass_reg, klass, ((void *)0));
>}
>
>static inline void
>mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
>{
> if (cfg->compile_aot) {
>  int const_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = const_reg; inst->data.op[0].p = klass; inst->data.op[1].const_val = MONO_PATCH_INFO_CLASS; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = klass_reg; inst->sreg2 = const_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> } else {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = klass_reg; inst->data.op[1].const_val = (mgreg_t)(klass); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> }
> do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((branch_op)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((branch_op) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (target); mono_link_bblock ((cfg), (cfg)->cbb, (target)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (target); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (target)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>}
>
>static void
>mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null);
>
>static void
>mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null)
>{
> if (klass->rank) {
>  int rank_reg = alloc_preg (cfg);
>  int eclass_reg = alloc_preg (cfg);
>
>  do { if (!(!klass_inst)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 1645, "!klass_inst"); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADU1_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = rank_reg; inst->sreg1 = klass_reg; inst->data.op[0].const_val = __builtin_offsetof (MonoClass, rank); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = rank_reg; inst->data.op[1].const_val = (mgreg_t)(klass->rank); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_NE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"InvalidCastException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (eclass_reg); inst->sreg1 = (klass_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoClass, cast_class)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  if (klass->cast_class == mono_defaults.object_class) {
>   int parent_reg = alloc_preg (cfg);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (parent_reg); inst->sreg1 = (eclass_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoClass, parent)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_LBNE_UN, object_is_null);
>   mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class);
>  } else if (klass->cast_class == mono_defaults.enum_class->parent) {
>   mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_LBEQ, object_is_null);
>   mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class);
>  } else if (klass->cast_class == mono_defaults.enum_class) {
>   mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class);
>  } else if (klass->cast_class->flags & 0x00000020) {
>   mini_emit_iface_class_cast (cfg, eclass_reg, klass->cast_class, ((void *)0), ((void *)0));
>  } else {
>
>   mini_emit_castclass (cfg, -1, eclass_reg, klass->cast_class, object_is_null);
>  }
>
>  if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY) && (obj_reg != -1)) {
>
>   int bounds_reg = alloc_preg (cfg);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (bounds_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoArray, bounds)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = bounds_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_NE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"InvalidCastException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  }
> } else {
>  int idepth_reg = alloc_preg (cfg);
>  int stypes_reg = alloc_preg (cfg);
>  int stype = alloc_preg (cfg);
>
>  if (klass->idepth > 6) {
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADU2_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = idepth_reg; inst->sreg1 = klass_reg; inst->data.op[0].const_val = __builtin_offsetof (MonoClass, idepth); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = idepth_reg; inst->data.op[1].const_val = (mgreg_t)(klass->idepth); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_LT_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"InvalidCastException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  }
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (stypes_reg); inst->sreg1 = (klass_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoClass, supertypes)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (stype); inst->sreg1 = (stypes_reg); inst->data.op[0].const_val = (((klass->idepth - 1) * 8)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  mini_emit_class_check_inst (cfg, stype, klass, klass_inst);
> }
>}
>
>static void
>mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
>{
> return mini_emit_castclass_inst (cfg, obj_reg, klass_reg, klass, ((void *)0), object_is_null);
>}
>
>static void
>mini_emit_memset (MonoCompile *cfg, int destreg, int offset, int size, int val, int align)
>{
> int val_reg;
>
> do { if (!(val == 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 1702, "val == 0"); } while (0);
>
> if (align == 0)
>  align = 4;
>
> if ((size <= 4) && (size <= align)) {
>  switch (size) {
>  case 1:
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI1_MEMBASE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = destreg; inst->data.op[0].const_val = offset; inst->data.op[1].const_val = (mgreg_t)(val); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   return;
>  case 2:
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI2_MEMBASE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = destreg; inst->data.op[0].const_val = offset; inst->data.op[1].const_val = (mgreg_t)(val); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   return;
>  case 4:
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI4_MEMBASE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = destreg; inst->data.op[0].const_val = offset; inst->data.op[1].const_val = (mgreg_t)(val); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   return;
>
>  case 8:
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI8_MEMBASE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = destreg; inst->data.op[0].const_val = offset; inst->data.op[1].const_val = (mgreg_t)(val); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   return;
>
>  }
> }
>
> val_reg = alloc_preg (cfg);
>
> if (8 == 8)
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_I8CONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = val_reg; inst->data.i8const = val; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> else
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_ICONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = val_reg; inst->data.op[0].const_val = val; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
> if (align < 4) {
>
>  while (size >= 1) {
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI1_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = val_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   offset += 1;
>   size -= 1;
>  }
>  return;
> }
>
>
> if (8 == 8) {
>  if (offset % 8) {
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI4_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = val_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   offset += 4;
>   size -= 4;
>  }
>  while (size >= 8) {
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI8_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = val_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   offset += 8;
>   size -= 8;
>  }
> }
>
>
> while (size >= 4) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI4_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = val_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  offset += 4;
>  size -= 4;
> }
> while (size >= 2) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI2_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = val_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  offset += 2;
>  size -= 2;
> }
> while (size >= 1) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI1_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = val_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  offset += 1;
>  size -= 1;
> }
>}
>
>void
>mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
>{
> int cur_reg;
>
> if (align == 0)
>  align = 4;
>
>
> do { if (!(size < 10000)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 1784, "size < 10000"); } while (0);
>
> if (align < 4) {
>
>  while (size >= 1) {
>   cur_reg = alloc_preg (cfg);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI1_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = cur_reg; inst->sreg1 = srcreg; inst->data.op[0].const_val = soffset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI1_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = cur_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = doffset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   doffset += 1;
>   soffset += 1;
>   size -= 1;
>  }
> }
>
>
> if (8 == 8) {
>  while (size >= 8) {
>   cur_reg = alloc_preg (cfg);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI8_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = cur_reg; inst->sreg1 = srcreg; inst->data.op[0].const_val = soffset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI8_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = cur_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = doffset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   doffset += 8;
>   soffset += 8;
>   size -= 8;
>  }
> }
>
>
> while (size >= 4) {
>  cur_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI4_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = cur_reg; inst->sreg1 = srcreg; inst->data.op[0].const_val = soffset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI4_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = cur_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = doffset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  doffset += 4;
>  soffset += 4;
>  size -= 4;
> }
> while (size >= 2) {
>  cur_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI2_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = cur_reg; inst->sreg1 = srcreg; inst->data.op[0].const_val = soffset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI2_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = cur_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = doffset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  doffset += 2;
>  soffset += 2;
>  size -= 2;
> }
> while (size >= 1) {
>  cur_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI1_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = cur_reg; inst->sreg1 = srcreg; inst->data.op[0].const_val = soffset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI1_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = cur_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = doffset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  doffset += 1;
>  soffset += 1;
>  size -= 1;
> }
>}
>
>static int
>ret_type_to_call_opcode (MonoType *type, int calli, int virt, MonoGenericSharingContext *gsctx)
>{
> if (type->byref)
>  return calli? OP_CALL_REG: virt? OP_CALLVIRT: OP_CALL;
>
>handle_enum:
> type = mini_get_basic_type_from_generic (gsctx, type);
> switch (type->type) {
> case MONO_TYPE_VOID:
>  return calli? OP_VOIDCALL_REG: virt? OP_VOIDCALLVIRT: OP_VOIDCALL;
> case MONO_TYPE_I1:
> case MONO_TYPE_U1:
> case MONO_TYPE_BOOLEAN:
> case MONO_TYPE_I2:
> case MONO_TYPE_U2:
> case MONO_TYPE_CHAR:
> case MONO_TYPE_I4:
> case MONO_TYPE_U4:
>  return calli? OP_CALL_REG: virt? OP_CALLVIRT: OP_CALL;
> case MONO_TYPE_I:
> case MONO_TYPE_U:
> case MONO_TYPE_PTR:
> case MONO_TYPE_FNPTR:
>  return calli? OP_CALL_REG: virt? OP_CALLVIRT: OP_CALL;
> case MONO_TYPE_CLASS:
> case MONO_TYPE_STRING:
> case MONO_TYPE_OBJECT:
> case MONO_TYPE_SZARRAY:
> case MONO_TYPE_ARRAY:
>  return calli? OP_CALL_REG: virt? OP_CALLVIRT: OP_CALL;
> case MONO_TYPE_I8:
> case MONO_TYPE_U8:
>  return calli? OP_LCALL_REG: virt? OP_LCALLVIRT: OP_LCALL;
> case MONO_TYPE_R4:
> case MONO_TYPE_R8:
>  return calli? OP_FCALL_REG: virt? OP_FCALLVIRT: OP_FCALL;
> case MONO_TYPE_VALUETYPE:
>  if (type->data.klass->enumtype) {
>   type = mono_class_enum_basetype (type->data.klass);
>   goto handle_enum;
>  } else
>   return calli? OP_VCALL_REG: virt? OP_VCALLVIRT: OP_VCALL;
> case MONO_TYPE_TYPEDBYREF:
>  return calli? OP_VCALL_REG: virt? OP_VCALLVIRT: OP_VCALL;
> case MONO_TYPE_GENERICINST:
>  type = &type->data.generic_class->container_class->byval_arg;
>  goto handle_enum;
> default:
>  do { monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "unknown type 0x%02x in ret_type_to_call_opcode", type->type); for (;;); } while (0);
> }
> return -1;
>}
># 1902 "method-to-ir.c"
>static int
>target_type_is_incompatible (MonoCompile *cfg, MonoType *target, MonoInst *arg)
>{
> MonoType *simple_type;
> MonoClass *klass;
>
> if (target->byref) {
>
>  if (arg->type == STACK_MP)
>   return arg->klass != mono_class_from_mono_type (target);
>  if (arg->type == STACK_PTR)
>   return 0;
>  return 1;
> }
>
> simple_type = mono_type_get_underlying_type (target);
> switch (simple_type->type) {
> case MONO_TYPE_VOID:
>  return 1;
> case MONO_TYPE_I1:
> case MONO_TYPE_U1:
> case MONO_TYPE_BOOLEAN:
> case MONO_TYPE_I2:
> case MONO_TYPE_U2:
> case MONO_TYPE_CHAR:
> case MONO_TYPE_I4:
> case MONO_TYPE_U4:
>  if (arg->type != STACK_I4 && arg->type != STACK_PTR)
>   return 1;
>  return 0;
> case MONO_TYPE_PTR:
>
>  if (arg->type != STACK_I4 && arg->type != STACK_PTR && arg->type != STACK_MP)
>   return 1;
>  return 0;
> case MONO_TYPE_I:
> case MONO_TYPE_U:
> case MONO_TYPE_FNPTR:
>
>
>
>
>  if (arg->type != STACK_I4 && arg->type != STACK_PTR && arg->type != STACK_MP)
>   return 1;
>  return 0;
> case MONO_TYPE_CLASS:
> case MONO_TYPE_STRING:
> case MONO_TYPE_OBJECT:
> case MONO_TYPE_SZARRAY:
> case MONO_TYPE_ARRAY:
>  if (arg->type != STACK_OBJ)
>   return 1;
>
>  return 0;
> case MONO_TYPE_I8:
> case MONO_TYPE_U8:
>  if (arg->type != STACK_I8)
>   return 1;
>  return 0;
> case MONO_TYPE_R4:
> case MONO_TYPE_R8:
>  if (arg->type != STACK_R8)
>   return 1;
>  return 0;
> case MONO_TYPE_VALUETYPE:
>  if (arg->type != STACK_VTYPE)
>   return 1;
>  klass = mono_class_from_mono_type (simple_type);
>  if (klass != arg->klass)
>   return 1;
>  return 0;
> case MONO_TYPE_TYPEDBYREF:
>  if (arg->type != STACK_VTYPE)
>   return 1;
>  klass = mono_class_from_mono_type (simple_type);
>  if (klass != arg->klass)
>   return 1;
>  return 0;
> case MONO_TYPE_GENERICINST:
>  if (mono_type_generic_inst_is_valuetype (simple_type)) {
>   if (arg->type != STACK_VTYPE)
>    return 1;
>   klass = mono_class_from_mono_type (simple_type);
>   if (klass != arg->klass)
>    return 1;
>   return 0;
>  } else {
>   if (arg->type != STACK_OBJ)
>    return 1;
>
>   return 0;
>  }
> case MONO_TYPE_VAR:
> case MONO_TYPE_MVAR:
>
>
>
>
>  do { if (!(cfg->generic_sharing_context)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 2000, "cfg->generic_sharing_context"); } while (0);
>  if (arg->type != STACK_OBJ)
>   return 1;
>  return 0;
> default:
>  do { monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "unknown type 0x%02x in target_type_is_incompatible", simple_type->type); for (;;); } while (0);
> }
> return 1;
>}
># 2019 "method-to-ir.c"
>static int
>check_call_signature (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args)
>{
> MonoType *simple_type;
> int i;
>
> if (sig->hasthis) {
>  if (args [0]->type != STACK_OBJ && args [0]->type != STACK_MP && args [0]->type != STACK_PTR)
>   return 1;
>  args++;
> }
> for (i = 0; i < sig->param_count; ++i) {
>  if (sig->params [i]->byref) {
>   if (args [i]->type != STACK_MP && args [i]->type != STACK_PTR)
>    return 1;
>   continue;
>  }
>  simple_type = sig->params [i];
>  simple_type = mini_get_basic_type_from_generic (cfg->generic_sharing_context, simple_type);
>handle_enum:
>  switch (simple_type->type) {
>  case MONO_TYPE_VOID:
>   return 1;
>   continue;
>  case MONO_TYPE_I1:
>  case MONO_TYPE_U1:
>  case MONO_TYPE_BOOLEAN:
>  case MONO_TYPE_I2:
>  case MONO_TYPE_U2:
>  case MONO_TYPE_CHAR:
>  case MONO_TYPE_I4:
>  case MONO_TYPE_U4:
>   if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR)
>    return 1;
>   continue;
>  case MONO_TYPE_I:
>  case MONO_TYPE_U:
>  case MONO_TYPE_PTR:
>  case MONO_TYPE_FNPTR:
>   if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
>    return 1;
>   continue;
>  case MONO_TYPE_CLASS:
>  case MONO_TYPE_STRING:
>  case MONO_TYPE_OBJECT:
>  case MONO_TYPE_SZARRAY:
>  case MONO_TYPE_ARRAY:
>   if (args [i]->type != STACK_OBJ)
>    return 1;
>   continue;
>  case MONO_TYPE_I8:
>  case MONO_TYPE_U8:
>   if (args [i]->type != STACK_I8)
>    return 1;
>   continue;
>  case MONO_TYPE_R4:
>  case MONO_TYPE_R8:
>   if (args [i]->type != STACK_R8)
>    return 1;
>   continue;
>  case MONO_TYPE_VALUETYPE:
>   if (simple_type->data.klass->enumtype) {
>    simple_type = mono_class_enum_basetype (simple_type->data.klass);
>    goto handle_enum;
>   }
>   if (args [i]->type != STACK_VTYPE)
>    return 1;
>   continue;
>  case MONO_TYPE_TYPEDBYREF:
>   if (args [i]->type != STACK_VTYPE)
>    return 1;
>   continue;
>  case MONO_TYPE_GENERICINST:
>   simple_type = &simple_type->data.generic_class->container_class->byval_arg;
>   goto handle_enum;
>
>  default:
>   do { monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "unknown type 0x%02x in check_call_signature", simple_type->type); for (;;); } while (0)
>                       ;
>  }
> }
> return 0;
>}
>
>static int
>callvirt_to_call (int opcode)
>{
> switch (opcode) {
> case OP_CALLVIRT:
>  return OP_CALL;
> case OP_VOIDCALLVIRT:
>  return OP_VOIDCALL;
> case OP_FCALLVIRT:
>  return OP_FCALL;
> case OP_VCALLVIRT:
>  return OP_VCALL;
> case OP_LCALLVIRT:
>  return OP_LCALL;
> default:
>  do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 2118); } while (0);
> }
>
> return -1;
>}
>
>static int
>callvirt_to_call_membase (int opcode)
>{
> switch (opcode) {
> case OP_CALLVIRT:
>  return OP_CALL_MEMBASE;
> case OP_VOIDCALLVIRT:
>  return OP_VOIDCALL_MEMBASE;
> case OP_FCALLVIRT:
>  return OP_FCALL_MEMBASE;
> case OP_LCALLVIRT:
>  return OP_LCALL_MEMBASE;
> case OP_VCALLVIRT:
>  return OP_VCALL_MEMBASE;
> default:
>  do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 2139); } while (0);
> }
>
> return -1;
>}
>
>
>static void
>emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoInst *imt_arg)
>{
> int method_reg;
>
> if ((0)) {
>  method_reg = alloc_preg (cfg);
>
>  if (imt_arg) {
>   do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_MOVE)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((method_reg)); (((inst)))->sreg1 = ((imt_arg->dreg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0);
>  } else if (cfg->compile_aot) {
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = method_reg; inst->data.op[0].p = call->method; inst->data.op[1].const_val = MONO_PATCH_INFO_METHODCONST; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  } else {
>   MonoInst *ins;
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_I8CONST); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ins->data.op[0].p = call->method;
>   ins->dreg = method_reg;
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>  }
>
>
>
>
>
> mono_call_inst_add_outarg_reg (cfg, call, method_reg, s390_r9, 0);
>
>
>
>
>  return;
> }
>
>
> method_reg = alloc_preg (cfg);
>
> if (imt_arg) {
>  do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_MOVE)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((method_reg)); (((inst)))->sreg1 = ((imt_arg->dreg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0);
> } else if (cfg->compile_aot) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = method_reg; inst->data.op[0].p = call->method; inst->data.op[1].const_val = MONO_PATCH_INFO_METHODCONST; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> } else {
>  MonoInst *ins;
>  do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_I8CONST); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>  ins->data.op[0].p = call->method;
>  ins->dreg = method_reg;
>  do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
> }
>
> mono_call_inst_add_outarg_reg (cfg, call, method_reg, s390_r9, 0);
>
>
>
>}
>
>
>static MonoJumpInfo *
>mono_patch_info_new (MonoMemPool *mp, int ip, MonoJumpInfoType type, gconstpointer target)
>{
> MonoJumpInfo *ji = mono_mempool_alloc (mp, sizeof (MonoJumpInfo));
>
> ji->ip.i = ip;
> ji->type = type;
> ji->data.target = target;
>
> return ji;
>}
>
>inline static MonoCallInst *
>mono_emit_call_args (MonoCompile *cfg, MonoMethodSignature *sig,
>      MonoInst **args, int calli, int virtual, int tail, int rgctx)
>{
> MonoCallInst *call;
>
>
>
>
> if (tail)
>  do { (call) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoCallInst)); (call)->inst.opcode = (OP_TAILCALL); (call)->inst.dreg = -1; do { (&(call)->inst)->sreg1 = (&(call)->inst)->sreg2 = (&(call)->inst)->sreg3 = -1; } while (0); (call)->inst.cil_code = (cfg)->ip; } while (0);
> else
>  do { (call) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoCallInst)); (call)->inst.opcode = (ret_type_to_call_opcode (sig->ret, calli, virtual, cfg->generic_sharing_context)); (call)->inst.dreg = -1; do { (&(call)->inst)->sreg1 = (&(call)->inst)->sreg2 = (&(call)->inst)->sreg3 = -1; } while (0); (call)->inst.cil_code = (cfg)->ip; } while (0);
>
> call->args = args;
> call->signature = sig;
> call->rgctx_reg = rgctx;
>
> type_to_eval_stack_type ((cfg), sig->ret, &call->inst);
>
> if (tail) {
>  if (mono_type_is_struct (sig->ret)) {
>   call->vret_var = cfg->vret_addr;
>
>  }
> } else if (mono_type_is_struct (sig->ret)) {
>  MonoInst *temp = mono_compile_create_var (cfg, sig->ret, OP_LOCAL);
>  MonoInst *loada;
>
>  temp->backend.is_pinvoke = sig->pinvoke;
># 2251 "method-to-ir.c"
>  do { (loada) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (loada)->data.op[0].const_val = (loada)->data.op[1].const_val = 0; (loada)->next = (loada)->prev = ((void *)0); (loada)->opcode = (OP_OUTARG_VTRETADDR); (loada)->flags = 0; (loada)->type = 0; (loada)->dreg = -1; do { ((loada))->sreg1 = ((loada))->sreg2 = ((loada))->sreg3 = -1; } while (0); (loada)->cil_code = (cfg)->ip; } while (0);
>  loada->dreg = alloc_preg (cfg);
>  loada->data.op[0].p = temp;
>
>  loada->data.op[1].p = call;
>  do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (loada); (loada)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (loada); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (loada); } } while (0);
>
>  call->inst.dreg = temp->dreg;
>
>  call->vret_var = loada;
> } else if (!mono_type_is_void (sig->ret))
>  call->inst.dreg = alloc_dreg (cfg, call->inst.type);
># 2301 "method-to-ir.c"
> mono_arch_emit_call (cfg, call);
>
>
> cfg->param_area = (((cfg->param_area)>(call->stack_usage)) ? (cfg->param_area) : (call->stack_usage));
> cfg->flags |= MONO_CFG_HAS_CALLS;
>
> return call;
>}
>
>static void
>set_rgctx_arg (MonoCompile *cfg, MonoCallInst *call, int rgctx_reg, MonoInst *rgctx_arg)
>{
># 2321 "method-to-ir.c"
> do { do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 2321); } while (0); } while (0);
>
>}
>
>inline static MonoInst*
>mono_emit_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *rgctx_arg)
>{
> MonoCallInst *call;
> int rgctx_reg = -1;
>
> if (rgctx_arg) {
>  rgctx_reg = mono_alloc_preg (cfg);
>  do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_MOVE)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((rgctx_reg)); (((inst)))->sreg1 = ((rgctx_arg->dreg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0);
> }
>
> call = mono_emit_call_args (cfg, sig, args, 1, 0, 0, rgctx_arg ? 1 : 0);
>
> call->inst.sreg1 = addr->dreg;
>
> do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = ((MonoInst*)call); ((MonoInst*)call)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = ((MonoInst*)call); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = ((MonoInst*)call); } } while (0);
>
> if (rgctx_arg)
>  set_rgctx_arg (cfg, call, rgctx_reg, rgctx_arg);
>
> return (MonoInst*)call;
>}
>
>static MonoInst*
>emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, int rgctx_type);
>static MonoInst*
>emit_get_rgctx_klass (MonoCompile *cfg, int context_used, MonoClass *klass, int rgctx_type);
>
>static MonoInst*
>mono_emit_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig,
>       MonoInst **args, MonoInst *this, MonoInst *imt_arg, MonoInst *rgctx_arg)
>{
> gboolean might_be_remote;
> gboolean virtual = this != ((void *)0);
> gboolean enable_for_aot = 1;
> int context_used;
> MonoCallInst *call;
> int rgctx_reg = 0;
>
> if (rgctx_arg) {
>  rgctx_reg = mono_alloc_preg (cfg);
>  do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_MOVE)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((rgctx_reg)); (((inst)))->sreg1 = ((rgctx_arg->dreg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0);
> }
>
> if (method->string_ctor) {
>
>
>  MonoMethodSignature *ctor_sig = mono_metadata_signature_dup_mempool (cfg->mempool, sig);
>  ctor_sig->ret = &mono_defaults.string_class->byval_arg;
>
>  sig = ctor_sig;
> }
>
> context_used = mono_method_check_context_used (method);
>
> might_be_remote = this && sig->hasthis &&
>  (method->klass->marshalbyref || method->klass == mono_defaults.object_class) &&
>  !(method->flags & 0x0040) && (!(mono_method_signature (cfg->method)->hasthis && ((this)->opcode == OP_MOVE) && ((this)->sreg1 == cfg->args [0]->dreg)) || context_used);
>
> if (might_be_remote && context_used) {
>  MonoInst *addr;
>
>  do { if (!(cfg->generic_sharing_context)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 2387, "cfg->generic_sharing_context"); } while (0);
>
>  addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
>
>  return mono_emit_calli (cfg, sig, args, addr, ((void *)0));
> }
>
> call = mono_emit_call_args (cfg, sig, args, 0, virtual, 0, rgctx_arg ? 1 : 0);
>
> if (might_be_remote)
>  call->method = mono_marshal_get_remoting_invoke_with_check (method);
> else
>  call->method = method;
> call->inst.flags |= MONO_INST_HAS_METHOD;
> call->inst.data.op[0].src = this;
>
> if (virtual) {
>  int vtable_reg, slot_reg, this_reg;
>
>  this_reg = this->dreg;
>
>
>  if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (method->name) && __builtin_constant_p ("Invoke") && (__s1_len = __strlen_g ((method->name)), __s2_len = __strlen_g (("Invoke")), (!((size_t)(const void *)((method->name) + 1) - (size_t)(const void *)(method->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Invoke") + 1) - (size_t)(const void *)("Invoke") == 1) || __s2_len >= 4)) ? __builtin_strcmp (method->name, "Invoke") : (__builtin_constant_p (method->name) && ((size_t)(const void *)((method->name) + 1) - (size_t)(const void *)(method->name) == 1) && (__s1_len = __strlen_g ((method->name)), __s1_len < 4) ? (__builtin_constant_p ("Invoke") && ((size_t)(const void *)(("Invoke") + 1) - (size_t)(const void *)("Invoke") == 1) ? __builtin_strcmp (method->name, "Invoke") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Invoke"); int __result = (((const unsigned char *) (const char *) (method->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (method->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (method->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (method->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Invoke") && ((size_t)(const void *)(("Invoke") + 1) - (size_t)(const void *)("Invoke") == 1) && (__s2_len = __strlen_g (("Invoke")), __s2_len < 4) ? (__builtin_constant_p (method->name) && ((size_t)(const void *)((method->name) + 1) - (size_t)(const void *)(method->name) == 1) ? __builtin_strcmp (method->name, "Invoke") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (method->name); int __result = (((const unsigned char *) (const char *) ("Invoke"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Invoke"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Invoke"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Invoke"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (method->name, "Invoke")))); }))) {
>   MonoInst *dummy_use;
>
>   do { if (cfg->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (this_reg); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0);
>
>
>   call->inst.opcode = callvirt_to_call_membase (call->inst.opcode);
>   call->inst.sreg1 = this_reg;
>   call->inst.data.op[0].const_val = __builtin_offsetof (MonoDelegate, invoke_impl);
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = ((MonoInst*)call); ((MonoInst*)call)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = ((MonoInst*)call); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = ((MonoInst*)call); } } while (0);
># 2432 "method-to-ir.c"
>   do { do { do { (((dummy_use))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((dummy_use)))->data.op[0].const_val = (((dummy_use)))->data.op[1].const_val = 0; (((dummy_use)))->next = (((dummy_use)))->prev = ((void *)0); (((dummy_use)))->opcode = (OP_DUMMY_USE); (((dummy_use)))->flags = 0; (((dummy_use)))->type = 0; (((dummy_use)))->dreg = -1; do { ((((dummy_use))))->sreg1 = ((((dummy_use))))->sreg2 = ((((dummy_use))))->sreg3 = -1; } while (0); (((dummy_use)))->cil_code = (((cfg)))->ip; } while (0); ((dummy_use))->sreg1 = (args [0])->dreg; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((dummy_use)); ((dummy_use))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((dummy_use)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((dummy_use)); } } while (0); } while (0);
>
>   return (MonoInst*)call;
>  }
>
>
>  if ((!cfg->compile_aot || enable_for_aot) &&
>   (!(method->flags & 0x0040) ||
>    ((((method)->flags & 0x0020) || ((method)->klass && ((method)->klass->flags & 0x00000100))) &&
>     method->wrapper_type != MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)) &&
>   !(method->klass->marshalbyref && context_used)) {
>
>
>
>
>   if (method->klass->marshalbyref || method->klass == mono_defaults.object_class) {
>
>
>
>
>    method = call->method = mono_marshal_get_remoting_invoke_with_check (method);
>   }
>
>   if (!method->string_ctor)
>    do { cfg->flags |= MONO_CFG_HAS_CHECK_THIS; if (cfg->explicit_null_checks) { do { if (cfg->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (this_reg); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); } else { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_CHECK_THIS)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((this_reg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_NOT_NULL)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((this_reg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } while (0);
>
>   call->inst.opcode = callvirt_to_call (call->inst.opcode);
>  } else if ((method->flags & 0x0040) && (((method)->flags & 0x0020) || ((method)->klass && ((method)->klass->flags & 0x00000100)))) {
>
>
>
>
>
>   do { cfg->flags |= MONO_CFG_HAS_CHECK_THIS; if (cfg->explicit_null_checks) { do { if (cfg->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (this_reg); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); } else { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_CHECK_THIS)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((this_reg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_NOT_NULL)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((this_reg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } while (0);
>
>   call->inst.opcode = callvirt_to_call (call->inst.opcode);
>  } else {
>   call->inst.opcode = callvirt_to_call_membase (call->inst.opcode);
>
>   vtable_reg = alloc_preg (cfg);
>   do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((this_reg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = (((((OP_LOAD_MEMBASE))))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = (((((cfg)))))->ip; } while (0); ((inst))->dreg = ((((vtable_reg)))); ((inst))->sreg1 = ((((this_reg)))); ((inst))->data.op[0].const_val = ((((__builtin_offsetof (MonoObject, vtable))))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0);
>   if (method->klass->flags & 0x00000020) {
>    slot_reg = -1;
>
>    if (mono_use_imt) {
>     guint32 imt_slot = mono_method_get_imt_slot (method);
>     emit_imt_argument (cfg, call, imt_arg);
>     slot_reg = vtable_reg;
>     call->inst.data.op[0].const_val = ((gint32)imt_slot - 19) * 8;
>    }
>
>    if (slot_reg == -1) {
>     slot_reg = alloc_preg (cfg);
>     mini_emit_load_intf_reg_vtable (cfg, slot_reg, vtable_reg, method->klass);
>     call->inst.data.op[0].const_val = mono_method_get_vtable_index (method) * 8;
>    }
>   } else {
>    slot_reg = vtable_reg;
>    call->inst.data.op[0].const_val = __builtin_offsetof (MonoVTable, vtable) +
>     ((mono_method_get_vtable_index (method)) * (8));
>
>    if (imt_arg) {
>     do { if (!(mono_method_signature (method)->generic_param_count)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 2494, "mono_method_signature (method)->generic_param_count"); } while (0);
>     emit_imt_argument (cfg, call, imt_arg);
>    }
>
>   }
>
>   call->inst.sreg1 = slot_reg;
>   call->virtual = 1;
>  }
> }
>
> do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = ((MonoInst*)call); ((MonoInst*)call)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = ((MonoInst*)call); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = ((MonoInst*)call); } } while (0);
>
> if (rgctx_arg)
>  set_rgctx_arg (cfg, call, rgctx_reg, rgctx_arg);
>
> return (MonoInst*)call;
>}
>
>MonoInst*
>mono_emit_method_call (MonoCompile *cfg, MonoMethod *method, MonoInst **args, MonoInst *this)
>{
> return mono_emit_method_call_full (cfg, method, mono_method_signature (method), args, this, ((void *)0), ((void *)0));
>}
>
>MonoInst*
>mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig,
>        MonoInst **args)
>{
> MonoCallInst *call;
>
> do { if (!(sig)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 2525, "sig"); } while (0);
>
> call = mono_emit_call_args (cfg, sig, args, 0, 0, 0, 0);
> call->fptr = func;
>
> do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = ((MonoInst*)call); ((MonoInst*)call)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = ((MonoInst*)call); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = ((MonoInst*)call); } } while (0);
>
> return (MonoInst*)call;
>}
>
>MonoInst*
>mono_emit_jit_icall (MonoCompile *cfg, gconstpointer func, MonoInst **args)
>{
> MonoJitICallInfo *info = mono_find_jit_icall_by_addr (func);
>
> do { if (!(info)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 2540, "info"); } while (0);
>
> return mono_emit_native_call (cfg, mono_icall_get_wrapper (info), info->sig, args);
>}
>
>
>
>
>
>
>inline static MonoInst*
>mono_emit_abs_call (MonoCompile *cfg, MonoJumpInfoType patch_type, gconstpointer data,
>     MonoMethodSignature *sig, MonoInst **args)
>{
> MonoJumpInfo *ji = mono_patch_info_new (cfg->mempool, 0, patch_type, data);
> MonoInst *ins;
>
>
>
>
>
> if (cfg->abs_patches == ((void *)0))
>  cfg->abs_patches = monoeg_g_hash_table_new (((void *)0), ((void *)0));
> monoeg_g_hash_table_insert_replace ((cfg->abs_patches),(ji),(ji),0);
> ins = mono_emit_native_call (cfg, ji, sig, args);
> ((MonoCallInst*)ins)->fptr_is_patch = 1;
> return ins;
>}
>
>static MonoInst*
>mono_emit_widen_call_res (MonoCompile *cfg, MonoInst *ins, MonoMethodSignature *fsig)
>{
> if (!mono_type_is_void (fsig->ret)) {
>  if ((fsig->pinvoke || 0) && !fsig->ret->byref) {
>   int widen_op = -1;
>
>
>
>
>
>   switch (mono_type_to_load_membase (cfg, fsig->ret)) {
>   case OP_LOADI1_MEMBASE:
>    widen_op = OP_ICONV_TO_I1;
>    break;
>   case OP_LOADU1_MEMBASE:
>    widen_op = OP_ICONV_TO_U1;
>    break;
>   case OP_LOADI2_MEMBASE:
>    widen_op = OP_ICONV_TO_I2;
>    break;
>   case OP_LOADU2_MEMBASE:
>    widen_op = OP_ICONV_TO_U2;
>    break;
>   default:
>    break;
>   }
>
>   if (widen_op != -1) {
>    int dreg = alloc_preg (cfg);
>    MonoInst *widen;
>
>    do { do { do { (((widen))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((widen)))->data.op[0].const_val = (((widen)))->data.op[1].const_val = 0; (((widen)))->next = (((widen)))->prev = ((void *)0); (((widen)))->opcode = (((widen_op))); (((widen)))->flags = 0; (((widen)))->type = 0; (((widen)))->dreg = -1; do { ((((widen))))->sreg1 = ((((widen))))->sreg2 = ((((widen))))->sreg3 = -1; } while (0); (((widen)))->cil_code = (((cfg)))->ip; } while (0); ((widen))->dreg = (dreg); ((widen))->sreg1 = (ins->dreg); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((widen)); ((widen))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((widen)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((widen)); } } while (0); } while (0);
>    widen->type = ins->type;
>    ins = widen;
>   }
>  }
> }
>
> return ins;
>}
>
>static MonoMethod*
>get_memcpy_method (void)
>{
> static MonoMethod *memcpy_method = ((void *)0);
> if (!memcpy_method) {
>  memcpy_method = mono_class_get_method_from_name (mono_defaults.string_class, "memcpy", 3);
>  if (!memcpy_method)
>   do { monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "Old corlib found. Install a new one"); for (;;); } while (0);
> }
> return memcpy_method;
>}
>
>static void
>create_write_barrier_bitmap (MonoClass *klass, unsigned *wb_bitmap, int offset)
>{
> MonoClassField *field;
> gpointer iter = ((void *)0);
>
> while ((field = mono_class_get_fields (klass, &iter))) {
>  int foffset;
>
>  if (field->type->attrs & 0x0010)
>   continue;
>  foffset = klass->valuetype ? field->offset - sizeof (MonoObject): field->offset;
>  if (mono_type_is_reference (field->type)) {
>   do { if (!((foffset % 8) == 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 2636, "(foffset % SIZEOF_VOID_P) == 0"); } while (0);
>   *wb_bitmap |= 1 << ((offset + foffset) / 8);
>  } else {
>
>   MonoClass *field_class = mono_class_from_mono_type (field->type);
>   if (field_class->has_references)
>    create_write_barrier_bitmap (field_class, wb_bitmap, offset + foffset);
>  }
> }
>}
>
>static void
>emit_write_barrier (MonoCompile *cfg, MonoInst *ptr, MonoInst *value, int value_reg)
>{
> int card_table_shift_bits;
> gpointer card_table_mask;
> guint8 *card_table;
> MonoInst *dummy_use;
> int nursery_shift_bits;
> size_t nursery_size;
> gboolean has_card_table_wb = 0;
>
> if (!cfg->gen_write_barriers)
>  return;
>
> card_table = mono_gc_get_card_table (&card_table_shift_bits, &card_table_mask);
>
> mono_gc_get_nursery (&nursery_shift_bits, &nursery_size);
>
>
>
>
>
> if (has_card_table_wb && !cfg->compile_aot && card_table && nursery_shift_bits > 0) {
>  MonoInst *wbarrier;
>
>  do { (wbarrier) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (wbarrier)->data.op[0].const_val = (wbarrier)->data.op[1].const_val = 0; (wbarrier)->next = (wbarrier)->prev = ((void *)0); (wbarrier)->opcode = (OP_CARD_TABLE_WBARRIER); (wbarrier)->flags = 0; (wbarrier)->type = 0; (wbarrier)->dreg = -1; do { ((wbarrier))->sreg1 = ((wbarrier))->sreg2 = ((wbarrier))->sreg3 = -1; } while (0); (wbarrier)->cil_code = (cfg)->ip; } while (0);
>  wbarrier->sreg1 = ptr->dreg;
>  if (value)
>   wbarrier->sreg2 = value->dreg;
>  else
>   wbarrier->sreg2 = value_reg;
>  do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (wbarrier); (wbarrier)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (wbarrier); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (wbarrier); } } while (0);
> } else if (card_table) {
>  int offset_reg = alloc_preg (cfg);
>  int card_reg = alloc_preg (cfg);
>  MonoInst *ins;
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_SHR_UN_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = offset_reg; inst->sreg1 = ptr->dreg; inst->data.op[1].const_val = (mgreg_t)(card_table_shift_bits); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  if (card_table_mask)
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LAND_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = offset_reg; inst->sreg1 = offset_reg; inst->data.op[1].const_val = (mgreg_t)(card_table_mask); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>
>
>
>  if (cfg->compile_aot) {
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = card_reg; inst->data.op[0].p = ((void *)0); inst->data.op[1].const_val = MONO_PATCH_INFO_GC_CARD_TABLE_ADDR; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  } else {
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_I8CONST); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ins->data.op[0].p = card_table;
>   ins->dreg = card_reg;
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>  }
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LADD)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = offset_reg; inst->sreg1 = offset_reg; inst->sreg2 = card_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI1_MEMBASE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = offset_reg; inst->data.op[0].const_val = 0; inst->data.op[1].const_val = (mgreg_t)(1); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> } else {
>  MonoMethod *write_barrier = mono_gc_get_write_barrier ();
>  mono_emit_method_call (cfg, write_barrier, &ptr, ((void *)0));
> }
>
> if (value) {
>  do { do { do { (((dummy_use))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((dummy_use)))->data.op[0].const_val = (((dummy_use)))->data.op[1].const_val = 0; (((dummy_use)))->next = (((dummy_use)))->prev = ((void *)0); (((dummy_use)))->opcode = (OP_DUMMY_USE); (((dummy_use)))->flags = 0; (((dummy_use)))->type = 0; (((dummy_use)))->dreg = -1; do { ((((dummy_use))))->sreg1 = ((((dummy_use))))->sreg2 = ((((dummy_use))))->sreg3 = -1; } while (0); (((dummy_use)))->cil_code = (((cfg)))->ip; } while (0); ((dummy_use))->sreg1 = (value)->dreg; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((dummy_use)); ((dummy_use))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((dummy_use)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((dummy_use)); } } while (0); } while (0);
> } else {
>  do { (dummy_use) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (dummy_use)->data.op[0].const_val = (dummy_use)->data.op[1].const_val = 0; (dummy_use)->next = (dummy_use)->prev = ((void *)0); (dummy_use)->opcode = (OP_DUMMY_USE); (dummy_use)->flags = 0; (dummy_use)->type = 0; (dummy_use)->dreg = -1; do { ((dummy_use))->sreg1 = ((dummy_use))->sreg2 = ((dummy_use))->sreg3 = -1; } while (0); (dummy_use)->cil_code = (cfg)->ip; } while (0);
>  dummy_use->sreg1 = value_reg;
>  do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (dummy_use); (dummy_use)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (dummy_use); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (dummy_use); } } while (0);
> }
>}
>
>static gboolean
>mono_emit_wb_aware_memcpy (MonoCompile *cfg, MonoClass *klass, MonoInst *iargs[4], int size, int align)
>{
> int dest_ptr_reg, tmp_reg, destreg, srcreg, offset;
> unsigned need_wb = 0;
>
> if (align == 0)
>  align = 4;
>
>
> if (align < 8)
>  return 0;
>
>
> if (size > 32 * 8)
>  return 0;
>
> create_write_barrier_bitmap (klass, &need_wb, 0);
>
>
> if (size > 5 * 8) {
>
>  size += (8 - 1);
>  size &= ~(8 - 1);
>
>  do { do { do { (((iargs [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [2])))->data.op[0].const_val = (((iargs [2])))->data.op[1].const_val = 0; (((iargs [2])))->next = (((iargs [2])))->prev = ((void *)0); (((iargs [2])))->opcode = (OP_ICONST); (((iargs [2])))->flags = 0; (((iargs [2])))->type = 0; (((iargs [2])))->dreg = -1; do { ((((iargs [2]))))->sreg1 = ((((iargs [2]))))->sreg2 = ((((iargs [2]))))->sreg3 = -1; } while (0); (((iargs [2])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [2]))->data.op[0].const_val = ((size)); ((iargs [2]))->type = STACK_I4; ((iargs [2]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [2])); ((iargs [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [2])); } } while (0); } while (0);
>  do { do { do { (((iargs [3]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [3])))->data.op[0].const_val = (((iargs [3])))->data.op[1].const_val = 0; (((iargs [3])))->next = (((iargs [3])))->prev = ((void *)0); (((iargs [3])))->opcode = (OP_ICONST); (((iargs [3])))->flags = 0; (((iargs [3])))->type = 0; (((iargs [3])))->dreg = -1; do { ((((iargs [3]))))->sreg1 = ((((iargs [3]))))->sreg2 = ((((iargs [3]))))->sreg3 = -1; } while (0); (((iargs [3])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [3]))->data.op[0].const_val = ((need_wb)); ((iargs [3]))->type = STACK_I4; ((iargs [3]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [3])); ((iargs [3]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [3])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [3])); } } while (0); } while (0);
>  mono_emit_jit_icall (cfg, mono_gc_wbarrier_value_copy_bitmap, iargs);
>  return 1;
> }
>
> destreg = iargs [0]->dreg;
> srcreg = iargs [1]->dreg;
> offset = 0;
>
> dest_ptr_reg = alloc_preg (cfg);
> tmp_reg = alloc_preg (cfg);
>
>
> do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (((OP_MOVE))); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->dreg = (dest_ptr_reg); ((iargs [0]))->sreg1 = (destreg); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>
> while (size >= 8) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOAD_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = tmp_reg; inst->sreg1 = srcreg; inst->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI8_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = tmp_reg; (inst)->dreg = dest_ptr_reg; (inst)->data.op[0].const_val = 0; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>  if (need_wb & 0x1)
>   emit_write_barrier (cfg, iargs [0], ((void *)0), tmp_reg);
>
>  offset += 8;
>  size -= 8;
>  need_wb >>= 1;
>
>
>  if (size >= 8) {
>   do { do { ((iargs [0])) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((iargs [0]))->data.op[0].const_val = ((iargs [0]))->data.op[1].const_val = 0; ((iargs [0]))->next = ((iargs [0]))->prev = ((void *)0); ((iargs [0]))->opcode = ((OP_LADD_IMM)); ((iargs [0]))->flags = 0; ((iargs [0]))->type = 0; ((iargs [0]))->dreg = -1; do { (((iargs [0])))->sreg1 = (((iargs [0])))->sreg2 = (((iargs [0])))->sreg3 = -1; } while (0); ((iargs [0]))->cil_code = ((cfg))->ip; } while (0); (iargs [0])->dreg = dest_ptr_reg; (iargs [0])->sreg1 = dest_ptr_reg; (iargs [0])->data.op[1].const_val = (8); } while (0);
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (iargs [0]); (iargs [0])->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (iargs [0]); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (iargs [0]); } } while (0);
>  }
> }
>
>
> while (size >= 4) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI4_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = tmp_reg; inst->sreg1 = srcreg; inst->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI4_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = tmp_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  offset += 4;
>  size -= 4;
> }
>
> while (size >= 2) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI2_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = tmp_reg; inst->sreg1 = srcreg; inst->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI2_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = tmp_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  offset += 2;
>  size -= 2;
> }
>
> while (size >= 1) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI1_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = tmp_reg; inst->sreg1 = srcreg; inst->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI1_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = tmp_reg; (inst)->dreg = destreg; (inst)->data.op[0].const_val = offset; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  offset += 1;
>  size -= 1;
> }
>
> return 1;
>}
>
>
>
>
>
>void
>mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
>{
> MonoInst *iargs [4];
> int n;
> guint32 align = 0;
> MonoMethod *memcpy_method;
>
> do { if (!(klass)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 2812, "klass"); } while (0);
>
>
>
>
>
> if (native)
>  n = mono_class_native_size (klass, &align);
> else
>  n = mono_class_value_size (klass, &align);
>
>
> if (cfg->gen_write_barriers && klass->has_references && !native) {
>
>  if (!((dest->opcode == OP_ADD_IMM && dest->sreg1 == cfg->frame_reg) ||
>     (dest->opcode == OP_LDADDR))) {
>   int context_used = 0;
>
>   iargs [0] = dest;
>   iargs [1] = src;
>
>   if (cfg->generic_sharing_context)
>    context_used = mono_class_check_context_used (klass);
>
>
>   if ((cfg->opt & MONO_OPT_INTRINS) && mono_emit_wb_aware_memcpy (cfg, klass, iargs, n, align)) {
>    return;
>   } else if (context_used) {
>    iargs [2] = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
>   } else {
>    if (cfg->compile_aot) {
>     do { do { do { (((iargs [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [2])))->data.op[0].const_val = (((iargs [2])))->data.op[1].const_val = 0; (((iargs [2])))->next = (((iargs [2])))->prev = ((void *)0); (((iargs [2])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [2])))->flags = 0; (((iargs [2])))->type = 0; (((iargs [2])))->dreg = -1; do { ((((iargs [2]))))->sreg1 = ((((iargs [2]))))->sreg2 = ((((iargs [2]))))->sreg3 = -1; } while (0); (((iargs [2])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [2]))->data.op[0].p = ((klass)); ((iargs [2]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_CLASS); ((iargs [2]))->type = STACK_PTR; ((iargs [2]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [2])); ((iargs [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [2])); } } while (0); } while (0);
>    } else {
>     do { do { do { (((iargs [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [2])))->data.op[0].const_val = (((iargs [2])))->data.op[1].const_val = 0; (((iargs [2])))->next = (((iargs [2])))->prev = ((void *)0); (((iargs [2])))->opcode = (OP_I8CONST); (((iargs [2])))->flags = 0; (((iargs [2])))->type = 0; (((iargs [2])))->dreg = -1; do { ((((iargs [2]))))->sreg1 = ((((iargs [2]))))->sreg2 = ((((iargs [2]))))->sreg3 = -1; } while (0); (((iargs [2])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [2]))->data.op[0].p = ((klass)); ((iargs [2]))->type = STACK_PTR; ((iargs [2]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [2])); ((iargs [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [2])); } } while (0); } while (0);
>     mono_class_compute_gc_descriptor (klass);
>    }
>   }
>
>   mono_emit_jit_icall (cfg, mono_value_copy, iargs);
>   return;
>  }
> }
>
> if ((cfg->opt & MONO_OPT_INTRINS) && n <= sizeof (gpointer) * 5) {
>
>  mini_emit_memcpy (cfg, dest->dreg, 0, src->dreg, 0, n, align);
> } else {
>  iargs [0] = dest;
>  iargs [1] = src;
>  do { do { do { (((iargs [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [2])))->data.op[0].const_val = (((iargs [2])))->data.op[1].const_val = 0; (((iargs [2])))->next = (((iargs [2])))->prev = ((void *)0); (((iargs [2])))->opcode = (OP_ICONST); (((iargs [2])))->flags = 0; (((iargs [2])))->type = 0; (((iargs [2])))->dreg = -1; do { ((((iargs [2]))))->sreg1 = ((((iargs [2]))))->sreg2 = ((((iargs [2]))))->sreg3 = -1; } while (0); (((iargs [2])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [2]))->data.op[0].const_val = ((n)); ((iargs [2]))->type = STACK_I4; ((iargs [2]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [2])); ((iargs [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [2])); } } while (0); } while (0);
>
>  memcpy_method = get_memcpy_method ();
>  mono_emit_method_call (cfg, memcpy_method, iargs, ((void *)0));
> }
>}
>
>static MonoMethod*
>get_memset_method (void)
>{
> static MonoMethod *memset_method = ((void *)0);
> if (!memset_method) {
>  memset_method = mono_class_get_method_from_name (mono_defaults.string_class, "memset", 3);
>  if (!memset_method)
>   do { monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "Old corlib found. Install a new one"); for (;;); } while (0);
> }
> return memset_method;
>}
>
>void
>mini_emit_initobj (MonoCompile *cfg, MonoInst *dest, const guchar *ip, MonoClass *klass)
>{
> MonoInst *iargs [3];
> int n;
> guint32 align;
> MonoMethod *memset_method;
>
>
>
> mono_class_init (klass);
> n = mono_class_value_size (klass, &align);
>
> if (n <= sizeof (gpointer) * 5) {
>  mini_emit_memset (cfg, dest->dreg, 0, n, 0, align);
> }
> else {
>  memset_method = get_memset_method ();
>  iargs [0] = dest;
>  do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = (OP_ICONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].const_val = ((0)); ((iargs [1]))->type = STACK_I4; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>  do { do { do { (((iargs [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [2])))->data.op[0].const_val = (((iargs [2])))->data.op[1].const_val = 0; (((iargs [2])))->next = (((iargs [2])))->prev = ((void *)0); (((iargs [2])))->opcode = (OP_ICONST); (((iargs [2])))->flags = 0; (((iargs [2])))->type = 0; (((iargs [2])))->dreg = -1; do { ((((iargs [2]))))->sreg1 = ((((iargs [2]))))->sreg2 = ((((iargs [2]))))->sreg3 = -1; } while (0); (((iargs [2])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [2]))->data.op[0].const_val = ((n)); ((iargs [2]))->type = STACK_I4; ((iargs [2]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [2])); ((iargs [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [2])); } } while (0); } while (0);
>  mono_emit_method_call (cfg, memset_method, iargs, ((void *)0));
> }
>}
>
>static MonoInst*
>emit_get_rgctx (MonoCompile *cfg, MonoMethod *method, int context_used)
>{
> MonoInst *this = ((void *)0);
>
> do { if (!(cfg->generic_sharing_context)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 2910, "cfg->generic_sharing_context"); } while (0);
>
> if (!(method->flags & 0x0010) &&
>   !(context_used & MONO_GENERIC_CONTEXT_USED_METHOD) &&
>   !method->klass->valuetype)
>  do { do { do { ((((this)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((this))))->data.op[0].const_val = ((((this))))->data.op[1].const_val = 0; ((((this))))->next = ((((this))))->prev = ((void *)0); ((((this))))->opcode = (OP_MOVE); ((((this))))->flags = 0; ((((this))))->type = 0; ((((this))))->dreg = -1; do { (((((this)))))->sreg1 = (((((this)))))->sreg2 = (((((this)))))->sreg3 = -1; } while (0); ((((this))))->cil_code = ((((cfg))))->ip; } while (0); (((this)))->opcode = mono_type_to_regmove ((((cfg))), ((cfg)->arg_types [((0))])); type_to_eval_stack_type ((((cfg))), ((cfg)->arg_types [((0))]), (((this)))); (((this)))->klass = (cfg)->args [((0))]->klass; (((this)))->sreg1 = (cfg)->args [((0))]->dreg; (((this)))->dreg = alloc_dreg ((((cfg))), (((this)))->type); if ((((this)))->opcode == OP_VMOVE) (((this)))->klass = mono_class_from_mono_type (((cfg)->arg_types [((0))])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((this)); ((this))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((this)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((this)); } } while (0); } while (0);
>
> if (context_used & MONO_GENERIC_CONTEXT_USED_METHOD) {
>  MonoInst *mrgctx_loc, *mrgctx_var;
>
>  do { if (!(!this)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 2920, "!this"); } while (0);
>  do { if (!(method->is_inflated && mono_method_get_context (method)->method_inst)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 2921, "method->is_inflated && mono_method_get_context (method)->method_inst"); } while (0);
>
>  mrgctx_loc = mono_get_vtable_var (cfg);
>  do { do { do { ((((mrgctx_var)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((mrgctx_var))))->data.op[0].const_val = ((((mrgctx_var))))->data.op[1].const_val = 0; ((((mrgctx_var))))->next = ((((mrgctx_var))))->prev = ((void *)0); ((((mrgctx_var))))->opcode = (OP_MOVE); ((((mrgctx_var))))->flags = 0; ((((mrgctx_var))))->type = 0; ((((mrgctx_var))))->dreg = -1; do { (((((mrgctx_var)))))->sreg1 = (((((mrgctx_var)))))->sreg2 = (((((mrgctx_var)))))->sreg3 = -1; } while (0); ((((mrgctx_var))))->cil_code = ((((cfg))))->ip; } while (0); (((mrgctx_var)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((mrgctx_loc->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((mrgctx_loc->data.op[0].const_val))]->data.op[1].vtype), (((mrgctx_var)))); (((mrgctx_var)))->klass = ((cfg))->varinfo [((mrgctx_loc->data.op[0].const_val))]->klass; (((mrgctx_var)))->sreg1 = ((cfg))->varinfo [((mrgctx_loc->data.op[0].const_val))]->dreg; (((mrgctx_var)))->dreg = alloc_dreg ((((cfg))), (((mrgctx_var)))->type); if ((((mrgctx_var)))->opcode == OP_VMOVE) (((mrgctx_var)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((mrgctx_loc->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((mrgctx_var)); ((mrgctx_var))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((mrgctx_var)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((mrgctx_var)); } } while (0); } while (0);
>
>  return mrgctx_var;
> } else if (method->flags & 0x0010 || method->klass->valuetype) {
>  MonoInst *vtable_loc, *vtable_var;
>
>  do { if (!(!this)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 2930, "!this"); } while (0);
>
>  vtable_loc = mono_get_vtable_var (cfg);
>  do { do { do { ((((vtable_var)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((vtable_var))))->data.op[0].const_val = ((((vtable_var))))->data.op[1].const_val = 0; ((((vtable_var))))->next = ((((vtable_var))))->prev = ((void *)0); ((((vtable_var))))->opcode = (OP_MOVE); ((((vtable_var))))->flags = 0; ((((vtable_var))))->type = 0; ((((vtable_var))))->dreg = -1; do { (((((vtable_var)))))->sreg1 = (((((vtable_var)))))->sreg2 = (((((vtable_var)))))->sreg3 = -1; } while (0); ((((vtable_var))))->cil_code = ((((cfg))))->ip; } while (0); (((vtable_var)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((vtable_loc->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((vtable_loc->data.op[0].const_val))]->data.op[1].vtype), (((vtable_var)))); (((vtable_var)))->klass = ((cfg))->varinfo [((vtable_loc->data.op[0].const_val))]->klass; (((vtable_var)))->sreg1 = ((cfg))->varinfo [((vtable_loc->data.op[0].const_val))]->dreg; (((vtable_var)))->dreg = alloc_dreg ((((cfg))), (((vtable_var)))->type); if ((((vtable_var)))->opcode == OP_VMOVE) (((vtable_var)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((vtable_loc->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((vtable_var)); ((vtable_var))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((vtable_var)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((vtable_var)); } } while (0); } while (0);
>
>  if (method->is_inflated && mono_method_get_context (method)->method_inst) {
>   MonoInst *mrgctx_var = vtable_var;
>   int vtable_reg;
>
>   vtable_reg = alloc_preg (cfg);
>   do { do { do { (((vtable_var))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((vtable_var)))->data.op[0].const_val = (((vtable_var)))->data.op[1].const_val = 0; (((vtable_var)))->next = (((vtable_var)))->prev = ((void *)0); (((vtable_var)))->opcode = (((OP_LOAD_MEMBASE))); (((vtable_var)))->flags = 0; (((vtable_var)))->type = 0; (((vtable_var)))->dreg = -1; do { ((((vtable_var))))->sreg1 = ((((vtable_var))))->sreg2 = ((((vtable_var))))->sreg3 = -1; } while (0); (((vtable_var)))->cil_code = (((cfg)))->ip; } while (0); ((vtable_var))->dreg = ((vtable_reg)); ((vtable_var))->sreg1 = ((mrgctx_var->dreg)); ((vtable_var))->data.op[0].const_val = ((__builtin_offsetof (MonoMethodRuntimeGenericContext, class_vtable))); ((vtable_var))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((vtable_var)); ((vtable_var))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((vtable_var)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((vtable_var)); } } while (0); } while (0);
>   vtable_var->type = STACK_PTR;
>  }
>
>  return vtable_var;
> } else {
>  MonoInst *ins;
>  int vtable_reg;
>
>  vtable_reg = alloc_preg (cfg);
>  do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LOAD_MEMBASE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = ((vtable_reg)); ((ins))->sreg1 = ((this->dreg)); ((ins))->data.op[0].const_val = ((__builtin_offsetof (MonoObject, vtable))); ((ins))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>  return ins;
> }
>}
>
>static MonoJumpInfoRgctxEntry *
>mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, int info_type)
>{
> MonoJumpInfoRgctxEntry *res = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoRgctxEntry));
> res->method = method;
> res->in_mrgctx = in_mrgctx;
> res->data = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfo));
> res->data->type = patch_type;
> res->data->data.target = patch_data;
> res->info_type = info_type;
>
> return res;
>}
>
>static inline MonoInst*
>emit_rgctx_fetch (MonoCompile *cfg, MonoInst *rgctx, MonoJumpInfoRgctxEntry *entry)
>{
> return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
>}
>
>static MonoInst*
>emit_get_rgctx_klass (MonoCompile *cfg, int context_used,
>       MonoClass *klass, int rgctx_type)
>{
> MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_CLASS, klass, rgctx_type);
> MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
>
> return emit_rgctx_fetch (cfg, rgctx, entry);
>}
>
>
>
>
>
>
>
>static MonoInst*
>emit_get_rgctx_method (MonoCompile *cfg, int context_used,
>        MonoMethod *cmethod, int rgctx_type)
>{
> if (!context_used) {
>  MonoInst *ins;
>
>  switch (rgctx_type) {
>  case MONO_RGCTX_INFO_METHOD:
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((cmethod)); ((ins))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_METHODCONST); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   return ins;
>  case MONO_RGCTX_INFO_METHOD_RGCTX:
>   do { do { if ((cfg)->compile_aot) { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (((cfg))->compile_aot ? OP_AOTCONST : OP_I8CONST); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->data.op[0].p = (((cmethod))); (((ins)))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_METHOD_RGCTX); (((ins)))->type = STACK_PTR; (((ins)))->dreg = alloc_dreg ((((cfg))), STACK_PTR); } while (0); } else { MonoMethodRuntimeGenericContext *mrgctx; mrgctx = mono_method_lookup_rgctx (mono_class_vtable (((cfg))->domain, ((cmethod))->klass), mini_method_get_context (((cmethod)))->method_inst); do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_I8CONST); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->data.op[0].p = ((mrgctx)); (((ins)))->type = STACK_PTR; (((ins)))->dreg = alloc_dreg ((((cfg))), STACK_PTR); } while (0); } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   return ins;
>  default:
>   do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 3006); } while (0);
>  }
> } else {
>  MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_METHODCONST, cmethod, rgctx_type);
>  MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
>
>  return emit_rgctx_fetch (cfg, rgctx, entry);
> }
>}
>
>static MonoInst*
>emit_get_rgctx_field (MonoCompile *cfg, int context_used,
>       MonoClassField *field, int rgctx_type)
>{
> MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_FIELD, field, rgctx_type);
> MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
>
> return emit_rgctx_fetch (cfg, rgctx, entry);
>}
>
>
>
>
>static void
>emit_generic_class_init (MonoCompile *cfg, MonoClass *klass)
>{
> MonoInst *vtable_arg;
> MonoCallInst *call;
> int context_used = 0;
>
> if (cfg->generic_sharing_context)
>  context_used = mono_class_check_context_used (klass);
>
> if (context_used) {
>  vtable_arg = emit_get_rgctx_klass (cfg, context_used,
>             klass, MONO_RGCTX_INFO_VTABLE);
> } else {
>  MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
>
>  if (!vtable)
>   return;
>  do { do { do { (((vtable_arg))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((vtable_arg)))->data.op[0].const_val = (((vtable_arg)))->data.op[1].const_val = 0; (((vtable_arg)))->next = (((vtable_arg)))->prev = ((void *)0); (((vtable_arg)))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((vtable_arg)))->flags = 0; (((vtable_arg)))->type = 0; (((vtable_arg)))->dreg = -1; do { ((((vtable_arg))))->sreg1 = ((((vtable_arg))))->sreg2 = ((((vtable_arg))))->sreg3 = -1; } while (0); (((vtable_arg)))->cil_code = (((cfg)))->ip; } while (0); ((vtable_arg))->data.op[0].p = (cfg->compile_aot ? (gpointer)((vtable)->klass) : (vtable)); ((vtable_arg))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_VTABLE); ((vtable_arg))->type = STACK_PTR; ((vtable_arg))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((vtable_arg)); ((vtable_arg))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((vtable_arg)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((vtable_arg)); } } while (0); } while (0);
> }
>
> if ((0))
>  call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, ((void *)0), helper_sig_generic_class_init_trampoline_llvm, &vtable_arg);
> else
>  call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, ((void *)0), helper_sig_generic_class_init_trampoline, &vtable_arg);
>
>
>
>
> do { do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 3058); } while (0); } while (0);
>
>}
>
>static void
>save_cast_details (MonoCompile *cfg, MonoClass *klass, int obj_reg)
>{
> if (mini_get_debug_options ()->better_cast_details) {
>  int to_klass_reg = alloc_preg (cfg);
>  int vtable_reg = alloc_preg (cfg);
>  int klass_reg = alloc_preg (cfg);
>  MonoInst *tls_get = mono_get_jit_tls_intrinsic (cfg);
>
>  if (!tls_get) {
>   fprintf (stderr, "error: --debug=casts not supported on this platform.\n.");
>   exit (1);
>  }
>
>  do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (tls_get); (tls_get)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (tls_get); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (tls_get); } } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (vtable_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoObject, vtable)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (vtable_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STORE_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = klass_reg; (inst)->dreg = tls_get->dreg; (inst)->data.op[0].const_val = __builtin_offsetof (MonoJitTlsData, class_cast_from); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_I8CONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = to_klass_reg; (inst)->data.op[0].p = (klass); (inst)->type = STACK_PTR; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STORE_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = to_klass_reg; (inst)->dreg = tls_get->dreg; (inst)->data.op[0].const_val = __builtin_offsetof (MonoJitTlsData, class_cast_to); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> }
>}
>
>static void
>reset_cast_details (MonoCompile *cfg)
>{
>
> if (mini_get_debug_options ()->better_cast_details) {
>  MonoInst *tls_get = mono_get_jit_tls_intrinsic (cfg);
>
>  do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (tls_get); (tls_get)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (tls_get); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (tls_get); } } while (0);
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STORE_MEMBASE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = tls_get->dreg; inst->data.op[0].const_val = __builtin_offsetof (MonoJitTlsData, class_cast_from); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> }
>}
>
>
>
>
>static void
>mini_emit_check_array_type (MonoCompile *cfg, MonoInst *obj, MonoClass *array_class)
>{
> int vtable_reg = alloc_preg (cfg);
> int context_used = 0;
>
> if (cfg->generic_sharing_context)
>  context_used = mono_class_check_context_used (array_class);
>
> save_cast_details (cfg, array_class, obj->dreg);
>
> do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((obj->dreg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = (((((OP_LOAD_MEMBASE))))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = (((((cfg)))))->ip; } while (0); ((inst))->dreg = ((((vtable_reg)))); ((inst))->sreg1 = ((((obj->dreg)))); ((inst))->data.op[0].const_val = ((((__builtin_offsetof (MonoObject, vtable))))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0);
>
> if (cfg->opt & MONO_OPT_SHARED) {
>  int class_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (class_reg); inst->sreg1 = (vtable_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  if (cfg->compile_aot) {
>   int klass_reg = alloc_preg (cfg);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = klass_reg; inst->data.op[0].p = array_class; inst->data.op[1].const_val = MONO_PATCH_INFO_CLASS; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = class_reg; inst->sreg2 = klass_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  } else {
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = class_reg; inst->data.op[1].const_val = (mgreg_t)(array_class); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  }
> } else if (context_used) {
>  MonoInst *vtable_ins;
>
>  vtable_ins = emit_get_rgctx_klass (cfg, context_used, array_class, MONO_RGCTX_INFO_VTABLE);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = vtable_reg; inst->sreg2 = vtable_ins->dreg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> } else {
>  if (cfg->compile_aot) {
>   int vt_reg;
>   MonoVTable *vtable;
>
>   if (!(vtable = mono_class_vtable (cfg->domain, array_class)))
>    return;
>   vt_reg = alloc_preg (cfg);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (vt_reg); inst->data.op[0].p = (cfg)->compile_aot ? (gpointer)((vtable)->klass) : (vtable); inst->data.op[1].const_val = MONO_PATCH_INFO_VTABLE; do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = vtable_reg; inst->sreg2 = vt_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  } else {
>   MonoVTable *vtable;
>   if (!(vtable = mono_class_vtable (cfg->domain, array_class)))
>    return;
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = vtable_reg; inst->data.op[1].const_val = (mgreg_t)(vtable); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  }
> }
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_NE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"ArrayTypeMismatchException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
> reset_cast_details (cfg);
>}
>
>
>
>
>
>static MonoInst*
>handle_unbox_nullable (MonoCompile* cfg, MonoInst* val, MonoClass* klass, int context_used)
>{
> MonoMethod* method = mono_class_get_method_from_name (klass, "Unbox", 1);
>
> if (context_used) {
>  MonoInst *rgctx, *addr;
>
>
>
>
>  addr = emit_get_rgctx_method (cfg, context_used, method,
>           MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
>
>  rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
>
>  return mono_emit_calli (cfg, mono_method_signature (method), &val, addr, rgctx);
> } else {
>  return mono_emit_method_call (cfg, method, &val, ((void *)0));
> }
>}
>
>static MonoInst*
>handle_unbox (MonoCompile *cfg, MonoClass *klass, MonoInst **sp, int context_used)
>{
> MonoInst *add;
> int obj_reg;
> int vtable_reg = alloc_dreg (cfg ,STACK_PTR);
> int klass_reg = alloc_dreg (cfg ,STACK_PTR);
> int eclass_reg = alloc_dreg (cfg ,STACK_PTR);
> int rank_reg = alloc_dreg (cfg ,STACK_I4);
>
> obj_reg = sp [0]->dreg;
> do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((obj_reg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = (((((OP_LOAD_MEMBASE))))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = (((((cfg)))))->ip; } while (0); ((inst))->dreg = ((((vtable_reg)))); ((inst))->sreg1 = ((((obj_reg)))); ((inst))->data.op[0].const_val = ((((__builtin_offsetof (MonoObject, vtable))))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADU1_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = rank_reg; inst->sreg1 = vtable_reg; inst->data.op[0].const_val = __builtin_offsetof (MonoVTable, rank); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>
> do { if (!(klass->rank == 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 3194, "klass->rank == 0"); } while (0);
>
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = rank_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_NE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"InvalidCastException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (vtable_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (eclass_reg); inst->sreg1 = (klass_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoClass, element_class)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
> if (context_used) {
>  MonoInst *element_class;
>
>
>  do { if (!(klass->rank == 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 3207, "klass->rank == 0"); } while (0);
>
>  element_class = emit_get_rgctx_klass (cfg, context_used,
>    klass->element_class, MONO_RGCTX_INFO_KLASS);
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = eclass_reg; inst->sreg2 = element_class->dreg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_NE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"InvalidCastException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> } else {
>  save_cast_details (cfg, klass->element_class, obj_reg);
>  mini_emit_class_check (cfg, eclass_reg, klass->element_class);
>  reset_cast_details (cfg);
> }
>
> do { do { ((add)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((add))->data.op[0].const_val = ((add))->data.op[1].const_val = 0; ((add))->next = ((add))->prev = ((void *)0); ((add))->opcode = ((OP_ADD_IMM)); ((add))->flags = 0; ((add))->type = 0; ((add))->dreg = -1; do { (((add)))->sreg1 = (((add)))->sreg2 = (((add)))->sreg3 = -1; } while (0); ((add))->cil_code = ((cfg))->ip; } while (0); (add)->dreg = alloc_dreg (cfg, STACK_MP); (add)->sreg1 = obj_reg; (add)->data.op[1].const_val = (sizeof (MonoObject)); } while (0);
> do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (add); (add)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (add); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (add); } } while (0);
> add->type = STACK_MP;
> add->klass = klass;
>
> return add;
>}
>
>
>
>
>static MonoInst*
>handle_alloc (MonoCompile *cfg, MonoClass *klass, gboolean for_box, int context_used)
>{
> MonoInst *iargs [2];
> void *alloc_ftn;
>
> if (context_used) {
>  MonoInst *data;
>  int rgctx_info;
>  MonoInst *iargs [2];
># 3250 "method-to-ir.c"
>  if (cfg->opt & MONO_OPT_SHARED)
>   rgctx_info = MONO_RGCTX_INFO_KLASS;
>  else
>   rgctx_info = MONO_RGCTX_INFO_VTABLE;
>  data = emit_get_rgctx_klass (cfg, context_used, klass, rgctx_info);
>
>  if (cfg->opt & MONO_OPT_SHARED) {
>   do { do { if (((cfg)->opt & MONO_OPT_SHARED) || (cfg)->compile_aot) { MonoInst* __domain_var = mono_get_domainvar ((cfg)); do { do { ((((iargs [0])))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((iargs [0]))))->data.op[0].const_val = ((((iargs [0]))))->data.op[1].const_val = 0; ((((iargs [0]))))->next = ((((iargs [0]))))->prev = ((void *)0); ((((iargs [0]))))->opcode = (OP_MOVE); ((((iargs [0]))))->flags = 0; ((((iargs [0]))))->type = 0; ((((iargs [0]))))->dreg = -1; do { (((((iargs [0])))))->sreg1 = (((((iargs [0])))))->sreg2 = (((((iargs [0])))))->sreg3 = -1; } while (0); ((((iargs [0]))))->cil_code = ((((cfg))))->ip; } while (0); (((iargs [0])))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype), (((iargs [0])))); (((iargs [0])))->klass = ((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->klass; (((iargs [0])))->sreg1 = ((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->dreg; (((iargs [0])))->dreg = alloc_dreg ((((cfg))), (((iargs [0])))->type); if ((((iargs [0])))->opcode == OP_VMOVE) (((iargs [0])))->klass = mono_class_from_mono_type ((((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); } while (0); } else { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_I8CONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].p = (((cfg))->domain); ((iargs [0]))->type = STACK_PTR; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>   iargs [1] = data;
>   alloc_ftn = mono_object_new;
>  } else {
>   iargs [0] = data;
>   alloc_ftn = mono_object_new_specific;
>  }
>
>  return mono_emit_jit_icall (cfg, alloc_ftn, iargs);
> }
>
> if (cfg->opt & MONO_OPT_SHARED) {
>  do { do { if (((cfg)->opt & MONO_OPT_SHARED) || (cfg)->compile_aot) { MonoInst* __domain_var = mono_get_domainvar ((cfg)); do { do { ((((iargs [0])))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((iargs [0]))))->data.op[0].const_val = ((((iargs [0]))))->data.op[1].const_val = 0; ((((iargs [0]))))->next = ((((iargs [0]))))->prev = ((void *)0); ((((iargs [0]))))->opcode = (OP_MOVE); ((((iargs [0]))))->flags = 0; ((((iargs [0]))))->type = 0; ((((iargs [0]))))->dreg = -1; do { (((((iargs [0])))))->sreg1 = (((((iargs [0])))))->sreg2 = (((((iargs [0])))))->sreg3 = -1; } while (0); ((((iargs [0]))))->cil_code = ((((cfg))))->ip; } while (0); (((iargs [0])))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype), (((iargs [0])))); (((iargs [0])))->klass = ((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->klass; (((iargs [0])))->sreg1 = ((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->dreg; (((iargs [0])))->dreg = alloc_dreg ((((cfg))), (((iargs [0])))->type); if ((((iargs [0])))->opcode == OP_VMOVE) (((iargs [0])))->klass = mono_class_from_mono_type ((((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); } while (0); } else { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_I8CONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].p = (((cfg))->domain); ((iargs [0]))->type = STACK_PTR; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>  do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].p = ((klass)); ((iargs [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_CLASS); ((iargs [1]))->type = STACK_PTR; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>
>  alloc_ftn = mono_object_new;
> } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
>
>
>  do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_ICONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].const_val = ((((klass->type_token & 0xffffff)))); ((iargs [0]))->type = STACK_I4; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>  return mono_emit_jit_icall (cfg, mono_helper_newobj_mscorlib, iargs);
> } else {
>  MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
>  MonoMethod *managed_alloc = ((void *)0);
>  gboolean pass_lw;
>
>  if (!vtable) {
>   mono_cfg_set_exception (cfg, MONO_EXCEPTION_TYPE_LOAD);
>   cfg->exception_ptr = klass;
>   return ((void *)0);
>  }
>
>
>  managed_alloc = mono_gc_get_managed_allocator (vtable, for_box);
>
>
>  if (managed_alloc) {
>   do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].p = (cfg->compile_aot ? (gpointer)((vtable)->klass) : (vtable)); ((iargs [0]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_VTABLE); ((iargs [0]))->type = STACK_PTR; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>   return mono_emit_method_call (cfg, managed_alloc, iargs, ((void *)0));
>  }
>  alloc_ftn = mono_class_get_allocation_ftn (vtable, for_box, &pass_lw);
>  if (pass_lw) {
>   guint32 lw = vtable->klass->instance_size;
>   lw = ((lw + (sizeof (gpointer) - 1)) & ~(sizeof (gpointer) - 1)) / sizeof (gpointer);
>   do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_ICONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].const_val = ((lw)); ((iargs [0]))->type = STACK_I4; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>   do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].p = (cfg->compile_aot ? (gpointer)((vtable)->klass) : (vtable)); ((iargs [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_VTABLE); ((iargs [1]))->type = STACK_PTR; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>  }
>  else {
>   do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].p = (cfg->compile_aot ? (gpointer)((vtable)->klass) : (vtable)); ((iargs [0]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_VTABLE); ((iargs [0]))->type = STACK_PTR; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>  }
> }
>
> return mono_emit_jit_icall (cfg, alloc_ftn, iargs);
>}
>
>
>
>
>static MonoInst*
>handle_box (MonoCompile *cfg, MonoInst *val, MonoClass *klass, int context_used)
>{
> MonoInst *alloc, *ins;
>
> if (mono_class_is_nullable (klass)) {
>  MonoMethod* method = mono_class_get_method_from_name (klass, "Box", 1);
>
>  if (context_used) {
>
>
>   MonoInst *addr = emit_get_rgctx_method (cfg, context_used, method,
>             MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
>   MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
>
>   return mono_emit_calli (cfg, mono_method_signature (method), &val, addr, rgctx);
>  } else {
>   return mono_emit_method_call (cfg, method, &val, ((void *)0));
>  }
> }
>
> alloc = handle_alloc (cfg, klass, 1, context_used);
> if (!alloc)
>  return ((void *)0);
>
> do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (mono_type_to_store_membase (((cfg)), ((&klass->byval_arg)))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->sreg1 = (val->dreg); ((ins))->dreg = (alloc->dreg); ((ins))->data.op[0].const_val = (sizeof (MonoObject)); type_to_eval_stack_type (((cfg)), ((&klass->byval_arg)), ((ins))); ((ins))->klass = mono_class_from_mono_type ((&klass->byval_arg)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>
> return alloc;
>}
>
>
>static gboolean
>mini_class_has_reference_variant_generic_argument (MonoClass *klass, int context_used)
>{
> int i;
> MonoGenericContainer *container;
> MonoGenericInst *ginst;
>
> if (klass->generic_class) {
>  container = klass->generic_class->container_class->generic_container;
>  ginst = klass->generic_class->context.class_inst;
> } else if (klass->generic_container && context_used) {
>  container = klass->generic_container;
>  ginst = container->context.class_inst;
> } else {
>  return 0;
> }
>
> for (i = 0; i < container->type_argc; ++i) {
>  MonoType *type;
>  if (!((&((container)->type_params + (i))->info)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT)))
>   continue;
>  type = ginst->type_argv [i];
>  if (mono_type_is_reference (type))
>   return 1;
>
>  if (context_used && (type->type == MONO_TYPE_VAR || type->type == MONO_TYPE_MVAR))
>   return 1;
> }
> return 0;
>}
>
>
>
>
>
>
>
>static MonoInst*
>handle_castclass (MonoCompile *cfg, MonoClass *klass, MonoInst *src, int context_used)
>{
> MonoBasicBlock *is_null_bb;
> int obj_reg = src->dreg;
> int vtable_reg = alloc_preg (cfg);
> MonoInst *klass_inst = ((void *)0);
>
> if (context_used) {
>  MonoInst *args [3];
>
>  if(mini_class_has_reference_variant_generic_argument (klass, context_used)) {
>   MonoMethod *mono_castclass = mono_marshal_get_castclass_with_cache ();
>   MonoInst *cache_ins;
>
>   cache_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_CAST_CACHE);
>
>
>   args [0] = src;
>
>
>   do { do { do { (((args [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [1])))->data.op[0].const_val = (((args [1])))->data.op[1].const_val = 0; (((args [1])))->next = (((args [1])))->prev = ((void *)0); (((args [1])))->opcode = (((OP_LOAD_MEMBASE))); (((args [1])))->flags = 0; (((args [1])))->type = 0; (((args [1])))->dreg = -1; do { ((((args [1]))))->sreg1 = ((((args [1]))))->sreg2 = ((((args [1]))))->sreg3 = -1; } while (0); (((args [1])))->cil_code = (((cfg)))->ip; } while (0); ((args [1]))->dreg = ((alloc_preg (cfg))); ((args [1]))->sreg1 = ((cache_ins->dreg)); ((args [1]))->data.op[0].const_val = ((sizeof (gpointer))); ((args [1]))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [1])); ((args [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [1])); } } while (0); } while (0);
>
>
>   args [2] = cache_ins;
>
>   return mono_emit_method_call (cfg, mono_castclass, args, ((void *)0));
>  }
>
>  klass_inst = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
>
>  if ((1 || (klass->flags & 0x00000020) || klass->rank || mono_class_is_nullable (klass) || klass->marshalbyref || (klass->flags & 0x00000100) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR)) {
>
>
>
>   args [0] = src;
>
>
>   args [1] = klass_inst;
>
>   return mono_emit_jit_icall (cfg, mono_object_castclass, args);
>  } else {
>
>  }
> }
>
> do { (is_null_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (is_null_bb)->block_num = cfg->num_bblocks++; } while (0);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = obj_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBEQ)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBEQ) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (is_null_bb); mono_link_bblock ((cfg), (cfg)->cbb, (is_null_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (is_null_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (is_null_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
> save_cast_details (cfg, klass, obj_reg);
>
> if (klass->flags & 0x00000020) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (vtable_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoObject, vtable)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  mini_emit_iface_cast (cfg, vtable_reg, klass, ((void *)0), ((void *)0));
> } else {
>  int klass_reg = alloc_preg (cfg);
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (vtable_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoObject, vtable)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>  if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & 0x00000100)) {
>
>   if (0) {
>    MonoVTable *vt = mono_class_vtable (cfg->domain, klass);
>    if (!vt) {
>     mono_cfg_set_exception (cfg, MONO_EXCEPTION_TYPE_LOAD);
>     cfg->exception_ptr = klass;
>     return ((void *)0);
>    }
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = vtable_reg; inst->data.op[1].const_val = (mgreg_t)(vt); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   } else {
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (vtable_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = klass_reg; inst->data.op[1].const_val = (mgreg_t)(klass); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   }
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_NE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"InvalidCastException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  } else {
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (vtable_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   mini_emit_castclass_inst (cfg, obj_reg, klass_reg, klass, klass_inst, is_null_bb);
>  }
> }
>
> do { do { if (((is_null_bb))->cil_code) { (cfg)->cil_offset_to_bb [((is_null_bb))->cil_code - (cfg)->cil_start] = ((is_null_bb)); } ((is_null_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (is_null_bb); mono_link_bblock ((cfg), (cfg)->cbb, (is_null_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (is_null_bb)); (cfg)->cbb->next_bb = (is_null_bb); (cfg)->cbb = (is_null_bb); } while (0);
>
> reset_cast_details (cfg);
>
> return src;
>}
>
>
>
>
>static MonoInst*
>handle_isinst (MonoCompile *cfg, MonoClass *klass, MonoInst *src, int context_used)
>{
> MonoInst *ins;
> MonoBasicBlock *is_null_bb, *false_bb, *end_bb;
> int obj_reg = src->dreg;
> int vtable_reg = alloc_preg (cfg);
> int res_reg = alloc_ireg_ref (cfg);
> MonoInst *klass_inst = ((void *)0);
>
> if (context_used) {
>  MonoInst *args [3];
>
>  if(mini_class_has_reference_variant_generic_argument (klass, context_used)) {
>   MonoMethod *mono_isinst = mono_marshal_get_isinst_with_cache ();
>   MonoInst *cache_ins;
>
>   cache_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_CAST_CACHE);
>
>
>   args [0] = src;
>
>
>   do { do { do { (((args [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [1])))->data.op[0].const_val = (((args [1])))->data.op[1].const_val = 0; (((args [1])))->next = (((args [1])))->prev = ((void *)0); (((args [1])))->opcode = (((OP_LOAD_MEMBASE))); (((args [1])))->flags = 0; (((args [1])))->type = 0; (((args [1])))->dreg = -1; do { ((((args [1]))))->sreg1 = ((((args [1]))))->sreg2 = ((((args [1]))))->sreg3 = -1; } while (0); (((args [1])))->cil_code = (((cfg)))->ip; } while (0); ((args [1]))->dreg = ((alloc_preg (cfg))); ((args [1]))->sreg1 = ((cache_ins->dreg)); ((args [1]))->data.op[0].const_val = ((sizeof (gpointer))); ((args [1]))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [1])); ((args [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [1])); } } while (0); } while (0);
>
>
>   args [2] = cache_ins;
>
>   return mono_emit_method_call (cfg, mono_isinst, args, ((void *)0));
>  }
>
>  klass_inst = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
>
>  if ((1 || (klass->flags & 0x00000020) || klass->rank || mono_class_is_nullable (klass) || klass->marshalbyref || (klass->flags & 0x00000100) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR)) {
>
>
>
>   args [0] = src;
>
>
>   args [1] = klass_inst;
>
>   return mono_emit_jit_icall (cfg, mono_object_isinst, args);
>  } else {
>
>  }
> }
>
> do { (is_null_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (is_null_bb)->block_num = cfg->num_bblocks++; } while (0);
> do { (false_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (false_bb)->block_num = cfg->num_bblocks++; } while (0);
> do { (end_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (end_bb)->block_num = cfg->num_bblocks++; } while (0);
>
>
> do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_MOVE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = (res_reg); ((ins))->sreg1 = (obj_reg); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
> ins->type = STACK_OBJ;
> ins->klass = klass;
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = obj_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_IBEQ)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_IBEQ) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (is_null_bb); mono_link_bblock ((cfg), (cfg)->cbb, (is_null_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (is_null_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (is_null_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (vtable_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoObject, vtable)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
> if (klass->flags & 0x00000020) {
>  do { if (!(!context_used)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 3538, "!context_used"); } while (0);
>
>  mini_emit_iface_cast (cfg, vtable_reg, klass, false_bb, is_null_bb);
> } else {
>  int klass_reg = alloc_preg (cfg);
>
>  if (klass->rank) {
>   int rank_reg = alloc_preg (cfg);
>   int eclass_reg = alloc_preg (cfg);
>
>   do { if (!(!context_used)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 3548, "!context_used"); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADU1_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = rank_reg; inst->sreg1 = vtable_reg; inst->data.op[0].const_val = __builtin_offsetof (MonoVTable, rank); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = rank_reg; inst->data.op[1].const_val = (mgreg_t)(klass->rank); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBNE_UN)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBNE_UN) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (false_bb); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (false_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (vtable_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (eclass_reg); inst->sreg1 = (klass_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoClass, cast_class)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   if (klass->cast_class == mono_defaults.object_class) {
>    int parent_reg = alloc_preg (cfg);
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (parent_reg); inst->sreg1 = (eclass_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoClass, parent)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>    mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_LBNE_UN, is_null_bb);
>    mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class, OP_LBEQ, is_null_bb);
>    do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_BR)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_BR) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (false_bb); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (false_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>   } else if (klass->cast_class == mono_defaults.enum_class->parent) {
>    mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_LBEQ, is_null_bb);
>    mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class, OP_LBEQ, is_null_bb);
>    do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_BR)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_BR) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (false_bb); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (false_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>   } else if (klass->cast_class == mono_defaults.enum_class) {
>    mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class, OP_LBEQ, is_null_bb);
>    do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_BR)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_BR) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (false_bb); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (false_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>   } else if (klass->cast_class->flags & 0x00000020) {
>    mini_emit_iface_class_cast (cfg, eclass_reg, klass->cast_class, false_bb, is_null_bb);
>   } else {
>    if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY)) {
>
>     int bounds_reg = alloc_preg (cfg);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (bounds_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoArray, bounds)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = bounds_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>     do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBNE_UN)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBNE_UN) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (false_bb); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (false_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>    }
>
>
>    mini_emit_isninst_cast (cfg, eclass_reg, klass->cast_class, false_bb, is_null_bb);
>   }
>  } else if (mono_class_is_nullable (klass)) {
>   do { if (!(!context_used)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 3582, "!context_used"); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (vtable_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>   mini_emit_isninst_cast (cfg, klass_reg, klass->cast_class, false_bb, is_null_bb);
>  } else {
>   if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & 0x00000100)) {
>    do { if (!(!context_used)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 3588, "!context_used"); } while (0);
>
>    if (0) {
>     MonoVTable *vt = mono_class_vtable (cfg->domain, klass);
>     if (!vt) {
>      mono_cfg_set_exception (cfg, MONO_EXCEPTION_TYPE_LOAD);
>      cfg->exception_ptr = klass;
>      return ((void *)0);
>     }
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = vtable_reg; inst->data.op[1].const_val = (mgreg_t)(vt); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>    } else {
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (vtable_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = klass_reg; inst->data.op[1].const_val = (mgreg_t)(klass); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>    }
>    do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBNE_UN)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBNE_UN) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (false_bb); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (false_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>    do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_BR)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_BR) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (is_null_bb); mono_link_bblock ((cfg), (cfg)->cbb, (is_null_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (is_null_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (is_null_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>   } else {
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (vtable_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>    mini_emit_isninst_cast_inst (cfg, klass_reg, klass, klass_inst, false_bb, is_null_bb);
>   }
>  }
> }
>
> do { do { if (((false_bb))->cil_code) { (cfg)->cil_offset_to_bb [((false_bb))->cil_code - (cfg)->cil_start] = ((false_bb)); } ((false_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (false_bb); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); (cfg)->cbb->next_bb = (false_bb); (cfg)->cbb = (false_bb); } while (0);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_I8CONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = res_reg; (inst)->data.op[0].p = (0); (inst)->type = STACK_PTR; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_BR)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_BR) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (end_bb); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (end_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
> do { do { if (((is_null_bb))->cil_code) { (cfg)->cil_offset_to_bb [((is_null_bb))->cil_code - (cfg)->cil_start] = ((is_null_bb)); } ((is_null_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (is_null_bb); mono_link_bblock ((cfg), (cfg)->cbb, (is_null_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (is_null_bb)); (cfg)->cbb->next_bb = (is_null_bb); (cfg)->cbb = (is_null_bb); } while (0);
>
> do { do { if (((end_bb))->cil_code) { (cfg)->cil_offset_to_bb [((end_bb))->cil_code - (cfg)->cil_start] = ((end_bb)); } ((end_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (end_bb); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); (cfg)->cbb->next_bb = (end_bb); (cfg)->cbb = (end_bb); } while (0);
>
> return ins;
>}
>
>static MonoInst*
>handle_cisinst (MonoCompile *cfg, MonoClass *klass, MonoInst *src)
>{
>
>
>
>
>
> MonoInst *ins;
> MonoBasicBlock *true_bb, *false_bb, *false2_bb, *end_bb, *no_proxy_bb, *interface_fail_bb;
> int obj_reg = src->dreg;
> int dreg = alloc_ireg (cfg);
> int tmp_reg;
> int klass_reg = alloc_preg (cfg);
>
> do { (true_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (true_bb)->block_num = cfg->num_bblocks++; } while (0);
> do { (false_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (false_bb)->block_num = cfg->num_bblocks++; } while (0);
> do { (false2_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (false2_bb)->block_num = cfg->num_bblocks++; } while (0);
> do { (end_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (end_bb)->block_num = cfg->num_bblocks++; } while (0);
> do { (no_proxy_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (no_proxy_bb)->block_num = cfg->num_bblocks++; } while (0);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = obj_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBEQ)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBEQ) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (false_bb); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (false_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
> if (klass->flags & 0x00000020) {
>  do { (interface_fail_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (interface_fail_bb)->block_num = cfg->num_bblocks++; } while (0);
>
>  tmp_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (tmp_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoObject, vtable)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  mini_emit_iface_cast (cfg, tmp_reg, klass, interface_fail_bb, true_bb);
>  do { do { if (((interface_fail_bb))->cil_code) { (cfg)->cil_offset_to_bb [((interface_fail_bb))->cil_code - (cfg)->cil_start] = ((interface_fail_bb)); } ((interface_fail_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (interface_fail_bb); mono_link_bblock ((cfg), (cfg)->cbb, (interface_fail_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (interface_fail_bb)); (cfg)->cbb->next_bb = (interface_fail_bb); (cfg)->cbb = (interface_fail_bb); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (tmp_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>  mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_LBNE_UN, false_bb);
>
>  tmp_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (tmp_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoTransparentProxy, custom_type_info)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = tmp_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBNE_UN)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBNE_UN) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (false2_bb); mono_link_bblock ((cfg), (cfg)->cbb, (false2_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (false2_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (false2_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
> } else {
>  tmp_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (tmp_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoObject, vtable)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (tmp_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>  mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_LBNE_UN, no_proxy_bb);
>  tmp_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (tmp_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoTransparentProxy, remote_class)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (tmp_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoRemoteClass, proxy_class)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>  tmp_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (tmp_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoTransparentProxy, custom_type_info)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = tmp_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBEQ)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBEQ) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (no_proxy_bb); mono_link_bblock ((cfg), (cfg)->cbb, (no_proxy_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (no_proxy_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (no_proxy_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
>  mini_emit_isninst_cast (cfg, klass_reg, klass, false2_bb, true_bb);
>  do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_BR)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_BR) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (false2_bb); mono_link_bblock ((cfg), (cfg)->cbb, (false2_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (false2_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (false2_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
>  do { do { if (((no_proxy_bb))->cil_code) { (cfg)->cil_offset_to_bb [((no_proxy_bb))->cil_code - (cfg)->cil_start] = ((no_proxy_bb)); } ((no_proxy_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (no_proxy_bb); mono_link_bblock ((cfg), (cfg)->cbb, (no_proxy_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (no_proxy_bb)); (cfg)->cbb->next_bb = (no_proxy_bb); (cfg)->cbb = (no_proxy_bb); } while (0);
>
>  mini_emit_isninst_cast (cfg, klass_reg, klass, false_bb, true_bb);
> }
>
> do { do { if (((false_bb))->cil_code) { (cfg)->cil_offset_to_bb [((false_bb))->cil_code - (cfg)->cil_start] = ((false_bb)); } ((false_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (false_bb); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); (cfg)->cbb->next_bb = (false_bb); (cfg)->cbb = (false_bb); } while (0);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_ICONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = dreg; inst->data.op[0].const_val = 1; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_BR)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_BR) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (end_bb); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (end_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
> do { do { if (((false2_bb))->cil_code) { (cfg)->cil_offset_to_bb [((false2_bb))->cil_code - (cfg)->cil_start] = ((false2_bb)); } ((false2_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (false2_bb); mono_link_bblock ((cfg), (cfg)->cbb, (false2_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (false2_bb)); (cfg)->cbb->next_bb = (false2_bb); (cfg)->cbb = (false2_bb); } while (0);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_ICONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = dreg; inst->data.op[0].const_val = 2; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_BR)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_BR) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (end_bb); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (end_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
> do { do { if (((true_bb))->cil_code) { (cfg)->cil_offset_to_bb [((true_bb))->cil_code - (cfg)->cil_start] = ((true_bb)); } ((true_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (true_bb); mono_link_bblock ((cfg), (cfg)->cbb, (true_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (true_bb)); (cfg)->cbb->next_bb = (true_bb); (cfg)->cbb = (true_bb); } while (0);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_ICONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = dreg; inst->data.op[0].const_val = 0; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
> do { do { if (((end_bb))->cil_code) { (cfg)->cil_offset_to_bb [((end_bb))->cil_code - (cfg)->cil_start] = ((end_bb)); } ((end_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (end_bb); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); (cfg)->cbb->next_bb = (end_bb); (cfg)->cbb = (end_bb); } while (0);
>
>
> do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_ICONST); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
> ins->dreg = dreg;
> ins->type = STACK_I4;
>
> return ins;
>}
>
>static MonoInst*
>handle_ccastclass (MonoCompile *cfg, MonoClass *klass, MonoInst *src)
>{
>
>
>
>
>
> MonoInst *ins;
> MonoBasicBlock *end_bb, *ok_result_bb, *no_proxy_bb, *interface_fail_bb, *fail_1_bb;
> int obj_reg = src->dreg;
> int dreg = alloc_ireg (cfg);
> int tmp_reg = alloc_preg (cfg);
> int klass_reg = alloc_preg (cfg);
>
> do { (end_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (end_bb)->block_num = cfg->num_bblocks++; } while (0);
> do { (ok_result_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (ok_result_bb)->block_num = cfg->num_bblocks++; } while (0);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = obj_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBEQ)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBEQ) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (ok_result_bb); mono_link_bblock ((cfg), (cfg)->cbb, (ok_result_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (ok_result_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (ok_result_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
> save_cast_details (cfg, klass, obj_reg);
>
> if (klass->flags & 0x00000020) {
>  do { (interface_fail_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (interface_fail_bb)->block_num = cfg->num_bblocks++; } while (0);
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (tmp_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoObject, vtable)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  mini_emit_iface_cast (cfg, tmp_reg, klass, interface_fail_bb, ok_result_bb);
>  do { do { if (((interface_fail_bb))->cil_code) { (cfg)->cil_offset_to_bb [((interface_fail_bb))->cil_code - (cfg)->cil_start] = ((interface_fail_bb)); } ((interface_fail_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (interface_fail_bb); mono_link_bblock ((cfg), (cfg)->cbb, (interface_fail_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (interface_fail_bb)); (cfg)->cbb->next_bb = (interface_fail_bb); (cfg)->cbb = (interface_fail_bb); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (tmp_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>  mini_emit_class_check (cfg, klass_reg, mono_defaults.transparent_proxy_class);
>
>  tmp_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (tmp_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoTransparentProxy, custom_type_info)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = tmp_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"InvalidCastException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_ICONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = dreg; inst->data.op[0].const_val = 1; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_BR)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_BR) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (end_bb); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (end_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
> } else {
>  do { (no_proxy_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (no_proxy_bb)->block_num = cfg->num_bblocks++; } while (0);
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (tmp_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoObject, vtable)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (tmp_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoVTable, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_LBNE_UN, no_proxy_bb);
>
>  tmp_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (tmp_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoTransparentProxy, remote_class)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (tmp_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoRemoteClass, proxy_class)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>  tmp_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (tmp_reg); inst->sreg1 = (obj_reg); inst->data.op[0].const_val = (__builtin_offsetof (MonoTransparentProxy, custom_type_info)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = tmp_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBEQ)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBEQ) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (no_proxy_bb); mono_link_bblock ((cfg), (cfg)->cbb, (no_proxy_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (no_proxy_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (no_proxy_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
>  do { (fail_1_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (fail_1_bb)->block_num = cfg->num_bblocks++; } while (0);
>
>  mini_emit_isninst_cast (cfg, klass_reg, klass, fail_1_bb, ok_result_bb);
>
>  do { do { if (((fail_1_bb))->cil_code) { (cfg)->cil_offset_to_bb [((fail_1_bb))->cil_code - (cfg)->cil_start] = ((fail_1_bb)); } ((fail_1_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (fail_1_bb); mono_link_bblock ((cfg), (cfg)->cbb, (fail_1_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (fail_1_bb)); (cfg)->cbb->next_bb = (fail_1_bb); (cfg)->cbb = (fail_1_bb); } while (0);
>
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_ICONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = dreg; inst->data.op[0].const_val = 1; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_BR)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_BR) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (end_bb); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (end_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
>  do { do { if (((no_proxy_bb))->cil_code) { (cfg)->cil_offset_to_bb [((no_proxy_bb))->cil_code - (cfg)->cil_start] = ((no_proxy_bb)); } ((no_proxy_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (no_proxy_bb); mono_link_bblock ((cfg), (cfg)->cbb, (no_proxy_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (no_proxy_bb)); (cfg)->cbb->next_bb = (no_proxy_bb); (cfg)->cbb = (no_proxy_bb); } while (0);
>
>  mini_emit_castclass (cfg, obj_reg, klass_reg, klass, ok_result_bb);
> }
>
> do { do { if (((ok_result_bb))->cil_code) { (cfg)->cil_offset_to_bb [((ok_result_bb))->cil_code - (cfg)->cil_start] = ((ok_result_bb)); } ((ok_result_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (ok_result_bb); mono_link_bblock ((cfg), (cfg)->cbb, (ok_result_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (ok_result_bb)); (cfg)->cbb->next_bb = (ok_result_bb); (cfg)->cbb = (ok_result_bb); } while (0);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_ICONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = dreg; inst->data.op[0].const_val = 0; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
> do { do { if (((end_bb))->cil_code) { (cfg)->cil_offset_to_bb [((end_bb))->cil_code - (cfg)->cil_start] = ((end_bb)); } ((end_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (end_bb); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); (cfg)->cbb->next_bb = (end_bb); (cfg)->cbb = (end_bb); } while (0);
>
>
> do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_ICONST); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
> ins->dreg = dreg;
> ins->type = STACK_I4;
>
> return ins;
>}
>
>
>
>
>static __attribute__((__unused__)) MonoInst*
>handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used)
>{
> MonoInst *ptr;
> int dreg;
> gpointer *trampoline;
> MonoInst *obj, *method_ins, *tramp_ins;
> MonoDomain *domain;
> guint8 **code_slot;
>
> obj = handle_alloc (cfg, klass, 0, 0);
> if (!obj)
>  return ((void *)0);
>
>
>
>
>
> if (!(target->opcode == OP_I8CONST && target->data.op[0].p == 0)) {
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STORE_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = target->dreg; (inst)->dreg = obj->dreg; (inst)->data.op[0].const_val = __builtin_offsetof (MonoDelegate, target); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>  if (cfg->gen_write_barriers) {
>   dreg = alloc_preg (cfg);
>   do { do { do { (((ptr))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ptr)))->data.op[0].const_val = (((ptr)))->data.op[1].const_val = 0; (((ptr)))->next = (((ptr)))->prev = ((void *)0); (((ptr)))->opcode = (((OP_LADD_IMM))); (((ptr)))->flags = 0; (((ptr)))->type = 0; (((ptr)))->dreg = -1; do { ((((ptr))))->sreg1 = ((((ptr))))->sreg2 = ((((ptr))))->sreg3 = -1; } while (0); (((ptr)))->cil_code = (((cfg)))->ip; } while (0); ((ptr))->dreg = (dreg); ((ptr))->sreg1 = (obj->dreg); ((ptr))->data.op[1].const_val = ((__builtin_offsetof (MonoDelegate, target))); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ptr)); ((ptr))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ptr)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ptr)); } } while (0); } while (0);
>   emit_write_barrier (cfg, ptr, target, 0);
>  }
> }
>
>
> method_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STORE_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = method_ins->dreg; (inst)->dreg = obj->dreg; (inst)->data.op[0].const_val = __builtin_offsetof (MonoDelegate, method); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> if (cfg->gen_write_barriers) {
>  dreg = alloc_preg (cfg);
>  do { do { do { (((ptr))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ptr)))->data.op[0].const_val = (((ptr)))->data.op[1].const_val = 0; (((ptr)))->next = (((ptr)))->prev = ((void *)0); (((ptr)))->opcode = (((OP_LADD_IMM))); (((ptr)))->flags = 0; (((ptr)))->type = 0; (((ptr)))->dreg = -1; do { ((((ptr))))->sreg1 = ((((ptr))))->sreg2 = ((((ptr))))->sreg3 = -1; } while (0); (((ptr)))->cil_code = (((cfg)))->ip; } while (0); ((ptr))->dreg = (dreg); ((ptr))->sreg1 = (obj->dreg); ((ptr))->data.op[1].const_val = ((__builtin_offsetof (MonoDelegate, method))); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ptr)); ((ptr))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ptr)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ptr)); } } while (0); } while (0);
>  emit_write_barrier (cfg, ptr, method_ins, 0);
> }
>
>
>
>
>
> if (!cfg->compile_aot && !method->dynamic) {
>  MonoInst *code_slot_ins;
>
>  if (context_used) {
>   code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
>  } else {
>   domain = mono_domain_get ();
>   do { do { int ret = pthread_mutex_lock (&(&(domain)->lock)->mutex); if (ret != 0) monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_WARNING, "Bad call to mono_mutex_lock result %d", ret); do { if (!(ret == 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 3845, "ret == 0"); } while (0); } while (0); do {} while (0); } while (0);
>   if (!((MonoJitDomainInfo*)((domain)->runtime_info))->method_code_hash)
>    ((MonoJitDomainInfo*)((domain)->runtime_info))->method_code_hash = monoeg_g_hash_table_new (((void *)0), ((void *)0));
>   code_slot = monoeg_g_hash_table_lookup (((MonoJitDomainInfo*)((domain)->runtime_info))->method_code_hash, method);
>   if (!code_slot) {
>    code_slot = mono_domain_alloc0 (domain, sizeof (gpointer));
>    monoeg_g_hash_table_insert_replace ((((MonoJitDomainInfo*)((domain)->runtime_info))->method_code_hash),(method),(code_slot),0);
>   }
>   do { do {} while (0); do { int ret = pthread_mutex_unlock (&(&(domain)->lock)->mutex); if (ret != 0) monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_WARNING, "Bad call to mono_mutex_unlock result %d", ret); do { if (!(ret == 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 3853, "ret == 0"); } while (0); } while (0); } while (0);
>
>   do { do { do { (((code_slot_ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((code_slot_ins)))->data.op[0].const_val = (((code_slot_ins)))->data.op[1].const_val = 0; (((code_slot_ins)))->next = (((code_slot_ins)))->prev = ((void *)0); (((code_slot_ins)))->opcode = (OP_I8CONST); (((code_slot_ins)))->flags = 0; (((code_slot_ins)))->type = 0; (((code_slot_ins)))->dreg = -1; do { ((((code_slot_ins))))->sreg1 = ((((code_slot_ins))))->sreg2 = ((((code_slot_ins))))->sreg3 = -1; } while (0); (((code_slot_ins)))->cil_code = (((cfg)))->ip; } while (0); ((code_slot_ins))->data.op[0].p = ((code_slot)); ((code_slot_ins))->type = STACK_PTR; ((code_slot_ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((code_slot_ins)); ((code_slot_ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((code_slot_ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((code_slot_ins)); } } while (0); } while (0);
>  }
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STORE_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = code_slot_ins->dreg; (inst)->dreg = obj->dreg; (inst)->data.op[0].const_val = __builtin_offsetof (MonoDelegate, method_code); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> }
>
>
> if (cfg->compile_aot) {
>  do { do { do { (((tramp_ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((tramp_ins)))->data.op[0].const_val = (((tramp_ins)))->data.op[1].const_val = 0; (((tramp_ins)))->next = (((tramp_ins)))->prev = ((void *)0); (((tramp_ins)))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((tramp_ins)))->flags = 0; (((tramp_ins)))->type = 0; (((tramp_ins)))->dreg = -1; do { ((((tramp_ins))))->sreg1 = ((((tramp_ins))))->sreg2 = ((((tramp_ins))))->sreg3 = -1; } while (0); (((tramp_ins)))->cil_code = (((cfg)))->ip; } while (0); ((tramp_ins))->data.op[0].p = ((klass)); ((tramp_ins))->data.op[1].src = (gpointer)((MONO_PATCH_INFO_DELEGATE_TRAMPOLINE)); ((tramp_ins))->type = STACK_PTR; ((tramp_ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((tramp_ins)); ((tramp_ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((tramp_ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((tramp_ins)); } } while (0); } while (0);
> } else {
>  trampoline = mono_create_delegate_trampoline (klass);
>  do { do { do { (((tramp_ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((tramp_ins)))->data.op[0].const_val = (((tramp_ins)))->data.op[1].const_val = 0; (((tramp_ins)))->next = (((tramp_ins)))->prev = ((void *)0); (((tramp_ins)))->opcode = (OP_I8CONST); (((tramp_ins)))->flags = 0; (((tramp_ins)))->type = 0; (((tramp_ins)))->dreg = -1; do { ((((tramp_ins))))->sreg1 = ((((tramp_ins))))->sreg2 = ((((tramp_ins))))->sreg3 = -1; } while (0); (((tramp_ins)))->cil_code = (((cfg)))->ip; } while (0); ((tramp_ins))->data.op[0].p = ((trampoline)); ((tramp_ins))->type = STACK_PTR; ((tramp_ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((tramp_ins)); ((tramp_ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((tramp_ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((tramp_ins)); } } while (0); } while (0);
> }
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STORE_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = tramp_ins->dreg; (inst)->dreg = obj->dreg; (inst)->data.op[0].const_val = __builtin_offsetof (MonoDelegate, invoke_impl); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>
>
> return obj;
>}
>
>static MonoInst*
>handle_array_new (MonoCompile *cfg, int rank, MonoInst **sp, unsigned char *ip)
>{
> MonoJitICallInfo *info;
>
>
> info = mono_get_array_new_va_icall (rank);
>
> cfg->flags |= MONO_CFG_HAS_VARARGS;
>
>
> cfg->disable_llvm = 1;
>
>
> return mono_emit_native_call (cfg, mono_icall_get_wrapper (info), info->sig, sp);
>}
>
>static void
>mono_emit_load_got_addr (MonoCompile *cfg)
>{
> MonoInst *getaddr, *dummy_use;
>
> if (!cfg->got_var || cfg->got_var_allocated)
>  return;
>
> do { (getaddr) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (getaddr)->data.op[0].const_val = (getaddr)->data.op[1].const_val = 0; (getaddr)->next = (getaddr)->prev = ((void *)0); (getaddr)->opcode = (OP_LOAD_GOTADDR); (getaddr)->flags = 0; (getaddr)->type = 0; (getaddr)->dreg = -1; do { ((getaddr))->sreg1 = ((getaddr))->sreg2 = ((getaddr))->sreg3 = -1; } while (0); (getaddr)->cil_code = (cfg)->ip; } while (0);
> getaddr->dreg = cfg->got_var->dreg;
>
>
> if (cfg->bb_entry->code) {
>  getaddr->next = cfg->bb_entry->code;
>  cfg->bb_entry->code = getaddr;
> }
> else
>  do { if ((cfg->bb_entry)->last_ins) { (cfg->bb_entry)->last_ins->next = (getaddr); (getaddr)->prev = (cfg->bb_entry)->last_ins; (cfg->bb_entry)->last_ins = (getaddr); } else { (cfg->bb_entry)->code = (cfg->bb_entry)->last_ins = (getaddr); } } while (0);
>
> cfg->got_var_allocated = 1;
># 3921 "method-to-ir.c"
> do { do { ((dummy_use)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((dummy_use))->data.op[0].const_val = ((dummy_use))->data.op[1].const_val = 0; ((dummy_use))->next = ((dummy_use))->prev = ((void *)0); ((dummy_use))->opcode = (OP_DUMMY_USE); ((dummy_use))->flags = 0; ((dummy_use))->type = 0; ((dummy_use))->dreg = -1; do { (((dummy_use)))->sreg1 = (((dummy_use)))->sreg2 = (((dummy_use)))->sreg3 = -1; } while (0); ((dummy_use))->cil_code = ((cfg))->ip; } while (0); (dummy_use)->sreg1 = cfg->got_var->dreg; } while (0);
> do { if ((cfg->bb_exit)->last_ins) { (cfg->bb_exit)->last_ins->next = (dummy_use); (dummy_use)->prev = (cfg->bb_exit)->last_ins; (cfg->bb_exit)->last_ins = (dummy_use); } else { (cfg->bb_exit)->code = (cfg->bb_exit)->last_ins = (dummy_use); } } while (0);
>}
>
>static int inline_limit;
>static gboolean inline_limit_inited;
>
>static gboolean
>mono_method_check_inlining (MonoCompile *cfg, MonoMethod *method)
>{
> MonoMethodHeaderSummary header;
> MonoVTable *vtable;
>
>
>
>
>
> if (cfg->generic_sharing_context)
>  return 0;
>
> if (cfg->inline_depth > 10)
>  return 0;
># 3952 "method-to-ir.c"
> if (!mono_method_get_header_summary (method, &header))
>  return 0;
>
>
> if ((method->iflags & 0x0008) ||
>     (method->iflags & 0x0020) ||
>     (method->klass->marshalbyref) ||
>     header.has_clauses)
>  return 0;
>
>
>
> if (!inline_limit_inited) {
>  if (getenv ("MONO_INLINELIMIT"))
>   inline_limit = atoi (getenv ("MONO_INLINELIMIT"));
>  else
>   inline_limit = 20;
>  inline_limit_inited = 1;
> }
> if (header.code_size >= inline_limit)
>  return 0;
>
>
>
>
>
>
>
> if (!(cfg->opt & MONO_OPT_SHARED)) {
>  if (method->klass->flags & 0x00100000) {
>   if (cfg->run_cctors && method->klass->has_cctor) {
>
>    if (!method->klass->runtime_info)
>
>     return 0;
>    vtable = mono_class_vtable (cfg->domain, method->klass);
>    if (!vtable)
>     return 0;
>
>
>
>    if (! vtable->initialized)
>     return 0;
>    mono_runtime_class_init (vtable);
>   }
>  } else if (mono_class_needs_cctor_run (method->klass, ((void *)0))) {
>   if (!method->klass->runtime_info)
>
>    return 0;
>   vtable = mono_class_vtable (cfg->domain, method->klass);
>   if (!vtable)
>    return 0;
>   if (!vtable->initialized)
>    return 0;
>  }
> } else {
>
>
>
>
>
>  if (mono_class_needs_cctor_run (method->klass, ((void *)0)) && !((method->klass->flags & 0x00100000)))
>   return 0;
> }
>
>
>
>
>
> if (mono_method_has_declsec (method))
>  return 0;
># 4033 "method-to-ir.c"
> return 1;
>}
>
>static gboolean
>mini_field_access_needs_cctor_run (MonoCompile *cfg, MonoMethod *method, MonoVTable *vtable)
>{
> if (vtable->initialized && !cfg->compile_aot)
>  return 0;
>
> if (vtable->klass->flags & 0x00100000)
>  return 0;
>
> if (!mono_class_needs_cctor_run (vtable->klass, method))
>  return 0;
>
> if (! (method->flags & 0x0010) && (vtable->klass == method->klass))
>
>  return 0;
>
> return 1;
>}
>
>static MonoInst*
>mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
>{
> MonoInst *ins;
> guint32 size;
> int mult_reg, add_reg, array_reg, index_reg, index2_reg;
>
> mono_class_init (klass);
> size = mono_class_array_element_size (klass);
>
> mult_reg = alloc_preg (cfg);
> array_reg = arr->dreg;
> index_reg = index->dreg;
>
>
>
> if ((0)) {
>
>  index2_reg = index_reg;
> } else {
>  index2_reg = alloc_preg (cfg);
>  do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_SEXT_I4)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((index2_reg)); (((inst)))->sreg1 = ((index_reg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0);
> }
># 4087 "method-to-ir.c"
> if (bcheck)
>  do { if (!(cfg->opt & MONO_OPT_UNSAFE)) { if (!(cfg->opt & MONO_OPT_ABCREM)) { do { if (cfg->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (array_reg); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((0)) do { int _length_reg = alloc_ireg ((cfg)); if (1) do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((array_reg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = ((((OP_LOADI4_MEMBASE)))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = (((((cfg)))))->ip; } while (0); ((inst))->dreg = (((_length_reg))); ((inst))->sreg1 = ((((array_reg)))); ((inst))->data.op[0].const_val = (((__builtin_offsetof (MonoArray, max_length)))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); else do { MonoInst *inst; int __ins_flags = MONO_INST_CONSTANT_LOAD; if (__ins_flags & MONO_INST_FAULT) { do { if (((cfg))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (((array_reg))); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((((cfg)))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((((cfg)))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((((cfg)))))->cbb)->last_ins) { ((((((cfg)))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((((cfg)))))->cbb)->last_ins; ((((((cfg)))))->cbb)->last_ins = (((inst))); } else { ((((((cfg)))))->cbb)->code = ((((((cfg)))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((cfg)->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = (((OP_LOADI4_MEMBASE))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = ((((cfg))))->ip; } while (0); ((inst))->dreg = ((_length_reg)); ((inst))->sreg1 = (((array_reg))); ((inst))->data.op[0].const_val = ((__builtin_offsetof (MonoArray, max_length))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = -1; inst->sreg1 = _length_reg; inst->sreg2 = (index2_reg); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_LE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->data.op[1].p = (char*)"IndexOutOfRangeException"; do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); } while (0); else do { int _length_reg = alloc_ireg (((cfg))); if (1) do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if (((((cfg))))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((((cfg))))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((((cfg))))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (((((array_reg))))); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((((cfg))))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((((cfg))))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((((((cfg)))))->cbb)->last_ins) { ((((((cfg)))))->cbb)->last_ins->next = (inst); (inst)->prev = ((((((cfg)))))->cbb)->last_ins; ((((((cfg)))))->cbb)->last_ins = (inst); } else { ((((((cfg)))))->cbb)->code = ((((((cfg)))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((((((cfg)))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((((((cfg)))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((((((cfg)))))))->cbb)->last_ins) { ((((((((cfg)))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((((((cfg)))))))->cbb)->last_ins; ((((((((cfg)))))))->cbb)->last_ins = (((inst))); } else { ((((((((cfg)))))))->cbb)->code = ((((((((cfg)))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((((cfg)))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc (((((((cfg))))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = ((((OP_LOADI4_MEMBASE)))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = ((((((cfg))))))->ip; } while (0); ((inst))->dreg = (((_length_reg))); ((inst))->sreg1 = (((((array_reg))))); ((inst))->data.op[0].const_val = ((((__builtin_offsetof (MonoArray, max_length))))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); else do { MonoInst *inst; int __ins_flags = MONO_INST_CONSTANT_LOAD; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((array_reg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = (((OP_LOADI4_MEMBASE))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = (((((cfg)))))->ip; } while (0); ((inst))->dreg = ((_length_reg)); ((inst))->sreg1 = ((((array_reg)))); ((inst))->data.op[0].const_val = (((__builtin_offsetof (MonoArray, max_length)))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = _length_reg; inst->sreg2 = ((index2_reg)); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_LE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->data.op[1].p = (char*)"IndexOutOfRangeException"; do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); } while (0); } else { MonoInst *ins; do { (ins) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BOUNDS_CHECK); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = ((cfg))->ip; } while (0); ins->sreg1 = array_reg; ins->sreg2 = index2_reg; ins->data.op[1].const_val = __builtin_offsetof (MonoArray, max_length); ins->flags |= MONO_INST_FAULT; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); (cfg)->flags |= MONO_CFG_HAS_ARRAY_ACCESS; (cfg)->cbb->has_array_access = 1; } } } while (0);
># 4102 "method-to-ir.c"
> add_reg = alloc_ireg_mp (cfg);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_MUL_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = mult_reg; inst->sreg1 = index2_reg; inst->data.op[1].const_val = (mgreg_t)(size); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LADD)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = add_reg; inst->sreg1 = array_reg; inst->sreg2 = mult_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LADD_IMM)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); (ins)->dreg = add_reg; (ins)->sreg1 = add_reg; (ins)->data.op[1].const_val = (__builtin_offsetof (MonoArray, vector)); } while (0);
> ins->klass = mono_class_get_element_class (klass);
> ins->type = STACK_MP;
> do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>
> return ins;
>}
>
>
>static MonoInst*
>mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
>{
> int bounds_reg = alloc_preg (cfg);
> int add_reg = alloc_ireg_mp (cfg);
> int mult_reg = alloc_preg (cfg);
> int mult2_reg = alloc_preg (cfg);
> int low1_reg = alloc_preg (cfg);
> int low2_reg = alloc_preg (cfg);
> int high1_reg = alloc_preg (cfg);
> int high2_reg = alloc_preg (cfg);
> int realidx1_reg = alloc_preg (cfg);
> int realidx2_reg = alloc_preg (cfg);
> int sum_reg = alloc_preg (cfg);
> int index1, index2;
> MonoInst *ins;
> guint32 size;
>
> mono_class_init (klass);
> size = mono_class_array_element_size (klass);
>
> index1 = index_ins1->dreg;
> index2 = index_ins2->dreg;
>
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (bounds_reg); inst->sreg1 = (arr->dreg); inst->data.op[0].const_val = (__builtin_offsetof (MonoArray, bounds)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0)
>                                                          ;
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI4_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = low1_reg; inst->sreg1 = bounds_reg; inst->data.op[0].const_val = __builtin_offsetof (MonoArrayBounds, lower_bound); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0)
>                                                                      ;
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LSUB)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = realidx1_reg; inst->sreg1 = index1; inst->sreg2 = low1_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI4_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = high1_reg; inst->sreg1 = bounds_reg; inst->data.op[0].const_val = __builtin_offsetof (MonoArrayBounds, length); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0)
>                                                                 ;
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = high1_reg; inst->sreg2 = realidx1_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_LE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"IndexOutOfRangeException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI4_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = low2_reg; inst->sreg1 = bounds_reg; inst->data.op[0].const_val = sizeof (MonoArrayBounds) + __builtin_offsetof (MonoArrayBounds, lower_bound); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0)
>                                                                                                 ;
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LSUB)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = realidx2_reg; inst->sreg1 = index2; inst->sreg2 = low2_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LOADI4_MEMBASE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = high2_reg; inst->sreg1 = bounds_reg; inst->data.op[0].const_val = sizeof (MonoArrayBounds) + __builtin_offsetof (MonoArrayBounds, length); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0)
>                                                                                            ;
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = high2_reg; inst->sreg2 = realidx2_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_LE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"IndexOutOfRangeException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LMUL)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = mult_reg; inst->sreg1 = high2_reg; inst->sreg2 = realidx1_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LADD)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = sum_reg; inst->sreg1 = mult_reg; inst->sreg2 = realidx2_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LMUL_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = mult2_reg; inst->sreg1 = sum_reg; inst->data.op[1].const_val = (mgreg_t)(size); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LADD)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = add_reg; inst->sreg1 = mult2_reg; inst->sreg2 = arr->dreg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
> do { do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LADD_IMM)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); (ins)->dreg = add_reg; (ins)->sreg1 = add_reg; (ins)->data.op[1].const_val = (__builtin_offsetof (MonoArray, vector)); } while (0);
>
> ins->type = STACK_MP;
> ins->klass = klass;
> do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>
> return ins;
>}
>
>
>static MonoInst*
>mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
>{
> int rank;
> MonoInst *addr;
> MonoMethod *addr_method;
> int element_size;
>
> rank = mono_method_signature (cmethod)->param_count - (is_set? 1: 0);
>
> if (rank == 1)
>  return mini_emit_ldelema_1_ins (cfg, cmethod->klass->element_class, sp [0], sp [1], 1);
>
>
>
> if (rank == 2 && (cfg->opt & MONO_OPT_INTRINS)) {
>  return mini_emit_ldelema_2_ins (cfg, cmethod->klass->element_class, sp [0], sp [1], sp [2]);
> }
>
>
> element_size = mono_class_array_element_size (cmethod->klass->element_class);
> addr_method = mono_marshal_get_array_address (rank, element_size);
> addr = mono_emit_method_call (cfg, addr_method, sp, ((void *)0));
>
> return addr;
>}
>
>static MonoBreakPolicy
>always_insert_breakpoint (MonoMethod *method)
>{
> return MONO_BREAK_POLICY_ALWAYS;
>}
>
>static MonoBreakPolicyFunc break_policy_func = always_insert_breakpoint;
># 4223 "method-to-ir.c"
>void
>mono_set_break_policy (MonoBreakPolicyFunc policy_callback)
>{
> if (policy_callback)
>  break_policy_func = policy_callback;
> else
>  break_policy_func = always_insert_breakpoint;
>}
>
>static gboolean
>should_insert_brekpoint (MonoMethod *method) {
> switch (break_policy_func (method)) {
> case MONO_BREAK_POLICY_ALWAYS:
>  return 1;
> case MONO_BREAK_POLICY_NEVER:
>  return 0;
> case MONO_BREAK_POLICY_ON_DBG:
>  return mono_debug_using_mono_debugger ();
> default:
>  monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_WARNING, "Incorrect value returned from break policy callback");
>  return 0;
> }
>}
>
>
>static MonoInst*
>emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
>{
> MonoInst *addr, *store, *load;
> MonoClass *eklass = mono_class_from_mono_type (fsig->params [2]);
>
>
> addr = mini_emit_ldelema_1_ins (cfg, eklass, args [0], args [1], 0);
> if (is_set) {
>  do { do { do { do { ((((load)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((load))))->data.op[0].const_val = ((((load))))->data.op[1].const_val = 0; ((((load))))->next = ((((load))))->prev = ((void *)0); ((((load))))->opcode = ((mono_type_to_load_membase (((cfg)), ((&eklass->byval_arg))))); ((((load))))->flags = 0; ((((load))))->type = 0; ((((load))))->dreg = -1; do { (((((load)))))->sreg1 = (((((load)))))->sreg2 = (((((load)))))->sreg3 = -1; } while (0); ((((load))))->cil_code = ((((cfg))))->ip; } while (0); (((load)))->dreg = (0); (((load)))->sreg1 = (((args [2]->dreg))); (((load)))->data.op[0].const_val = (((0))); (((load)))->type = STACK_I4; } while (0); type_to_eval_stack_type (((cfg)), ((&eklass->byval_arg)), ((load))); ((load))->dreg = alloc_dreg (((cfg)), ((load))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((load)); ((load))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((load)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((load)); } } while (0); } while (0);
>  do { do { do { (((store))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((store)))->data.op[0].const_val = (((store)))->data.op[1].const_val = 0; (((store)))->next = (((store)))->prev = ((void *)0); (((store)))->opcode = (mono_type_to_store_membase (((cfg)), ((&eklass->byval_arg)))); (((store)))->flags = 0; (((store)))->type = 0; (((store)))->dreg = -1; do { ((((store))))->sreg1 = ((((store))))->sreg2 = ((((store))))->sreg3 = -1; } while (0); (((store)))->cil_code = (((cfg)))->ip; } while (0); ((store))->sreg1 = (load->dreg); ((store))->dreg = (addr->dreg); ((store))->data.op[0].const_val = (0); type_to_eval_stack_type (((cfg)), ((&eklass->byval_arg)), ((store))); ((store))->klass = mono_class_from_mono_type ((&eklass->byval_arg)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((store)); ((store))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((store)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((store)); } } while (0); } while (0);
> } else {
>  do { do { do { do { ((((load)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((load))))->data.op[0].const_val = ((((load))))->data.op[1].const_val = 0; ((((load))))->next = ((((load))))->prev = ((void *)0); ((((load))))->opcode = ((mono_type_to_load_membase (((cfg)), ((&eklass->byval_arg))))); ((((load))))->flags = 0; ((((load))))->type = 0; ((((load))))->dreg = -1; do { (((((load)))))->sreg1 = (((((load)))))->sreg2 = (((((load)))))->sreg3 = -1; } while (0); ((((load))))->cil_code = ((((cfg))))->ip; } while (0); (((load)))->dreg = (0); (((load)))->sreg1 = (((addr->dreg))); (((load)))->data.op[0].const_val = (((0))); (((load)))->type = STACK_I4; } while (0); type_to_eval_stack_type (((cfg)), ((&eklass->byval_arg)), ((load))); ((load))->dreg = alloc_dreg (((cfg)), ((load))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((load)); ((load))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((load)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((load)); } } while (0); } while (0);
>  do { do { do { (((store))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((store)))->data.op[0].const_val = (((store)))->data.op[1].const_val = 0; (((store)))->next = (((store)))->prev = ((void *)0); (((store)))->opcode = (mono_type_to_store_membase (((cfg)), ((&eklass->byval_arg)))); (((store)))->flags = 0; (((store)))->type = 0; (((store)))->dreg = -1; do { ((((store))))->sreg1 = ((((store))))->sreg2 = ((((store))))->sreg3 = -1; } while (0); (((store)))->cil_code = (((cfg)))->ip; } while (0); ((store))->sreg1 = (load->dreg); ((store))->dreg = (args [2]->dreg); ((store))->data.op[0].const_val = (0); type_to_eval_stack_type (((cfg)), ((&eklass->byval_arg)), ((store))); ((store))->klass = mono_class_from_mono_type ((&eklass->byval_arg)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((store)); ((store))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((store)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((store)); } } while (0); } while (0);
> }
> return store;
>}
>
>static MonoInst*
>mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
>{
> MonoInst *ins = ((void *)0);
># 4278 "method-to-ir.c"
> return ins;
>}
>
>static MonoInst*
>mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
>{
> MonoInst *ins = ((void *)0);
>
> static MonoClass *runtime_helpers_class = ((void *)0);
> if (! runtime_helpers_class)
>  runtime_helpers_class = mono_class_from_name (mono_defaults.corlib,
>   "System.Runtime.CompilerServices", "RuntimeHelpers");
>
> if (cmethod->klass == mono_defaults.string_class) {
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("get_Chars") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("get_Chars")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("get_Chars") + 1) - (size_t)(const void *)("get_Chars") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "get_Chars") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("get_Chars") && ((size_t)(const void *)(("get_Chars") + 1) - (size_t)(const void *)("get_Chars") == 1) ? __builtin_strcmp (cmethod->name, "get_Chars") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("get_Chars"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("get_Chars") && ((size_t)(const void *)(("get_Chars") + 1) - (size_t)(const void *)("get_Chars") == 1) && (__s2_len = __strlen_g (("get_Chars")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "get_Chars") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("get_Chars"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("get_Chars"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("get_Chars"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("get_Chars"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "get_Chars")))); }) == 0) {
>   int dreg = alloc_ireg (cfg);
>   int index_reg = alloc_preg (cfg);
>   int mult_reg = alloc_preg (cfg);
>   int add_reg = alloc_preg (cfg);
>
>
>
>   do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_SEXT_I4)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((index_reg)); (((inst)))->sreg1 = ((args [1]->dreg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0);
>
>
>
>   do { if (!(cfg->opt & MONO_OPT_UNSAFE)) { if (!(cfg->opt & MONO_OPT_ABCREM)) { do { if (cfg->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (args [0]->dreg); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((0)) do { int _length_reg = alloc_ireg ((cfg)); if (1) do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((args [0]->dreg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = ((((OP_LOADI4_MEMBASE)))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = (((((cfg)))))->ip; } while (0); ((inst))->dreg = (((_length_reg))); ((inst))->sreg1 = ((((args [0]->dreg)))); ((inst))->data.op[0].const_val = (((__builtin_offsetof (MonoString, length)))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); else do { MonoInst *inst; int __ins_flags = MONO_INST_CONSTANT_LOAD; if (__ins_flags & MONO_INST_FAULT) { do { if (((cfg))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (((args [0]->dreg))); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((((cfg)))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((((cfg)))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((((cfg)))))->cbb)->last_ins) { ((((((cfg)))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((((cfg)))))->cbb)->last_ins; ((((((cfg)))))->cbb)->last_ins = (((inst))); } else { ((((((cfg)))))->cbb)->code = ((((((cfg)))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((cfg)->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = (((OP_LOADI4_MEMBASE))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = ((((cfg))))->ip; } while (0); ((inst))->dreg = ((_length_reg)); ((inst))->sreg1 = (((args [0]->dreg))); ((inst))->data.op[0].const_val = ((__builtin_offsetof (MonoString, length))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = -1; inst->sreg1 = _length_reg; inst->sreg2 = (index_reg); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_LE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->data.op[1].p = (char*)"IndexOutOfRangeException"; do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); } while (0); else do { int _length_reg = alloc_ireg (((cfg))); if (1) do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if (((((cfg))))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((((cfg))))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((((cfg))))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (((((args [0]->dreg))))); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((((cfg))))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((((cfg))))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((((((cfg)))))->cbb)->last_ins) { ((((((cfg)))))->cbb)->last_ins->next = (inst); (inst)->prev = ((((((cfg)))))->cbb)->last_ins; ((((((cfg)))))->cbb)->last_ins = (inst); } else { ((((((cfg)))))->cbb)->code = ((((((cfg)))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((((((cfg)))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((((((cfg)))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((((((cfg)))))))->cbb)->last_ins) { ((((((((cfg)))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((((((cfg)))))))->cbb)->last_ins; ((((((((cfg)))))))->cbb)->last_ins = (((inst))); } else { ((((((((cfg)))))))->cbb)->code = ((((((((cfg)))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((((cfg)))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc (((((((cfg))))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = ((((OP_LOADI4_MEMBASE)))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = ((((((cfg))))))->ip; } while (0); ((inst))->dreg = (((_length_reg))); ((inst))->sreg1 = (((((args [0]->dreg))))); ((inst))->data.op[0].const_val = ((((__builtin_offsetof (MonoString, length))))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); else do { MonoInst *inst; int __ins_flags = MONO_INST_CONSTANT_LOAD; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((args [0]->dreg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = (((OP_LOADI4_MEMBASE))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = (((((cfg)))))->ip; } while (0); ((inst))->dreg = ((_length_reg)); ((inst))->sreg1 = ((((args [0]->dreg)))); ((inst))->data.op[0].const_val = (((__builtin_offsetof (MonoString, length)))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = _length_reg; inst->sreg2 = ((index_reg)); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_LE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->data.op[1].p = (char*)"IndexOutOfRangeException"; do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); } while (0); } else { MonoInst *ins; do { (ins) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BOUNDS_CHECK); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = ((cfg))->ip; } while (0); ins->sreg1 = args [0]->dreg; ins->sreg2 = index_reg; ins->data.op[1].const_val = __builtin_offsetof (MonoString, length); ins->flags |= MONO_INST_FAULT; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); (cfg)->flags |= MONO_CFG_HAS_ARRAY_ACCESS; (cfg)->cbb->has_array_access = 1; } } } while (0);
># 4314 "method-to-ir.c"
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_SHL_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = mult_reg; inst->sreg1 = index_reg; inst->data.op[1].const_val = (mgreg_t)(1); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LADD)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = add_reg; inst->sreg1 = mult_reg; inst->sreg2 = args [0]->dreg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LOADU2_MEMBASE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = ((dreg)); ((ins))->sreg1 = ((add_reg)); ((ins))->data.op[0].const_val = ((__builtin_offsetof (MonoString, chars))); ((ins))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0)
>                                                        ;
>
>   type_from_op (ins, ((void *)0), ((void *)0));
>   return ins;
>  } else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("get_Length") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("get_Length")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("get_Length") + 1) - (size_t)(const void *)("get_Length") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "get_Length") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("get_Length") && ((size_t)(const void *)(("get_Length") + 1) - (size_t)(const void *)("get_Length") == 1) ? __builtin_strcmp (cmethod->name, "get_Length") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("get_Length"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("get_Length") && ((size_t)(const void *)(("get_Length") + 1) - (size_t)(const void *)("get_Length") == 1) && (__s2_len = __strlen_g (("get_Length")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "get_Length") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("get_Length"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("get_Length"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("get_Length"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("get_Length"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "get_Length")))); }) == 0) {
>   int dreg = alloc_ireg (cfg);
>
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_STRLEN))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = (dreg); ((ins))->sreg1 = (args [0]->dreg); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ins->type = STACK_I4;
>   ins->flags |= MONO_INST_FAULT;
>   cfg->cbb->has_array_access = 1;
>   cfg->flags |= MONO_CFG_HAS_ARRAY_ACCESS;
>
>   return ins;
>  } else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("InternalSetChar") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("InternalSetChar")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("InternalSetChar") + 1) - (size_t)(const void *)("InternalSetChar") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "InternalSetChar") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("InternalSetChar") && ((size_t)(const void *)(("InternalSetChar") + 1) - (size_t)(const void *)("InternalSetChar") == 1) ? __builtin_strcmp (cmethod->name, "InternalSetChar") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("InternalSetChar"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("InternalSetChar") && ((size_t)(const void *)(("InternalSetChar") + 1) - (size_t)(const void *)("InternalSetChar") == 1) && (__s2_len = __strlen_g (("InternalSetChar")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "InternalSetChar") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("InternalSetChar"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("InternalSetChar"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("InternalSetChar"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("InternalSetChar"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "InternalSetChar")))); }) == 0) {
>   int mult_reg = alloc_preg (cfg);
>   int add_reg = alloc_preg (cfg);
>
>
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_SHL_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = mult_reg; inst->sreg1 = args [1]->dreg; inst->data.op[1].const_val = (mgreg_t)(1); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LADD)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = add_reg; inst->sreg1 = mult_reg; inst->sreg2 = args [0]->dreg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI2_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = args [2]->dreg; (inst)->dreg = add_reg; (inst)->data.op[0].const_val = __builtin_offsetof (MonoString, chars); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   return cfg->cbb->last_ins;
>  } else
>   return ((void *)0);
> } else if (cmethod->klass == mono_defaults.object_class) {
>
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("GetType") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("GetType")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("GetType") + 1) - (size_t)(const void *)("GetType") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "GetType") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("GetType") && ((size_t)(const void *)(("GetType") + 1) - (size_t)(const void *)("GetType") == 1) ? __builtin_strcmp (cmethod->name, "GetType") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("GetType"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("GetType") && ((size_t)(const void *)(("GetType") + 1) - (size_t)(const void *)("GetType") == 1) && (__s2_len = __strlen_g (("GetType")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "GetType") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("GetType"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("GetType"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("GetType"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("GetType"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "GetType")))); }) == 0) {
>   int dreg = alloc_ireg_ref (cfg);
>   int vt_reg = alloc_preg (cfg);
>   do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((args [0]->dreg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = (((((OP_LOAD_MEMBASE))))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = (((((cfg)))))->ip; } while (0); ((inst))->dreg = ((((vt_reg)))); ((inst))->sreg1 = ((((args [0]->dreg)))); ((inst))->data.op[0].const_val = ((((__builtin_offsetof (MonoObject, vtable))))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LOAD_MEMBASE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = ((dreg)); ((ins))->sreg1 = ((vt_reg)); ((ins))->data.op[0].const_val = ((__builtin_offsetof (MonoVTable, type))); ((ins))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   type_from_op (ins, ((void *)0), ((void *)0));
>
>   return ins;
>
>  } else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("InternalGetHashCode") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("InternalGetHashCode")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("InternalGetHashCode") + 1) - (size_t)(const void *)("InternalGetHashCode") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "InternalGetHashCode") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("InternalGetHashCode") && ((size_t)(const void *)(("InternalGetHashCode") + 1) - (size_t)(const void *)("InternalGetHashCode") == 1) ? __builtin_strcmp (cmethod->name, "InternalGetHashCode") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("InternalGetHashCode"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("InternalGetHashCode") && ((size_t)(const void *)(("InternalGetHashCode") + 1) - (size_t)(const void *)("InternalGetHashCode") == 1) && (__s2_len = __strlen_g (("InternalGetHashCode")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "InternalGetHashCode") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("InternalGetHashCode"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("InternalGetHashCode"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("InternalGetHashCode"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("InternalGetHashCode"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "InternalGetHashCode")))); }) == 0 && !mono_gc_is_moving ()) {
>   int dreg = alloc_ireg (cfg);
>   int t1 = alloc_ireg (cfg);
>
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_SHL_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = t1; inst->sreg1 = args [0]->dreg; inst->data.op[1].const_val = (mgreg_t)(3); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_MUL_IMM))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = (dreg); ((ins))->sreg1 = (t1); ((ins))->data.op[1].const_val = ((2654435761u)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ins->type = STACK_I4;
>
>   return ins;
>
>  } else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p (".ctor") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g ((".ctor")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((".ctor") + 1) - (size_t)(const void *)(".ctor") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, ".ctor") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p (".ctor") && ((size_t)(const void *)((".ctor") + 1) - (size_t)(const void *)(".ctor") == 1) ? __builtin_strcmp (cmethod->name, ".ctor") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (".ctor"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (".ctor") && ((size_t)(const void *)((".ctor") + 1) - (size_t)(const void *)(".ctor") == 1) && (__s2_len = __strlen_g ((".ctor")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, ".ctor") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) (".ctor"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (".ctor"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (".ctor"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (".ctor"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, ".ctor")))); }) == 0) {
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_NOP); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>   return ins;
>  } else
>   return ((void *)0);
> } else if (cmethod->klass == mono_defaults.array_class) {
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name + 1) && __builtin_constant_p ("etGenericValueImpl") && (__s1_len = __strlen_g ((cmethod->name + 1)), __s2_len = __strlen_g (("etGenericValueImpl")), (!((size_t)(const void *)((cmethod->name + 1) + 1) - (size_t)(const void *)(cmethod->name + 1) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("etGenericValueImpl") + 1) - (size_t)(const void *)("etGenericValueImpl") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name + 1, "etGenericValueImpl") : (__builtin_constant_p (cmethod->name + 1) && ((size_t)(const void *)((cmethod->name + 1) + 1) - (size_t)(const void *)(cmethod->name + 1) == 1) && (__s1_len = __strlen_g ((cmethod->name + 1)), __s1_len < 4) ? (__builtin_constant_p ("etGenericValueImpl") && ((size_t)(const void *)(("etGenericValueImpl") + 1) - (size_t)(const void *)("etGenericValueImpl") == 1) ? __builtin_strcmp (cmethod->name + 1, "etGenericValueImpl") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("etGenericValueImpl"); int __result = (((const unsigned char *) (const char *) (cmethod->name + 1))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name + 1))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name + 1))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name + 1))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("etGenericValueImpl") && ((size_t)(const void *)(("etGenericValueImpl") + 1) - (size_t)(const void *)("etGenericValueImpl") == 1) && (__s2_len = __strlen_g (("etGenericValueImpl")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name + 1) && ((size_t)(const void *)((cmethod->name + 1) + 1) - (size_t)(const void *)(cmethod->name + 1) == 1) ? __builtin_strcmp (cmethod->name + 1, "etGenericValueImpl") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name + 1); int __result = (((const unsigned char *) (const char *) ("etGenericValueImpl"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("etGenericValueImpl"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("etGenericValueImpl"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("etGenericValueImpl"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name + 1, "etGenericValueImpl")))); }) == 0)
>   return emit_array_generic_access (cfg, fsig, args, *cmethod->name == 'S');
>
>
>
>
>
>
>  if ((__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("GetLength") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("GetLength")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("GetLength") + 1) - (size_t)(const void *)("GetLength") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "GetLength") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("GetLength") && ((size_t)(const void *)(("GetLength") + 1) - (size_t)(const void *)("GetLength") == 1) ? __builtin_strcmp (cmethod->name, "GetLength") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("GetLength"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("GetLength") && ((size_t)(const void *)(("GetLength") + 1) - (size_t)(const void *)("GetLength") == 1) && (__s2_len = __strlen_g (("GetLength")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "GetLength") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("GetLength"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("GetLength"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("GetLength"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("GetLength"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "GetLength")))); }) == 0 || __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("GetLowerBound") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("GetLowerBound")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("GetLowerBound") + 1) - (size_t)(const void *)("GetLowerBound") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "GetLowerBound") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("GetLowerBound") && ((size_t)(const void *)(("GetLowerBound") + 1) - (size_t)(const void *)("GetLowerBound") == 1) ? __builtin_strcmp (cmethod->name, "GetLowerBound") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("GetLowerBound"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("GetLowerBound") && ((size_t)(const void *)(("GetLowerBound") + 1) - (size_t)(const void *)("GetLowerBound") == 1) && (__s2_len = __strlen_g (("GetLowerBound")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "GetLowerBound") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("GetLowerBound"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("GetLowerBound"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("GetLowerBound"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("GetLowerBound"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "GetLowerBound")))); }) == 0) && args [1]->opcode == OP_ICONST && args [1]->data.op[0].const_val == 0) {
>   int dreg = alloc_ireg (cfg);
>   int bounds_reg = alloc_ireg_mp (cfg);
>   MonoBasicBlock *end_bb, *szarray_bb;
>   gboolean get_length = __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("GetLength") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("GetLength")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("GetLength") + 1) - (size_t)(const void *)("GetLength") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "GetLength") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("GetLength") && ((size_t)(const void *)(("GetLength") + 1) - (size_t)(const void *)("GetLength") == 1) ? __builtin_strcmp (cmethod->name, "GetLength") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("GetLength"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("GetLength") && ((size_t)(const void *)(("GetLength") + 1) - (size_t)(const void *)("GetLength") == 1) && (__s2_len = __strlen_g (("GetLength")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "GetLength") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("GetLength"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("GetLength"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("GetLength"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("GetLength"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "GetLength")))); }) == 0;
>
>   do { (end_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (end_bb)->block_num = cfg->num_bblocks++; } while (0);
>   do { (szarray_bb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (szarray_bb)->block_num = cfg->num_bblocks++; } while (0);
>
>   do { do { int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((args [0]->dreg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((((ins))))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((((ins)))))->data.op[0].const_val = (((((ins)))))->data.op[1].const_val = 0; (((((ins)))))->next = (((((ins)))))->prev = ((void *)0); (((((ins)))))->opcode = (((((OP_LOAD_MEMBASE))))); (((((ins)))))->flags = 0; (((((ins)))))->type = 0; (((((ins)))))->dreg = -1; do { ((((((ins))))))->sreg1 = ((((((ins))))))->sreg2 = ((((((ins))))))->sreg3 = -1; } while (0); (((((ins)))))->cil_code = (((((cfg)))))->ip; } while (0); ((((ins))))->dreg = ((((bounds_reg)))); ((((ins))))->sreg1 = ((((args [0]->dreg)))); ((((ins))))->data.op[0].const_val = ((((__builtin_offsetof (MonoArray, bounds))))); ((((ins))))->type = STACK_I4; } while (0); (((ins)))->flags = (__ins_flags); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0)
>                                                               ;
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = bounds_reg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_IBEQ)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_IBEQ) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (szarray_bb); mono_link_bblock ((cfg), (cfg)->cbb, (szarray_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (szarray_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (szarray_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>
>   if (get_length)
>    do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LOADI4_MEMBASE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = ((dreg)); ((ins))->sreg1 = ((bounds_reg)); ((ins))->data.op[0].const_val = ((__builtin_offsetof (MonoArrayBounds, length))); ((ins))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0)
>                                                                  ;
>   else
>    do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LOADI4_MEMBASE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = ((dreg)); ((ins))->sreg1 = ((bounds_reg)); ((ins))->data.op[0].const_val = ((__builtin_offsetof (MonoArrayBounds, lower_bound))); ((ins))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0)
>                                                                       ;
>   do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_BR)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_BR) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (end_bb); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (end_bb); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>   do { do { if (((szarray_bb))->cil_code) { (cfg)->cil_offset_to_bb [((szarray_bb))->cil_code - (cfg)->cil_start] = ((szarray_bb)); } ((szarray_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (szarray_bb); mono_link_bblock ((cfg), (cfg)->cbb, (szarray_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (szarray_bb)); (cfg)->cbb->next_bb = (szarray_bb); (cfg)->cbb = (szarray_bb); } while (0);
>
>   if (get_length)
>    do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LOADI4_MEMBASE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = ((dreg)); ((ins))->sreg1 = ((args [0]->dreg)); ((ins))->data.op[0].const_val = ((__builtin_offsetof (MonoArray, max_length))); ((ins))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0)
>                                                                    ;
>   else
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_ICONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = dreg; inst->data.op[0].const_val = 0; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { do { if (((end_bb))->cil_code) { (cfg)->cil_offset_to_bb [((end_bb))->cil_code - (cfg)->cil_start] = ((end_bb)); } ((end_bb))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (end_bb); mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (end_bb)); (cfg)->cbb->next_bb = (end_bb); (cfg)->cbb = (end_bb); } while (0);
>
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_MOVE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = (dreg); ((ins))->sreg1 = (dreg); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ins->type = STACK_I4;
>
>   return ins;
>  }
>
>
>   if (cmethod->name [0] != 'g')
>    return ((void *)0);
>
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("get_Rank") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("get_Rank")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("get_Rank") + 1) - (size_t)(const void *)("get_Rank") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "get_Rank") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("get_Rank") && ((size_t)(const void *)(("get_Rank") + 1) - (size_t)(const void *)("get_Rank") == 1) ? __builtin_strcmp (cmethod->name, "get_Rank") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("get_Rank"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("get_Rank") && ((size_t)(const void *)(("get_Rank") + 1) - (size_t)(const void *)("get_Rank") == 1) && (__s2_len = __strlen_g (("get_Rank")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "get_Rank") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("get_Rank"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("get_Rank"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("get_Rank"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("get_Rank"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "get_Rank")))); }) == 0) {
>   int dreg = alloc_ireg (cfg);
>   int vtable_reg = alloc_preg (cfg);
>   do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if (((cfg))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (((args [0]->dreg))); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((((cfg)))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((((cfg)))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((((cfg)))))->cbb)->last_ins) { ((((((cfg)))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((((cfg)))))->cbb)->last_ins; ((((((cfg)))))->cbb)->last_ins = (((inst))); } else { ((((((cfg)))))->cbb)->code = ((((((cfg)))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((cfg)->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = ((((OP_LOAD_MEMBASE)))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = ((((cfg))))->ip; } while (0); ((inst))->dreg = (((vtable_reg))); ((inst))->sreg1 = (((args [0]->dreg))); ((inst))->data.op[0].const_val = (((__builtin_offsetof (MonoObject, vtable)))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0)
>                                                                  ;
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LOADU1_MEMBASE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = ((dreg)); ((ins))->sreg1 = ((vtable_reg)); ((ins))->data.op[0].const_val = ((__builtin_offsetof (MonoVTable, rank))); ((ins))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0)
>                                                          ;
>   type_from_op (ins, ((void *)0), ((void *)0));
>
>   return ins;
>  } else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("get_Length") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("get_Length")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("get_Length") + 1) - (size_t)(const void *)("get_Length") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "get_Length") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("get_Length") && ((size_t)(const void *)(("get_Length") + 1) - (size_t)(const void *)("get_Length") == 1) ? __builtin_strcmp (cmethod->name, "get_Length") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("get_Length"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("get_Length") && ((size_t)(const void *)(("get_Length") + 1) - (size_t)(const void *)("get_Length") == 1) && (__s2_len = __strlen_g (("get_Length")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "get_Length") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("get_Length"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("get_Length"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("get_Length"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("get_Length"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "get_Length")))); }) == 0) {
>   int dreg = alloc_ireg (cfg);
>
>   do { do { int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((args [0]->dreg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((((ins))))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((((ins)))))->data.op[0].const_val = (((((ins)))))->data.op[1].const_val = 0; (((((ins)))))->next = (((((ins)))))->prev = ((void *)0); (((((ins)))))->opcode = (((((OP_LOADI4_MEMBASE))))); (((((ins)))))->flags = 0; (((((ins)))))->type = 0; (((((ins)))))->dreg = -1; do { ((((((ins))))))->sreg1 = ((((((ins))))))->sreg2 = ((((((ins))))))->sreg3 = -1; } while (0); (((((ins)))))->cil_code = (((((cfg)))))->ip; } while (0); ((((ins))))->dreg = ((((dreg)))); ((((ins))))->sreg1 = ((((args [0]->dreg)))); ((((ins))))->data.op[0].const_val = ((((__builtin_offsetof (MonoArray, max_length))))); ((((ins))))->type = STACK_I4; } while (0); (((ins)))->flags = (__ins_flags); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0)
>                                                                   ;
>   type_from_op (ins, ((void *)0), ((void *)0));
>
>   return ins;
>  } else
>   return ((void *)0);
> } else if (cmethod->klass == runtime_helpers_class) {
>
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("get_OffsetToStringData") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("get_OffsetToStringData")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("get_OffsetToStringData") + 1) - (size_t)(const void *)("get_OffsetToStringData") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "get_OffsetToStringData") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("get_OffsetToStringData") && ((size_t)(const void *)(("get_OffsetToStringData") + 1) - (size_t)(const void *)("get_OffsetToStringData") == 1) ? __builtin_strcmp (cmethod->name, "get_OffsetToStringData") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("get_OffsetToStringData"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("get_OffsetToStringData") && ((size_t)(const void *)(("get_OffsetToStringData") + 1) - (size_t)(const void *)("get_OffsetToStringData") == 1) && (__s2_len = __strlen_g (("get_OffsetToStringData")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "get_OffsetToStringData") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("get_OffsetToStringData"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("get_OffsetToStringData"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("get_OffsetToStringData"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("get_OffsetToStringData"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "get_OffsetToStringData")))); }) == 0) {
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_ICONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].const_val = ((__builtin_offsetof (MonoString, chars))); ((ins))->type = STACK_I4; ((ins))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   return ins;
>  } else
>   return ((void *)0);
> } else if (cmethod->klass == mono_defaults.thread_class) {
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("SpinWait_nop") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("SpinWait_nop")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("SpinWait_nop") + 1) - (size_t)(const void *)("SpinWait_nop") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "SpinWait_nop") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("SpinWait_nop") && ((size_t)(const void *)(("SpinWait_nop") + 1) - (size_t)(const void *)("SpinWait_nop") == 1) ? __builtin_strcmp (cmethod->name, "SpinWait_nop") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("SpinWait_nop"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("SpinWait_nop") && ((size_t)(const void *)(("SpinWait_nop") + 1) - (size_t)(const void *)("SpinWait_nop") == 1) && (__s2_len = __strlen_g (("SpinWait_nop")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "SpinWait_nop") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("SpinWait_nop"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("SpinWait_nop"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("SpinWait_nop"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("SpinWait_nop"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "SpinWait_nop")))); }) == 0) {
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_RELAXED_NOP); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>   return ins;
>  } else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("MemoryBarrier") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("MemoryBarrier")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("MemoryBarrier") + 1) - (size_t)(const void *)("MemoryBarrier") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "MemoryBarrier") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("MemoryBarrier") && ((size_t)(const void *)(("MemoryBarrier") + 1) - (size_t)(const void *)("MemoryBarrier") == 1) ? __builtin_strcmp (cmethod->name, "MemoryBarrier") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("MemoryBarrier"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("MemoryBarrier") && ((size_t)(const void *)(("MemoryBarrier") + 1) - (size_t)(const void *)("MemoryBarrier") == 1) && (__s2_len = __strlen_g (("MemoryBarrier")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "MemoryBarrier") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("MemoryBarrier"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("MemoryBarrier"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("MemoryBarrier"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("MemoryBarrier"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "MemoryBarrier")))); }) == 0) {
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_MEMORY_BARRIER); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>   return ins;
>  }
> } else if (cmethod->klass == mono_defaults.monitor_class) {
># 4505 "method-to-ir.c"
> } else if (cmethod->klass->image == mono_defaults.corlib &&
>      (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->klass->name_space) && __builtin_constant_p ("System.Threading") && (__s1_len = __strlen_g ((cmethod->klass->name_space)), __s2_len = __strlen_g (("System.Threading")), (!((size_t)(const void *)((cmethod->klass->name_space) + 1) - (size_t)(const void *)(cmethod->klass->name_space) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("System.Threading") + 1) - (size_t)(const void *)("System.Threading") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->klass->name_space, "System.Threading") : (__builtin_constant_p (cmethod->klass->name_space) && ((size_t)(const void *)((cmethod->klass->name_space) + 1) - (size_t)(const void *)(cmethod->klass->name_space) == 1) && (__s1_len = __strlen_g ((cmethod->klass->name_space)), __s1_len < 4) ? (__builtin_constant_p ("System.Threading") && ((size_t)(const void *)(("System.Threading") + 1) - (size_t)(const void *)("System.Threading") == 1) ? __builtin_strcmp (cmethod->klass->name_space, "System.Threading") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("System.Threading"); int __result = (((const unsigned char *) (const char *) (cmethod->klass->name_space))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->klass->name_space))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->klass->name_space))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->klass->name_space))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("System.Threading") && ((size_t)(const void *)(("System.Threading") + 1) - (size_t)(const void *)("System.Threading") == 1) && (__s2_len = __strlen_g (("System.Threading")), __s2_len < 4) ? (__builtin_constant_p (cmethod->klass->name_space) && ((size_t)(const void *)((cmethod->klass->name_space) + 1) - (size_t)(const void *)(cmethod->klass->name_space) == 1) ? __builtin_strcmp (cmethod->klass->name_space, "System.Threading") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->klass->name_space); int __result = (((const unsigned char *) (const char *) ("System.Threading"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("System.Threading"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("System.Threading"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("System.Threading"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->klass->name_space, "System.Threading")))); }) == 0) &&
>      (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->klass->name) && __builtin_constant_p ("Interlocked") && (__s1_len = __strlen_g ((cmethod->klass->name)), __s2_len = __strlen_g (("Interlocked")), (!((size_t)(const void *)((cmethod->klass->name) + 1) - (size_t)(const void *)(cmethod->klass->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Interlocked") + 1) - (size_t)(const void *)("Interlocked") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->klass->name, "Interlocked") : (__builtin_constant_p (cmethod->klass->name) && ((size_t)(const void *)((cmethod->klass->name) + 1) - (size_t)(const void *)(cmethod->klass->name) == 1) && (__s1_len = __strlen_g ((cmethod->klass->name)), __s1_len < 4) ? (__builtin_constant_p ("Interlocked") && ((size_t)(const void *)(("Interlocked") + 1) - (size_t)(const void *)("Interlocked") == 1) ? __builtin_strcmp (cmethod->klass->name, "Interlocked") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Interlocked"); int __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Interlocked") && ((size_t)(const void *)(("Interlocked") + 1) - (size_t)(const void *)("Interlocked") == 1) && (__s2_len = __strlen_g (("Interlocked")), __s2_len < 4) ? (__builtin_constant_p (cmethod->klass->name) && ((size_t)(const void *)((cmethod->klass->name) + 1) - (size_t)(const void *)(cmethod->klass->name) == 1) ? __builtin_strcmp (cmethod->klass->name, "Interlocked") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->klass->name); int __result = (((const unsigned char *) (const char *) ("Interlocked"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Interlocked"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Interlocked"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Interlocked"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->klass->name, "Interlocked")))); }) == 0)) {
>  ins = ((void *)0);
>
>
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("Read") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("Read")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Read") + 1) - (size_t)(const void *)("Read") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "Read") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("Read") && ((size_t)(const void *)(("Read") + 1) - (size_t)(const void *)("Read") == 1) ? __builtin_strcmp (cmethod->name, "Read") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Read"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Read") && ((size_t)(const void *)(("Read") + 1) - (size_t)(const void *)("Read") == 1) && (__s2_len = __strlen_g (("Read")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "Read") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("Read"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Read"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Read"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Read"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "Read")))); }) == 0 && (fsig->params [0]->type == MONO_TYPE_I8)) {
>
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_LOADI8_MEMBASE); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ins->dreg = mono_alloc_preg (cfg);
>   ins->sreg1 = args [0]->dreg;
>   ins->data.op[0].const_val = 0;
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>  }
>
>
>
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("Increment") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("Increment")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Increment") + 1) - (size_t)(const void *)("Increment") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "Increment") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("Increment") && ((size_t)(const void *)(("Increment") + 1) - (size_t)(const void *)("Increment") == 1) ? __builtin_strcmp (cmethod->name, "Increment") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Increment"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Increment") && ((size_t)(const void *)(("Increment") + 1) - (size_t)(const void *)("Increment") == 1) && (__s2_len = __strlen_g (("Increment")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "Increment") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("Increment"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Increment"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Increment"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Increment"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "Increment")))); }) == 0) {
>   MonoInst *ins_iconst;
>   guint32 opcode = 0;
>
>   if (fsig->params [0]->type == MONO_TYPE_I4)
>    opcode = OP_ATOMIC_ADD_NEW_I4;
>
>   else if (fsig->params [0]->type == MONO_TYPE_I8)
>    opcode = OP_ATOMIC_ADD_NEW_I8;
>
>   if (opcode) {
>    do { (ins_iconst) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins_iconst)->data.op[0].const_val = (ins_iconst)->data.op[1].const_val = 0; (ins_iconst)->next = (ins_iconst)->prev = ((void *)0); (ins_iconst)->opcode = (OP_ICONST); (ins_iconst)->flags = 0; (ins_iconst)->type = 0; (ins_iconst)->dreg = -1; do { ((ins_iconst))->sreg1 = ((ins_iconst))->sreg2 = ((ins_iconst))->sreg3 = -1; } while (0); (ins_iconst)->cil_code = (cfg)->ip; } while (0);
>    ins_iconst->data.op[0].const_val = 1;
>    ins_iconst->dreg = mono_alloc_ireg (cfg);
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins_iconst); (ins_iconst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins_iconst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins_iconst); } } while (0);
>
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (opcode); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->dreg = mono_alloc_ireg (cfg);
>    ins->sreg1 = args [0]->dreg;
>    ins->data.op[0].const_val = 0;
>    ins->sreg2 = ins_iconst->dreg;
>    ins->type = (opcode == OP_ATOMIC_ADD_NEW_I4) ? STACK_I4 : STACK_I8;
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>   }
>  } else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("Decrement") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("Decrement")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Decrement") + 1) - (size_t)(const void *)("Decrement") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "Decrement") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("Decrement") && ((size_t)(const void *)(("Decrement") + 1) - (size_t)(const void *)("Decrement") == 1) ? __builtin_strcmp (cmethod->name, "Decrement") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Decrement"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Decrement") && ((size_t)(const void *)(("Decrement") + 1) - (size_t)(const void *)("Decrement") == 1) && (__s2_len = __strlen_g (("Decrement")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "Decrement") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("Decrement"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Decrement"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Decrement"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Decrement"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "Decrement")))); }) == 0) {
>   MonoInst *ins_iconst;
>   guint32 opcode = 0;
>
>   if (fsig->params [0]->type == MONO_TYPE_I4)
>    opcode = OP_ATOMIC_ADD_NEW_I4;
>
>   else if (fsig->params [0]->type == MONO_TYPE_I8)
>    opcode = OP_ATOMIC_ADD_NEW_I8;
>
>   if (opcode) {
>    do { (ins_iconst) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins_iconst)->data.op[0].const_val = (ins_iconst)->data.op[1].const_val = 0; (ins_iconst)->next = (ins_iconst)->prev = ((void *)0); (ins_iconst)->opcode = (OP_ICONST); (ins_iconst)->flags = 0; (ins_iconst)->type = 0; (ins_iconst)->dreg = -1; do { ((ins_iconst))->sreg1 = ((ins_iconst))->sreg2 = ((ins_iconst))->sreg3 = -1; } while (0); (ins_iconst)->cil_code = (cfg)->ip; } while (0);
>    ins_iconst->data.op[0].const_val = -1;
>    ins_iconst->dreg = mono_alloc_ireg (cfg);
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins_iconst); (ins_iconst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins_iconst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins_iconst); } } while (0);
>
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (opcode); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->dreg = mono_alloc_ireg (cfg);
>    ins->sreg1 = args [0]->dreg;
>    ins->data.op[0].const_val = 0;
>    ins->sreg2 = ins_iconst->dreg;
>    ins->type = (opcode == OP_ATOMIC_ADD_NEW_I4) ? STACK_I4 : STACK_I8;
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>   }
>  } else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("Add") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("Add")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Add") + 1) - (size_t)(const void *)("Add") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "Add") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("Add") && ((size_t)(const void *)(("Add") + 1) - (size_t)(const void *)("Add") == 1) ? __builtin_strcmp (cmethod->name, "Add") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Add"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Add") && ((size_t)(const void *)(("Add") + 1) - (size_t)(const void *)("Add") == 1) && (__s2_len = __strlen_g (("Add")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "Add") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("Add"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Add"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Add"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Add"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "Add")))); }) == 0) {
>   guint32 opcode = 0;
>
>   if (fsig->params [0]->type == MONO_TYPE_I4)
>    opcode = OP_ATOMIC_ADD_NEW_I4;
>
>   else if (fsig->params [0]->type == MONO_TYPE_I8)
>    opcode = OP_ATOMIC_ADD_NEW_I8;
>
>
>   if (opcode) {
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (opcode); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->dreg = mono_alloc_ireg (cfg);
>    ins->sreg1 = args [0]->dreg;
>    ins->data.op[0].const_val = 0;
>    ins->sreg2 = args [1]->dreg;
>    ins->type = (opcode == OP_ATOMIC_ADD_NEW_I4) ? STACK_I4 : STACK_I8;
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>   }
>  }
>
>
>
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("Exchange") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("Exchange")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Exchange") + 1) - (size_t)(const void *)("Exchange") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "Exchange") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("Exchange") && ((size_t)(const void *)(("Exchange") + 1) - (size_t)(const void *)("Exchange") == 1) ? __builtin_strcmp (cmethod->name, "Exchange") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Exchange"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Exchange") && ((size_t)(const void *)(("Exchange") + 1) - (size_t)(const void *)("Exchange") == 1) && (__s2_len = __strlen_g (("Exchange")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "Exchange") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("Exchange"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Exchange"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Exchange"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Exchange"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "Exchange")))); }) == 0) {
>   guint32 opcode;
>   gboolean is_ref = fsig->params [0]->type == MONO_TYPE_OBJECT;
>
>   if (fsig->params [0]->type == MONO_TYPE_I4)
>    opcode = OP_ATOMIC_EXCHANGE_I4;
>
>   else if (is_ref || (fsig->params [0]->type == MONO_TYPE_I8) ||
>     (fsig->params [0]->type == MONO_TYPE_I))
>    opcode = OP_ATOMIC_EXCHANGE_I8;
>
>
>
>
>   else
>    return ((void *)0);
>
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (opcode); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ins->dreg = is_ref ? mono_alloc_ireg_ref (cfg) : mono_alloc_ireg (cfg);
>   ins->sreg1 = args [0]->dreg;
>   ins->data.op[0].const_val = 0;
>   ins->sreg2 = args [1]->dreg;
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>
>   switch (fsig->params [0]->type) {
>   case MONO_TYPE_I4:
>    ins->type = STACK_I4;
>    break;
>   case MONO_TYPE_I8:
>   case MONO_TYPE_I:
>    ins->type = STACK_I8;
>    break;
>   case MONO_TYPE_OBJECT:
>    ins->type = STACK_OBJ;
>    break;
>   default:
>    do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 4629); } while (0);
>   }
>
>   if (cfg->gen_write_barriers && is_ref)
>    emit_write_barrier (cfg, args [0], args [1], -1);
>  }
># 4671 "method-to-ir.c"
>  if (ins)
>   return ins;
> } else if (cmethod->klass->image == mono_defaults.corlib) {
>  if (cmethod->name [0] == 'B' && __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("Break") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("Break")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Break") + 1) - (size_t)(const void *)("Break") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "Break") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("Break") && ((size_t)(const void *)(("Break") + 1) - (size_t)(const void *)("Break") == 1) ? __builtin_strcmp (cmethod->name, "Break") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Break"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Break") && ((size_t)(const void *)(("Break") + 1) - (size_t)(const void *)("Break") == 1) && (__s2_len = __strlen_g (("Break")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "Break") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("Break"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Break"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Break"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Break"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "Break")))); }) == 0
>    && __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->klass->name) && __builtin_constant_p ("Debugger") && (__s1_len = __strlen_g ((cmethod->klass->name)), __s2_len = __strlen_g (("Debugger")), (!((size_t)(const void *)((cmethod->klass->name) + 1) - (size_t)(const void *)(cmethod->klass->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Debugger") + 1) - (size_t)(const void *)("Debugger") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->klass->name, "Debugger") : (__builtin_constant_p (cmethod->klass->name) && ((size_t)(const void *)((cmethod->klass->name) + 1) - (size_t)(const void *)(cmethod->klass->name) == 1) && (__s1_len = __strlen_g ((cmethod->klass->name)), __s1_len < 4) ? (__builtin_constant_p ("Debugger") && ((size_t)(const void *)(("Debugger") + 1) - (size_t)(const void *)("Debugger") == 1) ? __builtin_strcmp (cmethod->klass->name, "Debugger") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Debugger"); int __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Debugger") && ((size_t)(const void *)(("Debugger") + 1) - (size_t)(const void *)("Debugger") == 1) && (__s2_len = __strlen_g (("Debugger")), __s2_len < 4) ? (__builtin_constant_p (cmethod->klass->name) && ((size_t)(const void *)((cmethod->klass->name) + 1) - (size_t)(const void *)(cmethod->klass->name) == 1) ? __builtin_strcmp (cmethod->klass->name, "Debugger") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->klass->name); int __result = (((const unsigned char *) (const char *) ("Debugger"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Debugger"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Debugger"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Debugger"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->klass->name, "Debugger")))); }) == 0) {
>   if (should_insert_brekpoint (cfg->method))
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BREAK); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   else
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_NOP); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>   return ins;
>  }
>  if (cmethod->name [0] == 'g' && __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("get_IsRunningOnWindows") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("get_IsRunningOnWindows")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("get_IsRunningOnWindows") + 1) - (size_t)(const void *)("get_IsRunningOnWindows") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "get_IsRunningOnWindows") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("get_IsRunningOnWindows") && ((size_t)(const void *)(("get_IsRunningOnWindows") + 1) - (size_t)(const void *)("get_IsRunningOnWindows") == 1) ? __builtin_strcmp (cmethod->name, "get_IsRunningOnWindows") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("get_IsRunningOnWindows"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("get_IsRunningOnWindows") && ((size_t)(const void *)(("get_IsRunningOnWindows") + 1) - (size_t)(const void *)("get_IsRunningOnWindows") == 1) && (__s2_len = __strlen_g (("get_IsRunningOnWindows")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "get_IsRunningOnWindows") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("get_IsRunningOnWindows"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("get_IsRunningOnWindows"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("get_IsRunningOnWindows"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("get_IsRunningOnWindows"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "get_IsRunningOnWindows")))); }) == 0
>    && __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->klass->name) && __builtin_constant_p ("Environment") && (__s1_len = __strlen_g ((cmethod->klass->name)), __s2_len = __strlen_g (("Environment")), (!((size_t)(const void *)((cmethod->klass->name) + 1) - (size_t)(const void *)(cmethod->klass->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Environment") + 1) - (size_t)(const void *)("Environment") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->klass->name, "Environment") : (__builtin_constant_p (cmethod->klass->name) && ((size_t)(const void *)((cmethod->klass->name) + 1) - (size_t)(const void *)(cmethod->klass->name) == 1) && (__s1_len = __strlen_g ((cmethod->klass->name)), __s1_len < 4) ? (__builtin_constant_p ("Environment") && ((size_t)(const void *)(("Environment") + 1) - (size_t)(const void *)("Environment") == 1) ? __builtin_strcmp (cmethod->klass->name, "Environment") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Environment"); int __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Environment") && ((size_t)(const void *)(("Environment") + 1) - (size_t)(const void *)("Environment") == 1) && (__s2_len = __strlen_g (("Environment")), __s2_len < 4) ? (__builtin_constant_p (cmethod->klass->name) && ((size_t)(const void *)((cmethod->klass->name) + 1) - (size_t)(const void *)(cmethod->klass->name) == 1) ? __builtin_strcmp (cmethod->klass->name, "Environment") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->klass->name); int __result = (((const unsigned char *) (const char *) ("Environment"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Environment"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Environment"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Environment"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->klass->name, "Environment")))); }) == 0) {
>
>
>
>                 do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_ICONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].const_val = ((0)); ((ins))->type = STACK_I4; ((ins))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>
>   return ins;
>  }
> } else if (cmethod->klass == mono_defaults.math_class) {
>
>
>
>
>
> }
># 4708 "method-to-ir.c"
> return mono_arch_emit_inst_for_method (cfg, cmethod, fsig, args);
>}
>
>
>
>
>
>inline static MonoInst*
>mini_redirect_call (MonoCompile *cfg, MonoMethod *method,
>     MonoMethodSignature *signature, MonoInst **args, MonoInst *this)
>{
> if (method->klass == mono_defaults.string_class) {
>
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (method->name) && __builtin_constant_p ("InternalAllocateStr") && (__s1_len = __strlen_g ((method->name)), __s2_len = __strlen_g (("InternalAllocateStr")), (!((size_t)(const void *)((method->name) + 1) - (size_t)(const void *)(method->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("InternalAllocateStr") + 1) - (size_t)(const void *)("InternalAllocateStr") == 1) || __s2_len >= 4)) ? __builtin_strcmp (method->name, "InternalAllocateStr") : (__builtin_constant_p (method->name) && ((size_t)(const void *)((method->name) + 1) - (size_t)(const void *)(method->name) == 1) && (__s1_len = __strlen_g ((method->name)), __s1_len < 4) ? (__builtin_constant_p ("InternalAllocateStr") && ((size_t)(const void *)(("InternalAllocateStr") + 1) - (size_t)(const void *)("InternalAllocateStr") == 1) ? __builtin_strcmp (method->name, "InternalAllocateStr") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("InternalAllocateStr"); int __result = (((const unsigned char *) (const char *) (method->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (method->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (method->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (method->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("InternalAllocateStr") && ((size_t)(const void *)(("InternalAllocateStr") + 1) - (size_t)(const void *)("InternalAllocateStr") == 1) && (__s2_len = __strlen_g (("InternalAllocateStr")), __s2_len < 4) ? (__builtin_constant_p (method->name) && ((size_t)(const void *)((method->name) + 1) - (size_t)(const void *)(method->name) == 1) ? __builtin_strcmp (method->name, "InternalAllocateStr") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (method->name); int __result = (((const unsigned char *) (const char *) ("InternalAllocateStr"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("InternalAllocateStr"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("InternalAllocateStr"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("InternalAllocateStr"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (method->name, "InternalAllocateStr")))); }) == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS) && !(cfg->opt & MONO_OPT_SHARED)) {
>   MonoInst *iargs [2];
>   MonoVTable *vtable = mono_class_vtable (cfg->domain, method->klass);
>   MonoMethod *managed_alloc = ((void *)0);
>
>   do { if (!(vtable)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 4726, "vtable"); } while (0);
>
>   managed_alloc = mono_gc_get_managed_allocator (vtable, 0);
>
>   if (!managed_alloc)
>    return ((void *)0);
>   do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].p = (cfg->compile_aot ? (gpointer)((vtable)->klass) : (vtable)); ((iargs [0]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_VTABLE); ((iargs [0]))->type = STACK_PTR; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>   iargs [1] = args [0];
>   return mono_emit_method_call (cfg, managed_alloc, iargs, this);
>  }
> }
> return ((void *)0);
>}
>
>static void
>mono_save_args (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **sp)
>{
> MonoInst *store, *temp;
> int i;
>
> for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
>  MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
># 4757 "method-to-ir.c"
>  temp = mono_compile_create_var (cfg, argtype, OP_LOCAL);
>  cfg->args [i] = temp;
>
>  do { do { do { ((((store)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((store))))->data.op[0].const_val = ((((store))))->data.op[1].const_val = 0; ((((store))))->next = ((((store))))->prev = ((void *)0); ((((store))))->opcode = (OP_MOVE); ((((store))))->flags = 0; ((((store))))->type = 0; ((((store))))->dreg = -1; do { (((((store)))))->sreg1 = (((((store)))))->sreg2 = (((((store)))))->sreg3 = -1; } while (0); ((((store))))->cil_code = ((((cfg))))->ip; } while (0); (((store)))->opcode = mono_type_to_regmove ((((cfg))), ((cfg)->arg_types [((i))])); (((store)))->klass = ((cfg)->args [((i))])->klass; (((store)))->sreg1 = (((*sp)))->dreg; (((store)))->dreg = ((cfg)->args [((i))])->dreg; if ((((store)))->opcode == OP_VMOVE) (((store)))->klass = mono_class_from_mono_type (((cfg)->arg_types [((i))])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((store)); ((store))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((store)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((store)); } } while (0); } while (0);
>  store->cil_code = sp [0]->cil_code;
>  sp++;
> }
>}
>
>
>
>
>
>static gboolean
>check_inline_called_method_name_limit (MonoMethod *called_method)
>{
> int strncmp_result;
> static char *limit = ((void *)0);
>
> if (limit == ((void *)0)) {
>  char *limit_string = getenv ("MONO_INLINE_CALLED_METHOD_NAME_LIMIT");
>
>  if (limit_string != ((void *)0))
>   limit = limit_string;
>  else
>   limit = (char *) "";
> }
>
> if (limit [0] != '\0') {
>  char *called_method_name = mono_method_full_name (called_method, 1);
>
>  strncmp_result = (__extension__ (__builtin_constant_p (__strlen_g ((limit))) && ((__builtin_constant_p (called_method_name) && __strlen_g ((called_method_name)) < ((size_t) (__strlen_g ((limit))))) || (__builtin_constant_p (limit) && __strlen_g ((limit)) < ((size_t) (__strlen_g ((limit)))))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (called_method_name) && __builtin_constant_p (limit) && (__s1_len = __strlen_g ((called_method_name)), __s2_len = __strlen_g ((limit)), (!((size_t)(const void *)((called_method_name) + 1) - (size_t)(const void *)(called_method_name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((limit) + 1) - (size_t)(const void *)(limit) == 1) || __s2_len >= 4)) ? __builtin_strcmp (called_method_name, limit) : (__builtin_constant_p (called_method_name) && ((size_t)(const void *)((called_method_name) + 1) - (size_t)(const void *)(called_method_name) == 1) && (__s1_len = __strlen_g ((called_method_name)), __s1_len < 4) ? (__builtin_constant_p (limit) && ((size_t)(const void *)((limit) + 1) - (size_t)(const void *)(limit) == 1) ? __builtin_strcmp (called_method_name, limit) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (limit); int __result = (((const unsigned char *) (const char *) (called_method_name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (called_method_name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (called_method_name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (called_method_name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (limit) && ((size_t)(const void *)((limit) + 1) - (size_t)(const void *)(limit) == 1) && (__s2_len = __strlen_g ((limit)), __s2_len < 4) ? (__builtin_constant_p (called_method_name) && ((size_t)(const void *)((called_method_name) + 1) - (size_t)(const void *)(called_method_name) == 1) ? __builtin_strcmp (called_method_name, limit) : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (called_method_name); int __result = (((const unsigned char *) (const char *) (limit))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (limit))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (limit))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (limit))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (called_method_name, limit)))); }) : strncmp (called_method_name, limit, __strlen_g ((limit)))));
>  monoeg_g_free (called_method_name);
>
>
>  return (strncmp_result == 0);
> } else {
>  return 1;
> }
>}
>
>
>
>static gboolean
>check_inline_caller_method_name_limit (MonoMethod *caller_method)
>{
> int strncmp_result;
> static char *limit = ((void *)0);
>
> if (limit == ((void *)0)) {
>  char *limit_string = getenv ("MONO_INLINE_CALLER_METHOD_NAME_LIMIT");
>  if (limit_string != ((void *)0)) {
>   limit = limit_string;
>  } else {
>   limit = (char *) "";
>  }
> }
>
> if (limit [0] != '\0') {
>  char *caller_method_name = mono_method_full_name (caller_method, 1);
>
>  strncmp_result = (__extension__ (__builtin_constant_p (__strlen_g ((limit))) && ((__builtin_constant_p (caller_method_name) && __strlen_g ((caller_method_name)) < ((size_t) (__strlen_g ((limit))))) || (__builtin_constant_p (limit) && __strlen_g ((limit)) < ((size_t) (__strlen_g ((limit)))))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (caller_method_name) && __builtin_constant_p (limit) && (__s1_len = __strlen_g ((caller_method_name)), __s2_len = __strlen_g ((limit)), (!((size_t)(const void *)((caller_method_name) + 1) - (size_t)(const void *)(caller_method_name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((limit) + 1) - (size_t)(const void *)(limit) == 1) || __s2_len >= 4)) ? __builtin_strcmp (caller_method_name, limit) : (__builtin_constant_p (caller_method_name) && ((size_t)(const void *)((caller_method_name) + 1) - (size_t)(const void *)(caller_method_name) == 1) && (__s1_len = __strlen_g ((caller_method_name)), __s1_len < 4) ? (__builtin_constant_p (limit) && ((size_t)(const void *)((limit) + 1) - (size_t)(const void *)(limit) == 1) ? __builtin_strcmp (caller_method_name, limit) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (limit); int __result = (((const unsigned char *) (const char *) (caller_method_name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (caller_method_name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (caller_method_name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (caller_method_name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (limit) && ((size_t)(const void *)((limit) + 1) - (size_t)(const void *)(limit) == 1) && (__s2_len = __strlen_g ((limit)), __s2_len < 4) ? (__builtin_constant_p (caller_method_name) && ((size_t)(const void *)((caller_method_name) + 1) - (size_t)(const void *)(caller_method_name) == 1) ? __builtin_strcmp (caller_method_name, limit) : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (caller_method_name); int __result = (((const unsigned char *) (const char *) (limit))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (limit))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (limit))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (limit))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (caller_method_name, limit)))); }) : strncmp (caller_method_name, limit, __strlen_g ((limit)))));
>  monoeg_g_free (caller_method_name);
>
>
>  return (strncmp_result == 0);
> } else {
>  return 1;
> }
>}
>
>
>static void
>emit_init_rvar (MonoCompile *cfg, MonoInst *rvar, MonoType *rtype)
>{
> static double r8_0 = 0.0;
> MonoInst *ins;
>
> switch (rvar->type) {
> case STACK_I4:
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_ICONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = rvar->dreg; inst->data.op[0].const_val = 0; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  break;
> case STACK_I8:
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_I8CONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = rvar->dreg; inst->data.i8const = 0; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  break;
> case STACK_PTR:
> case STACK_MP:
> case STACK_OBJ:
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_I8CONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = rvar->dreg; (inst)->data.op[0].p = (0); (inst)->type = STACK_PTR; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  break;
> case STACK_R8:
>  do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_R8CONST); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>  ins->type = STACK_R8;
>  ins->data.op[0].p = (void*)&r8_0;
>  ins->dreg = rvar->dreg;
>  do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>  break;
> case STACK_VTYPE:
>  do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((0) ? OP_XZERO : OP_VZERO); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = rvar->dreg; (inst)->type = STACK_VTYPE; (inst)->klass = (mono_class_from_mono_type (rtype)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  break;
> default:
>  do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 4858); } while (0);
> }
>}
>
>static int
>inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
>  guchar *ip, guint real_offset, GList *dont_inline, gboolean inline_always)
>{
> MonoInst *ins, *rvar = ((void *)0);
> MonoMethodHeader *cheader;
> MonoBasicBlock *ebblock, *sbblock;
> int i, costs;
> MonoMethod *prev_inlined_method;
> MonoInst **prev_locals, **prev_args;
> MonoType **prev_arg_types;
> guint prev_real_offset;
> GHashTable *prev_cbb_hash;
> MonoBasicBlock **prev_cil_offset_to_bb;
> MonoBasicBlock *prev_cbb;
> unsigned char* prev_cil_start;
> guint32 prev_cil_offset_to_bb_len;
> MonoMethod *prev_current_method;
> MonoGenericContext *prev_generic_context;
> gboolean ret_var_set, prev_ret_var_set, virtual = 0;
>
> do { if (!(cfg->exception_type == MONO_EXCEPTION_NONE)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 4883, "cfg->exception_type == MONO_EXCEPTION_NONE"); } while (0);
>
>
> if ((! inline_always) && ! check_inline_called_method_name_limit (cmethod))
>  return 0;
>
>
> if ((! inline_always) && ! check_inline_caller_method_name_limit (cfg->method))
>  return 0;
>
>
> if (cfg->verbose_level > 2)
>  printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, 1), mono_method_full_name (cmethod, 1));
>
> if (!cmethod->inline_info) {
>  mono_jit_stats.inlineable_methods++;
>  cmethod->inline_info = 1;
> }
>
>
> cheader = mono_method_get_header (cmethod);
>
> if (cheader == ((void *)0) || mono_loader_get_last_error ()) {
>  MonoLoaderError *error = mono_loader_get_last_error ();
>
>  if (cheader)
>   mono_metadata_free_mh (cheader);
>  if (inline_always && error)
>   mono_cfg_set_exception (cfg, error->exception_type);
>
>  mono_loader_clear_error ();
>  return 0;
> }
>
>
> if (mono_compile_is_broken (cfg, cmethod, 0)) {
>  mono_metadata_free_mh (cheader);
>  return 0;
> }
>
>
> if (!mono_type_is_void (fsig->ret)) {
>  rvar = mono_compile_create_var (cfg, fsig->ret, OP_LOCAL);
> }
>
> prev_locals = cfg->locals;
> cfg->locals = mono_mempool_alloc0 (cfg->mempool, cheader->num_locals * sizeof (MonoInst*));
> for (i = 0; i < cheader->num_locals; ++i)
>  cfg->locals [i] = mono_compile_create_var (cfg, cheader->locals [i], OP_LOCAL);
>
>
>
> do { (sbblock) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (sbblock)->block_num = cfg->num_bblocks++; } while (0);
> sbblock->real_offset = real_offset;
>
> do { (ebblock) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (ebblock)->block_num = cfg->num_bblocks++; } while (0);
> ebblock->block_num = cfg->num_bblocks++;
> ebblock->real_offset = real_offset;
>
> prev_args = cfg->args;
> prev_arg_types = cfg->arg_types;
> prev_inlined_method = cfg->inlined_method;
> cfg->inlined_method = cmethod;
> cfg->ret_var_set = 0;
> cfg->inline_depth ++;
> prev_real_offset = cfg->real_offset;
> prev_cbb_hash = cfg->cbb_hash;
> prev_cil_offset_to_bb = cfg->cil_offset_to_bb;
> prev_cil_offset_to_bb_len = cfg->cil_offset_to_bb_len;
> prev_cil_start = cfg->cil_start;
> prev_cbb = cfg->cbb;
> prev_current_method = cfg->current_method;
> prev_generic_context = cfg->generic_context;
> prev_ret_var_set = cfg->ret_var_set;
>
> if (*ip == CEE_CALLVIRT && !(cmethod->flags & 0x0010))
>  virtual = 1;
>
> costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, virtual);
>
> ret_var_set = cfg->ret_var_set;
>
> cfg->inlined_method = prev_inlined_method;
> cfg->real_offset = prev_real_offset;
> cfg->cbb_hash = prev_cbb_hash;
> cfg->cil_offset_to_bb = prev_cil_offset_to_bb;
> cfg->cil_offset_to_bb_len = prev_cil_offset_to_bb_len;
> cfg->cil_start = prev_cil_start;
> cfg->locals = prev_locals;
> cfg->args = prev_args;
> cfg->arg_types = prev_arg_types;
> cfg->current_method = prev_current_method;
> cfg->generic_context = prev_generic_context;
> cfg->ret_var_set = prev_ret_var_set;
> cfg->inline_depth --;
>
> if ((costs >= 0 && costs < 60) || inline_always) {
>  if (cfg->verbose_level > 2)
>   printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, 1), mono_method_full_name (cmethod, 1));
>
>  mono_jit_stats.inlined_methods++;
>
>
>  do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_NOP); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>  do { if ((prev_cbb)->last_ins) { (prev_cbb)->last_ins->next = (ins); (ins)->prev = (prev_cbb)->last_ins; (prev_cbb)->last_ins = (ins); } else { (prev_cbb)->code = (prev_cbb)->last_ins = (ins); } } while (0);
>
>  prev_cbb->next_bb = sbblock;
>  link_bblock (cfg, prev_cbb, sbblock);
>
>
>
>
>
>  mono_merge_basic_blocks (cfg, prev_cbb, sbblock);
>
>  if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
>   mono_merge_basic_blocks (cfg, prev_cbb, prev_cbb->out_bb [0]);
>
>  if ((ebblock->in_count == 1) && ebblock->in_bb [0]->out_count == 1) {
>   MonoBasicBlock *prev = ebblock->in_bb [0];
>   mono_merge_basic_blocks (cfg, prev, ebblock);
>   cfg->cbb = prev;
>   if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
>    mono_merge_basic_blocks (cfg, prev_cbb, prev);
>    cfg->cbb = prev_cbb;
>   }
>  } else {
>
>
>
>
>   if (rvar) {
>    MonoBasicBlock *bb;
>
>    for (i = 0; i < ebblock->in_count; ++i) {
>     bb = ebblock->in_bb [i];
>
>     if (bb->last_ins && bb->last_ins->opcode == OP_NOT_REACHED) {
>      cfg->cbb = bb;
>
>      emit_init_rvar (cfg, rvar, fsig->ret);
>     }
>    }
>   }
>
>   cfg->cbb = ebblock;
>  }
>
>  if (rvar) {
>
>
>
>
>   if (!ret_var_set)
>    emit_init_rvar (cfg, rvar, fsig->ret);
>
>   do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((rvar->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((rvar->data.op[0].const_val))]->data.op[1].vtype), (((ins)))); (((ins)))->klass = ((cfg))->varinfo [((rvar->data.op[0].const_val))]->klass; (((ins)))->sreg1 = ((cfg))->varinfo [((rvar->data.op[0].const_val))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((rvar->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   *sp++ = ins;
>  }
>  cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, cheader);
>  return costs + 1;
> } else {
>  if (cfg->verbose_level > 2)
>   printf ("INLINE ABORTED %s\n", mono_method_full_name (cmethod, 1));
>  cfg->exception_type = MONO_EXCEPTION_NONE;
>  mono_loader_clear_error ();
>
>
>  cfg->cbb = prev_cbb;
> }
> cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, cheader);
> return 0;
>}
># 5092 "method-to-ir.c"
>static gboolean
>ip_in_bb (MonoCompile *cfg, MonoBasicBlock *bb, const guint8* ip)
>{
> MonoBasicBlock *b = cfg->cil_offset_to_bb [ip - cfg->cil_start];
>
> return b == ((void *)0) || b == bb;
>}
>
>static int
>get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
>{
> unsigned char *ip = start;
> unsigned char *target;
> int i;
> guint cli_addr;
> MonoBasicBlock *bblock;
> const MonoOpcode *opcode;
>
> while (ip < end) {
>  cli_addr = ip - start;
>  i = mono_opcode_value ((const guint8 **)&ip, end);
>  if (i < 0)
>   do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>  opcode = &mono_opcodes [i];
>  switch (opcode->argument) {
>  case MonoInlineNone:
>   ip++;
>   break;
>  case MonoInlineString:
>  case MonoInlineType:
>  case MonoInlineField:
>  case MonoInlineMethod:
>  case MonoInlineTok:
>  case MonoInlineSig:
>  case MonoShortInlineR:
>  case MonoInlineI:
>   ip += 5;
>   break;
>  case MonoInlineVar:
>   ip += 3;
>   break;
>  case MonoShortInlineVar:
>  case MonoShortInlineI:
>   ip += 2;
>   break;
>  case MonoShortInlineBrTarget:
>   target = start + cli_addr + 2 + (signed char)ip [1];
>   do { (bblock) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(bblock)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((bblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((bblock))->block_num = cfg->num_bblocks++; } while (0); (bblock)->cil_code = (target); do { if (((bblock))->cil_code) { cfg->cil_offset_to_bb [((bblock))->cil_code - cfg->cil_start] = ((bblock)); } ((bblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   ip += 2;
>   if (ip < end)
>    do { (bblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; if (!(bblock)) { if ((ip) >= end || (ip) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((bblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((bblock))->block_num = cfg->num_bblocks++; } while (0); (bblock)->cil_code = (ip); do { if (((bblock))->cil_code) { cfg->cil_offset_to_bb [((bblock))->cil_code - cfg->cil_start] = ((bblock)); } ((bblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   break;
>  case MonoInlineBrTarget:
>   target = start + cli_addr + 5 + (gint32)(((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   do { (bblock) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(bblock)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((bblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((bblock))->block_num = cfg->num_bblocks++; } while (0); (bblock)->cil_code = (target); do { if (((bblock))->cil_code) { cfg->cil_offset_to_bb [((bblock))->cil_code - cfg->cil_start] = ((bblock)); } ((bblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   ip += 5;
>   if (ip < end)
>    do { (bblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; if (!(bblock)) { if ((ip) >= end || (ip) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((bblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((bblock))->block_num = cfg->num_bblocks++; } while (0); (bblock)->cil_code = (ip); do { if (((bblock))->cil_code) { cfg->cil_offset_to_bb [((bblock))->cil_code - cfg->cil_start] = ((bblock)); } ((bblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   break;
>  case MonoInlineSwitch: {
>   guint32 n = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   guint32 j;
>   ip += 5;
>   cli_addr += 5 + 4 * n;
>   target = start + cli_addr;
>   do { (bblock) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(bblock)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((bblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((bblock))->block_num = cfg->num_bblocks++; } while (0); (bblock)->cil_code = (target); do { if (((bblock))->cil_code) { cfg->cil_offset_to_bb [((bblock))->cil_code - cfg->cil_start] = ((bblock)); } ((bblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>
>   for (j = 0; j < n; ++j) {
>    target = start + cli_addr + (gint32)(((guint32) ( (((guint32) (*((const guint32 *) (ip)))) << 24)| ((((guint32) (*((const guint32 *) (ip)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip)))) >> 24)) ));
>    do { (bblock) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(bblock)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((bblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((bblock))->block_num = cfg->num_bblocks++; } while (0); (bblock)->cil_code = (target); do { if (((bblock))->cil_code) { cfg->cil_offset_to_bb [((bblock))->cil_code - cfg->cil_start] = ((bblock)); } ((bblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>    ip += 4;
>   }
>   break;
>  }
>  case MonoInlineR:
>  case MonoInlineI8:
>   ip += 9;
>   break;
>  default:
>   do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 5171); } while (0);
>  }
>
>  if (i == CEE_THROW) {
>   unsigned char *bb_start = ip - 1;
>
>
>   bblock = ((void *)0);
>   while ((bb_start >= start) && !bblock) {
>    bblock = cfg->cil_offset_to_bb [(bb_start) - start];
>    bb_start --;
>   }
>   if (bblock)
>    bblock->out_of_line = 1;
>  }
> }
> return 0;
>unverified:
> *pos = ip;
> return 1;
>}
>
>static inline MonoMethod *
>mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
>{
> MonoMethod *method;
>
> if (m->wrapper_type != MONO_WRAPPER_NONE)
>  return mono_method_get_wrapper_data (m, token);
>
> method = mono_get_method_full (m->klass->image, token, klass, context);
>
> return method;
>}
>
>static inline MonoMethod *
>mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
>{
> MonoMethod *method = mini_get_method_allow_open (m, token, klass, context);
>
> if (method && cfg && !cfg->generic_sharing_context && mono_class_is_open_constructed_type (&method->klass->byval_arg))
>  return ((void *)0);
>
> return method;
>}
>
>static inline MonoClass*
>mini_get_class (MonoMethod *method, guint32 token, MonoGenericContext *context)
>{
> MonoClass *klass;
>
> if (method->wrapper_type != MONO_WRAPPER_NONE)
>  klass = mono_method_get_wrapper_data (method, token);
> else
>  klass = mono_class_get_full (method->klass->image, token, context);
> if (klass)
>  mono_class_init (klass);
> return klass;
>}
>
>
>
>
>
>static
>gboolean check_linkdemand (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee)
>{
> guint32 result;
>
> if ((cfg->method != caller) && mono_method_has_declsec (callee)) {
>  return 1;
> }
>
> result = mono_declsec_linkdemand (cfg->domain, caller, callee);
> if (result == MONO_JIT_SECURITY_OK)
>  return 0;
>
> if (result == MONO_JIT_LINKDEMAND_ECMA) {
>
>  MonoSecurityManager *secman = mono_security_manager_get_methods ();
>  MonoInst *args [2];
>
>  do { do { ((args [0])) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((args [0]))->data.op[0].const_val = ((args [0]))->data.op[1].const_val = 0; ((args [0]))->next = ((args [0]))->prev = ((void *)0); ((args [0]))->opcode = (OP_ICONST); ((args [0]))->flags = 0; ((args [0]))->type = 0; ((args [0]))->dreg = -1; do { (((args [0])))->sreg1 = (((args [0])))->sreg2 = (((args [0])))->sreg3 = -1; } while (0); ((args [0]))->cil_code = ((cfg))->ip; } while (0); (args [0])->data.op[0].const_val = (4); (args [0])->type = STACK_I4; (args [0])->dreg = alloc_dreg ((cfg), STACK_I4); } while (0);
>  do { do { (((args [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [1])))->data.op[0].const_val = (((args [1])))->data.op[1].const_val = 0; (((args [1])))->next = (((args [1])))->prev = ((void *)0); (((args [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((args [1])))->flags = 0; (((args [1])))->type = 0; (((args [1])))->dreg = -1; do { ((((args [1]))))->sreg1 = ((((args [1]))))->sreg2 = ((((args [1]))))->sreg3 = -1; } while (0); (((args [1])))->cil_code = (((cfg)))->ip; } while (0); ((args [1]))->data.op[0].p = ((caller)); ((args [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_METHODCONST); ((args [1]))->type = STACK_PTR; ((args [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0);
>  mono_emit_method_call (cfg, secman->linkdemandsecurityexception, args, ((void *)0));
> } else if (cfg->exception_type == MONO_EXCEPTION_NONE) {
>
>  mono_cfg_set_exception (cfg, MONO_EXCEPTION_SECURITY_LINKDEMAND);
>  cfg->exception_data = result;
>  return 1;
> }
>
> return 0;
>}
>
>static MonoMethod*
>throw_exception (void)
>{
> static MonoMethod *method = ((void *)0);
>
> if (!method) {
>  MonoSecurityManager *secman = mono_security_manager_get_methods ();
>  method = mono_class_get_method_from_name (secman->securitymanager, "ThrowException", 1);
> }
> do { if (!(method)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 5275, "method"); } while (0);
> return method;
>}
>
>static void
>emit_throw_exception (MonoCompile *cfg, MonoException *ex)
>{
> MonoMethod *thrower = throw_exception ();
> MonoInst *args [1];
>
> do { do { do { (((args [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [0])))->data.op[0].const_val = (((args [0])))->data.op[1].const_val = 0; (((args [0])))->next = (((args [0])))->prev = ((void *)0); (((args [0])))->opcode = (OP_I8CONST); (((args [0])))->flags = 0; (((args [0])))->type = 0; (((args [0])))->dreg = -1; do { ((((args [0]))))->sreg1 = ((((args [0]))))->sreg2 = ((((args [0]))))->sreg3 = -1; } while (0); (((args [0])))->cil_code = (((cfg)))->ip; } while (0); ((args [0]))->data.op[0].p = ((ex)); ((args [0]))->type = STACK_PTR; ((args [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [0])); ((args [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [0])); } } while (0); } while (0);
> mono_emit_method_call (cfg, thrower, args, ((void *)0));
>}
>
>
>
>
>
>static MonoMethod*
>get_original_method (MonoMethod *method)
>{
> if (method->wrapper_type == MONO_WRAPPER_NONE)
>  return method;
>
>
> if (method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED)
>  return ((void *)0);
>
>
> return mono_marshal_method_from_wrapper (method);
>}
>
>static void
>ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field,
>       MonoBasicBlock *bblock, unsigned char *ip)
>{
>
> MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
> if (ex)
>  emit_throw_exception (cfg, ex);
>}
>
>static void
>ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee,
>      MonoBasicBlock *bblock, unsigned char *ip)
>{
>
> MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
> if (ex)
>  emit_throw_exception (cfg, ex);
>}
>
>
>
>
>
>static const char*
>initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
>{
>
>
>
>
>
>
> if (ip [0] == CEE_DUP && ip [1] == CEE_LDTOKEN && ip [5] == 0x4 && ip [6] == CEE_CALL) {
>  guint32 token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 7)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 7)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 7)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 7)))) >> 24)) ));
>  guint32 field_token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>  guint32 field_index = field_token & 0xffffff;
>  guint32 rva;
>  const char *data_ptr;
>  int size = 0;
>  MonoMethod *cmethod;
>  MonoClass *dummy_class;
>  MonoClassField *field = mono_field_from_token (method->klass->image, field_token, &dummy_class, ((void *)0));
>  int dummy_align;
>
>  if (!field)
>   return ((void *)0);
>
>  *out_field_token = field_token;
>
>  cmethod = mini_get_method (((void *)0), method, token, ((void *)0), ((void *)0));
>  if (!cmethod)
>   return ((void *)0);
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("InitializeArray") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("InitializeArray")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("InitializeArray") + 1) - (size_t)(const void *)("InitializeArray") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "InitializeArray") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("InitializeArray") && ((size_t)(const void *)(("InitializeArray") + 1) - (size_t)(const void *)("InitializeArray") == 1) ? __builtin_strcmp (cmethod->name, "InitializeArray") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("InitializeArray"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("InitializeArray") && ((size_t)(const void *)(("InitializeArray") + 1) - (size_t)(const void *)("InitializeArray") == 1) && (__s2_len = __strlen_g (("InitializeArray")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "InitializeArray") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("InitializeArray"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("InitializeArray"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("InitializeArray"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("InitializeArray"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "InitializeArray")))); }) || __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->klass->name) && __builtin_constant_p ("RuntimeHelpers") && (__s1_len = __strlen_g ((cmethod->klass->name)), __s2_len = __strlen_g (("RuntimeHelpers")), (!((size_t)(const void *)((cmethod->klass->name) + 1) - (size_t)(const void *)(cmethod->klass->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("RuntimeHelpers") + 1) - (size_t)(const void *)("RuntimeHelpers") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->klass->name, "RuntimeHelpers") : (__builtin_constant_p (cmethod->klass->name) && ((size_t)(const void *)((cmethod->klass->name) + 1) - (size_t)(const void *)(cmethod->klass->name) == 1) && (__s1_len = __strlen_g ((cmethod->klass->name)), __s1_len < 4) ? (__builtin_constant_p ("RuntimeHelpers") && ((size_t)(const void *)(("RuntimeHelpers") + 1) - (size_t)(const void *)("RuntimeHelpers") == 1) ? __builtin_strcmp (cmethod->klass->name, "RuntimeHelpers") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("RuntimeHelpers"); int __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->klass->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("RuntimeHelpers") && ((size_t)(const void *)(("RuntimeHelpers") + 1) - (size_t)(const void *)("RuntimeHelpers") == 1) && (__s2_len = __strlen_g (("RuntimeHelpers")), __s2_len < 4) ? (__builtin_constant_p (cmethod->klass->name) && ((size_t)(const void *)((cmethod->klass->name) + 1) - (size_t)(const void *)(cmethod->klass->name) == 1) ? __builtin_strcmp (cmethod->klass->name, "RuntimeHelpers") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->klass->name); int __result = (((const unsigned char *) (const char *) ("RuntimeHelpers"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("RuntimeHelpers"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("RuntimeHelpers"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("RuntimeHelpers"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->klass->name, "RuntimeHelpers")))); }) || cmethod->klass->image != mono_defaults.corlib)
>   return ((void *)0);
>  switch (mono_type_get_underlying_type (&klass->byval_arg)->type) {
>  case MONO_TYPE_BOOLEAN:
>  case MONO_TYPE_I1:
>  case MONO_TYPE_U1:
>   size = 1; break;
># 5385 "method-to-ir.c"
>  default:
>   return ((void *)0);
>  }
>  size *= len;
>  if (size > mono_type_size (field->type, &dummy_align))
>      return ((void *)0);
>  *out_size = size;
>
>  if (!method->klass->image->dynamic) {
>   field_index = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) )) & 0xffffff;
>   mono_metadata_field_info (method->klass->image, field_index - 1, ((void *)0), &rva, ((void *)0));
>   data_ptr = mono_image_rva_map (method->klass->image, rva);
>
>
>   if (aot && data_ptr)
>    return ((gpointer)(gulong) (rva));
>  } else {
>
>   do { if (!(!aot)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 5403, "!aot"); } while (0);
>   data_ptr = mono_field_get_data (field);
>  }
>  return data_ptr;
> }
> return ((void *)0);
>}
>
>static void
>set_exception_type_from_invalid_il (MonoCompile *cfg, MonoMethod *method, unsigned char *ip)
>{
> char *method_fname = mono_method_full_name (method, 1);
> char *method_code;
> MonoMethodHeader *header = mono_method_get_header (method);
>
> if (header->code_size == 0)
>  method_code = monoeg_strdup ("method body is empty.");
> else
>  method_code = mono_disasm_code_one (((void *)0), method, ip, ((void *)0));
>  mono_cfg_set_exception (cfg, MONO_EXCEPTION_INVALID_PROGRAM);
>  cfg->exception_message = monoeg_g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
>  monoeg_g_free (method_fname);
>  monoeg_g_free (method_code);
> cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, header);
>}
>
>static void
>set_exception_object (MonoCompile *cfg, MonoException *exception)
>{
> mono_cfg_set_exception (cfg, MONO_EXCEPTION_OBJECT_SUPPLIED);
> do { do { if (!(sizeof (cfg->exception_ptr) == sizeof (MonoObject*))) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 5433, "sizeof (cfg->exception_ptr) == sizeof (MonoObject*)"); } while (0); mono_gc_register_root ((char*)&(cfg->exception_ptr), sizeof(MonoObject*), mono_gc_make_root_descr_all_refs (1)); } while (0);
> cfg->exception_ptr = exception;
>}
>
>static gboolean
>generic_class_is_reference_type (MonoCompile *cfg, MonoClass *klass)
>{
> MonoType *type;
>
> if (cfg->generic_sharing_context)
>  type = mini_get_basic_type_from_generic (cfg->generic_sharing_context, &klass->byval_arg);
> else
>  type = &klass->byval_arg;
> return mono_type_is_reference (type);
>}
>
>static void
>emit_stloc_ir (MonoCompile *cfg, MonoInst **sp, MonoMethodHeader *header, int n)
>{
> MonoInst *ins;
> guint32 opcode = mono_type_to_regmove (cfg, header->locals [n]);
> if ((opcode == OP_MOVE) && cfg->cbb->last_ins == sp [0] &&
>   ((sp [0]->opcode == OP_ICONST) || (sp [0]->opcode == OP_I8CONST))) {
>
>
>
>
>
>  sp [0]->dreg = (cfg)->locals [n]->dreg;
> } else {
>  do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->locals [((n))]->data.op[1].vtype)); (((ins)))->klass = (((cfg))->locals [((n))])->klass; (((ins)))->sreg1 = (((*sp)))->dreg; (((ins)))->dreg = (((cfg))->locals [((n))])->dreg; if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((((cfg))->locals [((n))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
> }
>}
>
>
>
>
>
>static inline unsigned char *
>emit_optimized_ldloca_ir (MonoCompile *cfg, unsigned char *ip, unsigned char *end, int size)
>{
> int local, token;
> MonoClass *klass;
>
> if (size == 1) {
>  local = ip [1];
>  ip += 2;
> } else {
>  local = (((guint16) (((guint16) *((const guint16 *) (ip + 2))) >> 8) | ((((guint16)(*((const guint16 *) (ip + 2)))) & 0xff) << 8)));
>  ip += 4;
> }
>
> if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
>  gboolean skip = 0;
>
>
>  token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>  klass = mini_get_class (cfg->current_method, token, cfg->generic_context);
>  if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>  if (generic_class_is_reference_type (cfg, klass)) {
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_I8CONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = cfg->locals [local]->dreg; (inst)->data.op[0].p = (((void *)0)); (inst)->type = STACK_PTR; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  } else if (mono_type_is_reference (&klass->byval_arg)) {
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_I8CONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = cfg->locals [local]->dreg; (inst)->data.op[0].p = (((void *)0)); (inst)->type = STACK_PTR; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  } else if (mono_type_is_struct (&klass->byval_arg)) {
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((0) ? OP_XZERO : OP_VZERO); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = cfg->locals [local]->dreg; (inst)->type = STACK_VTYPE; (inst)->klass = (klass); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  } else {
>   skip = 1;
>  }
>
>  if (!skip)
>   return ip + 6;
> }
>load_error:
> return ((void *)0);
>}
>
>static gboolean
>is_exception_class (MonoClass *class)
>{
> while (class) {
>  if (class == mono_defaults.exception_class)
>   return 1;
>  class = class->parent;
> }
> return 0;
>}
>
>
>
>
>
>
>
>static gboolean
>is_jit_optimizer_disabled (MonoMethod *m)
>{
> MonoAssembly *ass = m->klass->image->assembly;
> MonoCustomAttrInfo* attrs;
> static MonoClass *klass;
> int i;
> gboolean val = 0;
>
> do { if (!(ass)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 5535, "ass"); } while (0);
> if (ass->jit_optimizer_disabled_inited)
>  return ass->jit_optimizer_disabled;
>
> if (!klass)
>  klass = mono_class_from_name (mono_defaults.corlib, "System.Diagnostics", "DebuggableAttribute");
> if (!klass) {
>
>  ass->jit_optimizer_disabled = 0;
>  mono_memory_barrier ();
>  ass->jit_optimizer_disabled_inited = 1;
>  return 0;
> }
>
> attrs = mono_custom_attrs_from_assembly (ass);
> if (attrs) {
>  for (i = 0; i < attrs->num_attrs; ++i) {
>   MonoCustomAttrEntry *attr = &attrs->attrs [i];
>   const gchar *p;
>   int len;
>   MonoMethodSignature *sig;
>
>   if (!attr->ctor || attr->ctor->klass != klass)
>    continue;
>
>   len = attr->data_size;
>   p = (const char*)attr->data;
>   do { if (!((((guint16) (((guint16) *((const guint16 *) (p))) >> 8) | ((((guint16)(*((const guint16 *) (p)))) & 0xff) << 8))) == 0x0001)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 5562, "read16 (p) == 0x0001"); } while (0);
>   p += 2;
>
>
>   sig = mono_method_signature (attr->ctor);
>   if (sig->param_count != 2 || sig->params [0]->type != MONO_TYPE_BOOLEAN || sig->params [1]->type != MONO_TYPE_BOOLEAN)
>    continue;
>
>   p ++;
>   val = *p;
>  }
>  mono_custom_attrs_free (attrs);
> }
>
> ass->jit_optimizer_disabled = val;
> mono_memory_barrier ();
> ass->jit_optimizer_disabled_inited = 1;
>
> return val;
>}
>
>static gboolean
>is_supported_tail_call (MonoCompile *cfg, MonoMethod *method, MonoMethod *cmethod, MonoMethodSignature *fsig)
>{
> gboolean supported_tail_call;
> int i;
>
>
>
>
> supported_tail_call = mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)) && !mono_type_is_struct (mono_method_signature (cmethod)->ret);
>
>
> for (i = 0; i < fsig->param_count; ++i) {
>  if (fsig->params [i]->byref || fsig->params [i]->type == MONO_TYPE_PTR || fsig->params [i]->type == MONO_TYPE_FNPTR)
>
>   supported_tail_call = 0;
> }
> if (fsig->hasthis && cmethod->klass->valuetype)
>
>  supported_tail_call = 0;
> if (cmethod->flags & 0x2000)
>  supported_tail_call = 0;
> if (cfg->method->save_lmf)
>  supported_tail_call = 0;
> if (cmethod->wrapper_type && cmethod->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD)
>  supported_tail_call = 0;
># 5624 "method-to-ir.c"
> return supported_tail_call;
>}
>
>
>
>
>
>
>int
>mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
>     MonoInst *return_var, GList *dont_inline, MonoInst **inline_args,
>     guint inline_offset, gboolean is_virtual_call)
>{
> MonoError error;
> MonoInst *ins, **sp, **stack_start;
> MonoBasicBlock *bblock, *tblock = ((void *)0), *init_localsbb = ((void *)0);
> MonoSimpleBasicBlock *bb = ((void *)0), *original_bb = ((void *)0);
> MonoMethod *cmethod, *method_definition;
> MonoInst **arg_array;
> MonoMethodHeader *header;
> MonoImage *image;
> guint32 token, ins_flag;
> MonoClass *klass;
> MonoClass *constrained_call = ((void *)0);
> unsigned char *ip, *end, *target, *err_pos;
> static double r8_0 = 0.0;
> MonoMethodSignature *sig;
> MonoGenericContext *generic_context = ((void *)0);
> MonoGenericContainer *generic_container = ((void *)0);
> MonoType **param_types;
> int i, n, start_new_bblock, dreg;
> int num_calls = 0, inline_costs = 0;
> int breakpoint_id = 0;
> guint num_args;
> MonoBoolean security, pinvoke;
> MonoSecurityManager* secman = ((void *)0);
> MonoDeclSecurityActions actions;
> GSList *class_inits = ((void *)0);
> gboolean dont_verify, dont_verify_stloc, readonly = 0;
> int context_used;
> gboolean init_locals, seq_points, skip_dead_blocks;
> gboolean disable_inline;
>
> disable_inline = is_jit_optimizer_disabled (method);
>
>
> dont_verify = method->klass->image->assembly->corlib_internal? 1: 0;
> dont_verify |= method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE;
> dont_verify |= method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH;
>  dont_verify |= method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE;
> dont_verify |= method->wrapper_type == MONO_WRAPPER_COMINTEROP;
> dont_verify |= method->wrapper_type == MONO_WRAPPER_COMINTEROP_INVOKE;
>
> dont_verify |= mono_security_get_mode () == MONO_SECURITY_MODE_SMCS_HACK;
>
>
> dont_verify_stloc = method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE;
> dont_verify_stloc |= method->wrapper_type == MONO_WRAPPER_UNKNOWN;
> dont_verify_stloc |= method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED;
> dont_verify_stloc |= method->wrapper_type == MONO_WRAPPER_STELEMREF;
>
> image = method->klass->image;
> header = mono_method_get_header (method);
> if (!header) {
>  MonoLoaderError *error;
>
>  if ((error = mono_loader_get_last_error ())) {
>   mono_cfg_set_exception (cfg, error->exception_type);
>  } else {
>   mono_cfg_set_exception (cfg, MONO_EXCEPTION_INVALID_PROGRAM);
>   cfg->exception_message = monoeg_g_strdup_printf ("Missing or incorrect header for method %s", cfg->method->name);
>  }
>  goto exception_exit;
> }
> generic_container = mono_method_get_generic_container (method);
> sig = mono_method_signature (method);
> num_args = sig->hasthis + sig->param_count;
> ip = (unsigned char*)header->code;
> cfg->cil_start = ip;
> end = ip + header->code_size;
> mono_jit_stats.cil_code_size += header->code_size;
> init_locals = header->init_locals;
>
> seq_points = cfg->gen_seq_points && cfg->method == method;
>
>
>
>
>
> init_locals = 1;
>
> method_definition = method;
> while (method_definition->is_inflated) {
>  MonoMethodInflated *imethod = (MonoMethodInflated *) method_definition;
>  method_definition = imethod->declaring;
> }
>
>
> if (!dont_verify && mini_assembly_can_skip_verification (cfg->domain, method)) {
>  dont_verify = 1;
>  dont_verify_stloc = 1;
> }
>
> if (mono_debug_using_mono_debugger ())
>  cfg->keep_cil_nops = 1;
>
> if (sig->is_inflated)
>  generic_context = mono_method_get_context (method);
> else if (generic_container)
>  generic_context = &generic_container->context;
> cfg->generic_context = generic_context;
>
> if (!cfg->generic_sharing_context)
>  do { if (!(!sig->has_type_parameters)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 5737, "!sig->has_type_parameters"); } while (0);
>
> if (sig->generic_param_count && method->wrapper_type == MONO_WRAPPER_NONE) {
>  do { if (!(method->is_inflated)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 5740, "method->is_inflated"); } while (0);
>  do { if (!(mono_method_get_context (method)->method_inst)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 5741, "mono_method_get_context (method)->method_inst"); } while (0);
> }
> if (method->is_inflated && mono_method_get_context (method)->method_inst)
>  do { if (!(sig->generic_param_count)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 5744, "sig->generic_param_count"); } while (0);
>
> if (cfg->method == method) {
>  cfg->real_offset = 0;
> } else {
>  cfg->real_offset = inline_offset;
> }
>
> cfg->cil_offset_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
> cfg->cil_offset_to_bb_len = header->code_size;
>
> cfg->current_method = method;
>
> if (cfg->verbose_level > 2)
>  printf ("method to IR %s\n", mono_method_full_name (method, 1));
>
> param_types = mono_mempool_alloc (cfg->mempool, sizeof (MonoType*) * num_args);
> if (sig->hasthis)
>  param_types [0] = method->klass->valuetype?&method->klass->this_arg:&method->klass->byval_arg;
> for (n = 0; n < sig->param_count; ++n)
>  param_types [n + sig->hasthis] = sig->params [n];
> cfg->arg_types = param_types;
>
> dont_inline = monoeg_g_list_prepend (dont_inline, method);
> if (cfg->method == method) {
>
>  if (cfg->prof_options & MONO_PROFILE_INS_COVERAGE)
>   cfg->coverage_info = mono_profiler_coverage_alloc (cfg->method, header->code_size);
>
>
>  do { (start_bblock) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (start_bblock)->block_num = cfg->num_bblocks++; } while (0);
>  cfg->bb_entry = start_bblock;
>  start_bblock->cil_code = ((void *)0);
>  start_bblock->cil_length = 0;
>
>
>
>
>
>
>
>  do { (end_bblock) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (end_bblock)->block_num = cfg->num_bblocks++; } while (0);
>  cfg->bb_exit = end_bblock;
>  end_bblock->cil_code = ((void *)0);
>  end_bblock->cil_length = 0;
>  end_bblock->flags |= BB_INDIRECT_JUMP_TARGET;
>  do { if (!(cfg->num_bblocks == 2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 5790, "cfg->num_bblocks == 2"); } while (0);
>
>  arg_array = cfg->args;
>
>  if (header->num_clauses) {
>   cfg->spvars = monoeg_g_hash_table_new (((void *)0), ((void *)0));
>   cfg->exvars = monoeg_g_hash_table_new (((void *)0), ((void *)0));
>  }
>
>  for (i = 0; i < header->num_clauses; ++i) {
>   MonoBasicBlock *try_bb;
>   MonoExceptionClause *clause = &header->clauses [i];
>   do { (try_bb) = cfg->cil_offset_to_bb [(ip + clause->try_offset) - cfg->cil_start]; if (!(try_bb)) { if ((ip + clause->try_offset) >= end || (ip + clause->try_offset) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((try_bb)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((try_bb))->block_num = cfg->num_bblocks++; } while (0); (try_bb)->cil_code = (ip + clause->try_offset); do { if (((try_bb))->cil_code) { cfg->cil_offset_to_bb [((try_bb))->cil_code - cfg->cil_start] = ((try_bb)); } ((try_bb))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   try_bb->real_offset = clause->try_offset;
>   try_bb->try_start = 1;
>   try_bb->region = ((i + 1) << 8) | clause->flags;
>   do { (tblock) = cfg->cil_offset_to_bb [(ip + clause->handler_offset) - cfg->cil_start]; if (!(tblock)) { if ((ip + clause->handler_offset) >= end || (ip + clause->handler_offset) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (ip + clause->handler_offset); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   tblock->real_offset = clause->handler_offset;
>   tblock->flags |= BB_EXCEPTION_HANDLER;
>
>   link_bblock (cfg, try_bb, tblock);
>
>   if (*(ip + clause->handler_offset) == CEE_POP)
>    tblock->flags |= BB_EXCEPTION_DEAD_OBJ;
>
>   if (clause->flags == MONO_EXCEPTION_CLAUSE_FINALLY ||
>       clause->flags == MONO_EXCEPTION_CLAUSE_FILTER ||
>       clause->flags == MONO_EXCEPTION_CLAUSE_FAULT) {
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_START_HANDLER); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    do { if ((tblock)->last_ins) { (tblock)->last_ins->next = (ins); (ins)->prev = (tblock)->last_ins; (tblock)->last_ins = (ins); } else { (tblock)->code = (tblock)->last_ins = (ins); } } while (0);
>
>    if (seq_points && clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY) {
>
>     do { do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = (OP_SEQ_POINT); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); (ins)->data.op[1].const_val = (clause->handler_offset); (ins)->flags = 1 ? MONO_INST_SINGLE_STEP_LOC : 0; } while (0);
>     do { if ((tblock)->last_ins) { (tblock)->last_ins->next = (ins); (ins)->prev = (tblock)->last_ins; (tblock)->last_ins = (ins); } else { (tblock)->code = (tblock)->last_ins = (ins); } } while (0);
>    }
>
>
>    if (clause->flags == MONO_EXCEPTION_CLAUSE_FAULT)
>     tblock->flags |= BB_EXCEPTION_UNSAFE;
>   }
>
>
>
>
>
>
>
>   if (clause->flags == MONO_EXCEPTION_CLAUSE_NONE ||
>       clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
>    MonoInst *dummy_use;
>
>
>
>    tblock->in_scount = 1;
>    tblock->in_stack = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*));
>    tblock->in_stack [0] = mono_create_exvar_for_offset (cfg, clause->handler_offset);
>
>
>
>
>
>    cfg->cbb = tblock;
>    do { do { do { (((dummy_use))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((dummy_use)))->data.op[0].const_val = (((dummy_use)))->data.op[1].const_val = 0; (((dummy_use)))->next = (((dummy_use)))->prev = ((void *)0); (((dummy_use)))->opcode = (OP_DUMMY_USE); (((dummy_use)))->flags = 0; (((dummy_use)))->type = 0; (((dummy_use)))->dreg = -1; do { ((((dummy_use))))->sreg1 = ((((dummy_use))))->sreg2 = ((((dummy_use))))->sreg3 = -1; } while (0); (((dummy_use)))->cil_code = (((cfg)))->ip; } while (0); ((dummy_use))->sreg1 = (tblock->in_stack [0])->dreg; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((dummy_use)); ((dummy_use))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((dummy_use)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((dummy_use)); } } while (0); } while (0);
>
>    if (clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
>     do { (tblock) = cfg->cil_offset_to_bb [(ip + clause->data.filter_offset) - cfg->cil_start]; if (!(tblock)) { if ((ip + clause->data.filter_offset) >= end || (ip + clause->data.filter_offset) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (ip + clause->data.filter_offset); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>     tblock->flags |= BB_EXCEPTION_HANDLER;
>     tblock->real_offset = clause->data.filter_offset;
>     tblock->in_scount = 1;
>     tblock->in_stack = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*));
>
>     tblock->in_stack [0] = mono_create_exvar_for_offset (cfg, clause->handler_offset);
>     do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_START_HANDLER); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>     do { if ((tblock)->last_ins) { (tblock)->last_ins->next = (ins); (ins)->prev = (tblock)->last_ins; (tblock)->last_ins = (ins); } else { (tblock)->code = (tblock)->last_ins = (ins); } } while (0);
>    }
>   }
>
>   if (clause->flags != MONO_EXCEPTION_CLAUSE_FILTER &&
>     clause->data.catch_class &&
>     cfg->generic_sharing_context &&
>     mono_class_check_context_used (clause->data.catch_class)) {
># 5883 "method-to-ir.c"
>    if ((method->flags & 0x0010) ||
>      mini_method_get_context (method)->method_inst ||
>      method->klass->valuetype) {
>     mono_get_vtable_var (cfg);
>    } else {
>     MonoInst *dummy_use;
>
>     do { do { do { (((dummy_use))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((dummy_use)))->data.op[0].const_val = (((dummy_use)))->data.op[1].const_val = 0; (((dummy_use)))->next = (((dummy_use)))->prev = ((void *)0); (((dummy_use)))->opcode = (OP_DUMMY_USE); (((dummy_use)))->flags = 0; (((dummy_use)))->type = 0; (((dummy_use)))->dreg = -1; do { ((((dummy_use))))->sreg1 = ((((dummy_use))))->sreg2 = ((((dummy_use))))->sreg3 = -1; } while (0); (((dummy_use)))->cil_code = (((cfg)))->ip; } while (0); ((dummy_use))->sreg1 = (arg_array [0])->dreg; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((dummy_use)); ((dummy_use))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((dummy_use)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((dummy_use)); } } while (0); } while (0);
>    }
>   }
>  }
> } else {
>  arg_array = (MonoInst **) __builtin_alloca (sizeof (MonoInst *) * num_args);
>  cfg->cbb = start_bblock;
>  cfg->args = arg_array;
>  mono_save_args (cfg, sig, inline_args);
> }
>
>
> do { (bblock) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (bblock)->block_num = cfg->num_bblocks++; } while (0);
> bblock->cil_code = ip;
> cfg->cbb = bblock;
> cfg->ip = ip;
>
> do { if ((bblock)->cil_code) { cfg->cil_offset_to_bb [(bblock)->cil_code - cfg->cil_start] = (bblock); } (bblock)->real_offset = cfg->real_offset; } while (0);
>
> if (cfg->method == method) {
>  breakpoint_id = mono_debugger_method_has_breakpoint (method);
>  if (breakpoint_id && (mono_debug_format != MONO_DEBUG_FORMAT_DEBUGGER)) {
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BREAK); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>  }
> }
>
> if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS)
>  secman = mono_security_manager_get_methods ();
>
> security = (secman && mono_method_has_declsec (method));
>
> if (security && (cfg->method == method)) {
>
>
>
>  security = mono_declsec_get_demands (method, &actions);
> }
>
>
> pinvoke = (secman && (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE));
> if (pinvoke) {
>  MonoMethod *wrapped = mono_marshal_method_from_wrapper (method);
>  if (wrapped && (wrapped->flags & 0x2000)) {
>   MonoCustomAttrInfo* custom = mono_custom_attrs_from_method (wrapped);
>
>
>   if (custom && mono_custom_attrs_has_attr (custom, secman->suppressunmanagedcodesecurity)) {
>    pinvoke = 0;
>   }
>   if (custom)
>    mono_custom_attrs_free (custom);
>
>   if (pinvoke) {
>    custom = mono_custom_attrs_from_class (wrapped->klass);
>    if (custom && mono_custom_attrs_has_attr (custom, secman->suppressunmanagedcodesecurity)) {
>     pinvoke = 0;
>    }
>    if (custom)
>     mono_custom_attrs_free (custom);
>   }
>  } else {
>
>   pinvoke = 0;
>  }
> }
>
> if ((init_locals || (cfg->method == method && (cfg->opt & MONO_OPT_SHARED))) || cfg->compile_aot || security || pinvoke) {
>
>  do { (init_localsbb) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (init_localsbb)->block_num = cfg->num_bblocks++; } while (0);
>  cfg->bb_init = init_localsbb;
>  init_localsbb->real_offset = cfg->real_offset;
>  start_bblock->next_bb = init_localsbb;
>  init_localsbb->next_bb = bblock;
>  link_bblock (cfg, start_bblock, init_localsbb);
>  link_bblock (cfg, init_localsbb, bblock);
>
>  cfg->cbb = init_localsbb;
> } else {
>  start_bblock->next_bb = bblock;
>  link_bblock (cfg, start_bblock, bblock);
> }
>
>
> if (security && (cfg->method == method)) {
>  MonoInst *args [2];
>
>  mono_jit_stats.cas_demand_generation++;
>
>  if (actions.demand.blob) {
>
>   do { do { if ((cfg)->compile_aot) { do { do { (((args[0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args[0])))->data.op[0].const_val = (((args[0])))->data.op[1].const_val = 0; (((args[0])))->next = (((args[0])))->prev = ((void *)0); (((args[0])))->opcode = (OP_AOTCONST); (((args[0])))->flags = 0; (((args[0])))->type = 0; (((args[0])))->dreg = -1; do { ((((args[0]))))->sreg1 = ((((args[0]))))->sreg2 = ((((args[0]))))->sreg3 = -1; } while (0); (((args[0])))->cil_code = (((cfg)))->ip; } while (0); ((args[0]))->data.op[0].p = mono_jump_info_token_new2 (((cfg))->mempool, ((image)), (((actions.demand)).index), (((void *)0))); ((args[0]))->data.op[1].p = (gpointer)(MONO_PATCH_INFO_DECLSEC); ((args[0]))->type = (STACK_OBJ); ((args[0]))->klass = (((void *)0)); ((args[0]))->dreg = alloc_dreg (((cfg)), (STACK_OBJ)); } while (0); } else { do { do { ((args [0])) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((args [0]))->data.op[0].const_val = ((args [0]))->data.op[1].const_val = 0; ((args [0]))->next = ((args [0]))->prev = ((void *)0); ((args [0]))->opcode = (OP_I8CONST); ((args [0]))->flags = 0; ((args [0]))->type = 0; ((args [0]))->dreg = -1; do { (((args [0])))->sreg1 = (((args [0])))->sreg2 = (((args [0])))->sreg3 = -1; } while (0); ((args [0]))->cil_code = (((cfg)))->ip; } while (0); (args [0])->data.op[0].p = (((actions.demand)).blob); (args [0])->type = STACK_PTR; (args [0])->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args[0])); ((args[0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args[0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args[0])); } } while (0); } while (0);
>   do { do { do { (((args [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [1])))->data.op[0].const_val = (((args [1])))->data.op[1].const_val = 0; (((args [1])))->next = (((args [1])))->prev = ((void *)0); (((args [1])))->opcode = (OP_ICONST); (((args [1])))->flags = 0; (((args [1])))->type = 0; (((args [1])))->dreg = -1; do { ((((args [1]))))->sreg1 = ((((args [1]))))->sreg2 = ((((args [1]))))->sreg3 = -1; } while (0); (((args [1])))->cil_code = (((cfg)))->ip; } while (0); ((args [1]))->data.op[0].const_val = ((actions.demand.size)); ((args [1]))->type = STACK_I4; ((args [1]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [1])); ((args [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [1])); } } while (0); } while (0);
>
>   mono_emit_method_call (cfg, secman->demand, args, ((void *)0));
>  }
>  if (actions.noncasdemand.blob) {
>
>
>   do { do { if ((cfg)->compile_aot) { do { do { (((args[0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args[0])))->data.op[0].const_val = (((args[0])))->data.op[1].const_val = 0; (((args[0])))->next = (((args[0])))->prev = ((void *)0); (((args[0])))->opcode = (OP_AOTCONST); (((args[0])))->flags = 0; (((args[0])))->type = 0; (((args[0])))->dreg = -1; do { ((((args[0]))))->sreg1 = ((((args[0]))))->sreg2 = ((((args[0]))))->sreg3 = -1; } while (0); (((args[0])))->cil_code = (((cfg)))->ip; } while (0); ((args[0]))->data.op[0].p = mono_jump_info_token_new2 (((cfg))->mempool, ((image)), (((actions.noncasdemand)).index), (((void *)0))); ((args[0]))->data.op[1].p = (gpointer)(MONO_PATCH_INFO_DECLSEC); ((args[0]))->type = (STACK_OBJ); ((args[0]))->klass = (((void *)0)); ((args[0]))->dreg = alloc_dreg (((cfg)), (STACK_OBJ)); } while (0); } else { do { do { ((args [0])) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((args [0]))->data.op[0].const_val = ((args [0]))->data.op[1].const_val = 0; ((args [0]))->next = ((args [0]))->prev = ((void *)0); ((args [0]))->opcode = (OP_I8CONST); ((args [0]))->flags = 0; ((args [0]))->type = 0; ((args [0]))->dreg = -1; do { (((args [0])))->sreg1 = (((args [0])))->sreg2 = (((args [0])))->sreg3 = -1; } while (0); ((args [0]))->cil_code = (((cfg)))->ip; } while (0); (args [0])->data.op[0].p = (((actions.noncasdemand)).blob); (args [0])->type = STACK_PTR; (args [0])->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args[0])); ((args[0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args[0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args[0])); } } while (0); } while (0);
>   do { do { do { (((args [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [1])))->data.op[0].const_val = (((args [1])))->data.op[1].const_val = 0; (((args [1])))->next = (((args [1])))->prev = ((void *)0); (((args [1])))->opcode = (OP_ICONST); (((args [1])))->flags = 0; (((args [1])))->type = 0; (((args [1])))->dreg = -1; do { ((((args [1]))))->sreg1 = ((((args [1]))))->sreg2 = ((((args [1]))))->sreg3 = -1; } while (0); (((args [1])))->cil_code = (((cfg)))->ip; } while (0); ((args [1]))->data.op[0].const_val = ((actions.noncasdemand.size)); ((args [1]))->type = STACK_I4; ((args [1]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [1])); ((args [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [1])); } } while (0); } while (0);
>
>   mono_emit_method_call (cfg, secman->demand, args, ((void *)0));
>  }
>  if (actions.demandchoice.blob) {
>
>   do { do { if ((cfg)->compile_aot) { do { do { (((args[0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args[0])))->data.op[0].const_val = (((args[0])))->data.op[1].const_val = 0; (((args[0])))->next = (((args[0])))->prev = ((void *)0); (((args[0])))->opcode = (OP_AOTCONST); (((args[0])))->flags = 0; (((args[0])))->type = 0; (((args[0])))->dreg = -1; do { ((((args[0]))))->sreg1 = ((((args[0]))))->sreg2 = ((((args[0]))))->sreg3 = -1; } while (0); (((args[0])))->cil_code = (((cfg)))->ip; } while (0); ((args[0]))->data.op[0].p = mono_jump_info_token_new2 (((cfg))->mempool, ((image)), (((actions.demandchoice)).index), (((void *)0))); ((args[0]))->data.op[1].p = (gpointer)(MONO_PATCH_INFO_DECLSEC); ((args[0]))->type = (STACK_OBJ); ((args[0]))->klass = (((void *)0)); ((args[0]))->dreg = alloc_dreg (((cfg)), (STACK_OBJ)); } while (0); } else { do { do { ((args [0])) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((args [0]))->data.op[0].const_val = ((args [0]))->data.op[1].const_val = 0; ((args [0]))->next = ((args [0]))->prev = ((void *)0); ((args [0]))->opcode = (OP_I8CONST); ((args [0]))->flags = 0; ((args [0]))->type = 0; ((args [0]))->dreg = -1; do { (((args [0])))->sreg1 = (((args [0])))->sreg2 = (((args [0])))->sreg3 = -1; } while (0); ((args [0]))->cil_code = (((cfg)))->ip; } while (0); (args [0])->data.op[0].p = (((actions.demandchoice)).blob); (args [0])->type = STACK_PTR; (args [0])->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args[0])); ((args[0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args[0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args[0])); } } while (0); } while (0);
>   do { do { do { (((args [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [1])))->data.op[0].const_val = (((args [1])))->data.op[1].const_val = 0; (((args [1])))->next = (((args [1])))->prev = ((void *)0); (((args [1])))->opcode = (OP_ICONST); (((args [1])))->flags = 0; (((args [1])))->type = 0; (((args [1])))->dreg = -1; do { ((((args [1]))))->sreg1 = ((((args [1]))))->sreg2 = ((((args [1]))))->sreg3 = -1; } while (0); (((args [1])))->cil_code = (((cfg)))->ip; } while (0); ((args [1]))->data.op[0].const_val = ((actions.demandchoice.size)); ((args [1]))->type = STACK_I4; ((args [1]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [1])); ((args [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [1])); } } while (0); } while (0);
>
>   mono_emit_method_call (cfg, secman->demandchoice, args, ((void *)0));
>  }
> }
>
>
> if (pinvoke) {
>  mono_emit_method_call (cfg, secman->demandunmanaged, ((void *)0), ((void *)0));
> }
>
> if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) {
>
>  if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
>   MonoMethod *wrapped = mono_marshal_method_from_wrapper (method);
>   if (wrapped) {
>    gboolean pinvk = (wrapped->flags & 0x2000);
>    gboolean icall = (wrapped->iflags & 0x1000);
>
>
>    if ((icall || pinvk) && method->klass && method->klass->image) {
>     if (!mono_security_core_clr_is_platform_image (method->klass->image)) {
>      MonoException *ex = icall ? mono_get_exception_security () :
>       mono_get_exception_method_access ();
>      emit_throw_exception (cfg, ex);
>     }
>    }
>   }
>  }
> }
>
> if (header->code_size == 0)
>  do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
> if (get_basic_blocks (cfg, header, cfg->real_offset, ip, end, &err_pos)) {
>  ip = err_pos;
>  do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
> }
>
> if (cfg->method == method)
>  mono_debug_init_method (cfg, bblock, breakpoint_id);
>
> for (n = 0; n < header->num_locals; ++n) {
>  if (header->locals [n]->type == MONO_TYPE_VOID && !header->locals [n]->byref)
>   do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
> }
> class_inits = ((void *)0);
>
>
>
>
> if (cfg->generic_sharing_context && method == cfg->method) {
>  if ((method->flags & 0x0010) ||
>    mini_method_get_context (method)->method_inst ||
>    method->klass->valuetype) {
>   mono_get_vtable_var (cfg);
>  } else {
>
>
>
>   cfg->args [0]->flags |= MONO_INST_INDIRECT;
>  }
> }
>
>
> if (is_virtual_call) {
>  MonoInst *arg_ins;
>
>  do { do { (((arg_ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((arg_ins)))->data.op[0].const_val = (((arg_ins)))->data.op[1].const_val = 0; (((arg_ins)))->next = (((arg_ins)))->prev = ((void *)0); (((arg_ins)))->opcode = (OP_MOVE); (((arg_ins)))->flags = 0; (((arg_ins)))->type = 0; (((arg_ins)))->dreg = -1; do { ((((arg_ins))))->sreg1 = ((((arg_ins))))->sreg2 = ((((arg_ins))))->sreg3 = -1; } while (0); (((arg_ins)))->cil_code = (((cfg)))->ip; } while (0); ((arg_ins))->opcode = mono_type_to_regmove (((cfg)), (cfg->arg_types [(0)])); type_to_eval_stack_type (((cfg)), (cfg->arg_types [(0)]), ((arg_ins))); ((arg_ins))->klass = cfg->args [(0)]->klass; ((arg_ins))->sreg1 = cfg->args [(0)]->dreg; ((arg_ins))->dreg = alloc_dreg (((cfg)), ((arg_ins))->type); if (((arg_ins))->opcode == OP_VMOVE) ((arg_ins))->klass = mono_class_from_mono_type ((cfg->arg_types [(0)])); } while (0);
>  do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (arg_ins); (arg_ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (arg_ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (arg_ins); } } while (0);
>  do { cfg->flags |= MONO_CFG_HAS_CHECK_THIS; if (cfg->explicit_null_checks) { do { if (cfg->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (arg_ins->dreg); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); } else { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_CHECK_THIS)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((arg_ins->dreg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_NOT_NULL)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((arg_ins->dreg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } while (0);
> }
>
> skip_dead_blocks = !dont_verify;
> if (skip_dead_blocks) {
>  original_bb = bb = mono_basic_block_split (method, &error);
>  if (!mono_error_ok (&error)) {
>   mono_error_cleanup (&error);
>   do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>  }
>  do { if (!(bb)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6077, "bb"); } while (0);
> }
>
>
> stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
>
> ins_flag = 0;
> start_new_bblock = 0;
> cfg->cbb = bblock;
> while (ip < end) {
>  if (cfg->method == method)
>   cfg->real_offset = ip - header->code;
>  else
>   cfg->real_offset = inline_offset;
>  cfg->ip = ip;
>
>  context_used = 0;
>
>  if (start_new_bblock) {
>   bblock->cil_length = ip - bblock->cil_code;
>   if (start_new_bblock == 2) {
>    do { if (!(ip == tblock->cil_code)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6098, "ip == tblock->cil_code"); } while (0);
>   } else {
>    do { (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; if (!(tblock)) { if ((ip) >= end || (ip) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (ip); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   }
>   bblock->next_bb = tblock;
>   bblock = tblock;
>   cfg->cbb = bblock;
>   start_new_bblock = 0;
>   for (i = 0; i < bblock->in_scount; ++i) {
>    if (cfg->verbose_level > 3)
>     printf ("loading %d from temp %d\n", i, (int)bblock->in_stack [i]->data.op[0].const_val);
>    do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((bblock->in_stack [i]->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((bblock->in_stack [i]->data.op[0].const_val))]->data.op[1].vtype), (((ins)))); (((ins)))->klass = ((cfg))->varinfo [((bblock->in_stack [i]->data.op[0].const_val))]->klass; (((ins)))->sreg1 = ((cfg))->varinfo [((bblock->in_stack [i]->data.op[0].const_val))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((bblock->in_stack [i]->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    *sp++ = ins;
>   }
>   if (class_inits)
>    monoeg_g_slist_free (class_inits);
>   class_inits = ((void *)0);
>  } else {
>   if ((tblock = cfg->cil_offset_to_bb [ip - cfg->cil_start]) && (tblock != bblock)) {
>    link_bblock (cfg, bblock, tblock);
>    if (sp != stack_start) {
>     handle_stack_args (cfg, stack_start, sp - stack_start);
>     sp = stack_start;
>     if (cfg->unverifiable) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    }
>    bblock->next_bb = tblock;
>    bblock = tblock;
>    cfg->cbb = bblock;
>    for (i = 0; i < bblock->in_scount; ++i) {
>     if (cfg->verbose_level > 3)
>      printf ("loading %d from temp %d\n", i, (int)bblock->in_stack [i]->data.op[0].const_val);
>     do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((bblock->in_stack [i]->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((bblock->in_stack [i]->data.op[0].const_val))]->data.op[1].vtype), (((ins)))); (((ins)))->klass = ((cfg))->varinfo [((bblock->in_stack [i]->data.op[0].const_val))]->klass; (((ins)))->sreg1 = ((cfg))->varinfo [((bblock->in_stack [i]->data.op[0].const_val))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((bblock->in_stack [i]->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     *sp++ = ins;
>    }
>    monoeg_g_slist_free (class_inits);
>    class_inits = ((void *)0);
>   }
>  }
>
>  if (skip_dead_blocks) {
>   int ip_offset = ip - header->code;
>
>   if (ip_offset == bb->end)
>    bb = bb->next;
>
>   if (bb->dead) {
>    int op_size = mono_opcode_size (ip, end);
>    do { if (!(op_size > 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6145, "op_size > 0"); } while (0);
>
>    if (cfg->verbose_level > 3) printf ("SKIPPING DEAD OP at %x\n", ip_offset);
>
>    if (ip_offset + op_size == bb->end) {
>     do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_NOP); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>     do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>     start_new_bblock = 1;
>    }
>
>    ip += op_size;
>    continue;
>   }
>  }
>
>
>
>
>
>  if (seq_points && sp == stack_start) {
>   do { do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = (OP_SEQ_POINT); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); (ins)->data.op[1].const_val = (ip - header->code); (ins)->flags = 1 ? MONO_INST_SINGLE_STEP_LOC : 0; } while (0);
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>  }
>
>  bblock->real_offset = cfg->real_offset;
>
>  if ((cfg->method == method) && cfg->coverage_info) {
>   guint32 cil_offset = ip - header->code;
>   cfg->coverage_info->data [cil_offset].cil_code = ip;
># 6182 "method-to-ir.c"
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((&(cfg->coverage_info->data [cil_offset].count))); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STORE_MEMBASE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = ins->dreg; inst->data.op[0].const_val = 0; inst->data.op[1].const_val = (mgreg_t)(1); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>  }
>
>  if (cfg->verbose_level > 3)
>   printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (((void *)0), method, ip, ((void *)0)));
>
>  switch (*ip) {
>  case CEE_NOP:
>   if (cfg->keep_cil_nops)
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_HARD_NOP); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   else
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_NOP); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ip++;
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   break;
>  case CEE_BREAK:
>   if (should_insert_brekpoint (cfg->method))
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BREAK); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   else
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_NOP); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ip++;
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   break;
>  case CEE_LDARG_0:
>  case CEE_LDARG_1:
>  case CEE_LDARG_2:
>  case CEE_LDARG_3:
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   n = (*ip)-CEE_LDARG_0;
>   if ((unsigned)(n) >= (unsigned)num_args) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), ((cfg)->arg_types [((n))])); type_to_eval_stack_type ((((cfg))), ((cfg)->arg_types [((n))]), (((ins)))); (((ins)))->klass = (cfg)->args [((n))]->klass; (((ins)))->sreg1 = (cfg)->args [((n))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type (((cfg)->arg_types [((n))])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ip++;
>   *sp++ = ins;
>   break;
>  case CEE_LDLOC_0:
>  case CEE_LDLOC_1:
>  case CEE_LDLOC_2:
>  case CEE_LDLOC_3:
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   n = (*ip)-CEE_LDLOC_0;
>   if ((unsigned)(n) >= (unsigned)header->num_locals) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (header->locals [((n))])); type_to_eval_stack_type ((((cfg))), (header->locals [((n))]), (((ins)))); (((ins)))->klass = (cfg)->locals [((n))]->klass; (((ins)))->sreg1 = (cfg)->locals [((n))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((header->locals [((n))])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ip++;
>   *sp++ = ins;
>   break;
>  case CEE_STLOC_0:
>  case CEE_STLOC_1:
>  case CEE_STLOC_2:
>  case CEE_STLOC_3: {
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   n = (*ip)-CEE_STLOC_0;
>   if ((unsigned)(n) >= (unsigned)header->num_locals) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>   if (!dont_verify_stloc && target_type_is_incompatible (cfg, header->locals [n], *sp))
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   emit_stloc_ir (cfg, sp, header, n);
>   ++ip;
>   inline_costs += 1;
>   break;
>   }
>  case CEE_LDARG_S:
>   if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   n = ip [1];
>   if ((unsigned)(n) >= (unsigned)num_args) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), ((cfg)->arg_types [((n))])); type_to_eval_stack_type ((((cfg))), ((cfg)->arg_types [((n))]), (((ins)))); (((ins)))->klass = (cfg)->args [((n))]->klass; (((ins)))->sreg1 = (cfg)->args [((n))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type (((cfg)->arg_types [((n))])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   *sp++ = ins;
>   ip += 2;
>   break;
>  case CEE_LDARGA_S:
>   if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   n = ip [1];
>   if ((unsigned)(n) >= (unsigned)num_args) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_LDADDR); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = (arg_array [(n)]); (arg_array [(n)])->flags |= MONO_INST_INDIRECT; ((ins))->type = STACK_MP; ((ins))->klass = (arg_array [(n)])->klass; ((ins))->dreg = alloc_dreg (((cfg)), STACK_MP); if (8 == 4 && (((arg_array [(n)])->type) == STACK_I8)) { MonoInst *var1 = (((arg_array [(n)])->dreg + 1) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [((arg_array [(n)])->dreg + 1)] : ((void *)0)); MonoInst *var2 = (((arg_array [(n)])->dreg + 2) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [((arg_array [(n)])->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6258, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6258, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0);
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>   *sp++ = ins;
>   ip += 2;
>   break;
>  case CEE_STARG_S:
>   if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>   n = ip [1];
>   if ((unsigned)(n) >= (unsigned)num_args) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (!dont_verify_stloc && target_type_is_incompatible (cfg, param_types [ip [1]], *sp))
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), ((cfg)->arg_types [((n))])); (((ins)))->klass = ((cfg)->args [((n))])->klass; (((ins)))->sreg1 = (((*sp)))->dreg; (((ins)))->dreg = ((cfg)->args [((n))])->dreg; if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type (((cfg)->arg_types [((n))])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ip += 2;
>   break;
>  case CEE_LDLOC_S:
>   if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   n = ip [1];
>   if ((unsigned)(n) >= (unsigned)header->num_locals) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (header->locals [((n))])); type_to_eval_stack_type ((((cfg))), (header->locals [((n))]), (((ins)))); (((ins)))->klass = (cfg)->locals [((n))]->klass; (((ins)))->sreg1 = (cfg)->locals [((n))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((header->locals [((n))])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   *sp++ = ins;
>   ip += 2;
>   break;
>  case CEE_LDLOCA_S: {
>   unsigned char *tmp_ip;
>   if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if ((unsigned)(ip [1]) >= (unsigned)header->num_locals) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   if ((tmp_ip = emit_optimized_ldloca_ir (cfg, ip, end, 1))) {
>    ip = tmp_ip;
>    inline_costs += 1;
>    break;
>   }
>
>   do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_LDADDR); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->data.op[0].p = (((cfg))->locals [((ip [1]))]); (((cfg))->locals [((ip [1]))])->flags |= MONO_INST_INDIRECT; (((ins)))->type = STACK_MP; (((ins)))->klass = (((cfg))->locals [((ip [1]))])->klass; (((ins)))->dreg = alloc_dreg ((((cfg))), STACK_MP); if (8 == 4 && (((((cfg))->locals [((ip [1]))])->type) == STACK_I8)) { MonoInst *var1 = (((((cfg))->locals [((ip [1]))])->dreg + 1) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [((((cfg))->locals [((ip [1]))])->dreg + 1)] : ((void *)0)); MonoInst *var2 = (((((cfg))->locals [((ip [1]))])->dreg + 2) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [((((cfg))->locals [((ip [1]))])->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6295, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6295, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   *sp++ = ins;
>   ip += 2;
>   break;
>  }
>  case CEE_STLOC_S:
>   if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>   if ((unsigned)(ip [1]) >= (unsigned)header->num_locals) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (!dont_verify_stloc && target_type_is_incompatible (cfg, header->locals [ip [1]], *sp))
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   emit_stloc_ir (cfg, sp, header, ip [1]);
>   ip += 2;
>   inline_costs += 1;
>   break;
>  case CEE_LDNULL:
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((((void *)0))); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ins->type = STACK_OBJ;
>   ++ip;
>   *sp++ = ins;
>   break;
>  case CEE_LDC_I4_M1:
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_ICONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].const_val = ((-1)); ((ins))->type = STACK_I4; ((ins))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ++ip;
>   *sp++ = ins;
>   break;
>  case CEE_LDC_I4_0:
>  case CEE_LDC_I4_1:
>  case CEE_LDC_I4_2:
>  case CEE_LDC_I4_3:
>  case CEE_LDC_I4_4:
>  case CEE_LDC_I4_5:
>  case CEE_LDC_I4_6:
>  case CEE_LDC_I4_7:
>  case CEE_LDC_I4_8:
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_ICONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].const_val = (((*ip) - CEE_LDC_I4_0)); ((ins))->type = STACK_I4; ((ins))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ++ip;
>   *sp++ = ins;
>   break;
>  case CEE_LDC_I4_S:
>   if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   ++ip;
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_ICONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].const_val = ((*((signed char*)ip))); ((ins))->type = STACK_I4; ((ins))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ++ip;
>   *sp++ = ins;
>   break;
>  case CEE_LDC_I4:
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_ICONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].const_val = (((gint32)(((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) )))); ((ins))->type = STACK_I4; ((ins))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ip += 5;
>   *sp++ = ins;
>   break;
>  case CEE_LDC_I8:
>   if (ip + 9 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_I8CONST); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ins->type = STACK_I8;
>   ins->dreg = alloc_dreg (cfg, STACK_I8);
>   ++ip;
>   ins->data.i8const = (gint64)(((guint64) (((guint64)(((guint32) ( (((guint32) (((guint64)*((const guint64 *) (ip))) & 0xffffffff)) << 24)| ((((guint32) (((guint64)*((const guint64 *) (ip))) & 0xffffffff)) & 0xff0000) >> 8) | ((((guint32) (((guint64)*((const guint64 *) (ip))) & 0xffffffff)) & 0xff00) << 8) | (((guint32) (((guint64)*((const guint64 *) (ip))) & 0xffffffff)) >> 24)) ))) << 32) | ((guint32) ( (((guint32) (((guint64)*((const guint64 *) (ip))) >> 32)) << 24)| ((((guint32) (((guint64)*((const guint64 *) (ip))) >> 32)) & 0xff0000) >> 8) | ((((guint32) (((guint64)*((const guint64 *) (ip))) >> 32)) & 0xff00) << 8) | (((guint32) (((guint64)*((const guint64 *) (ip))) >> 32)) >> 24)) )));
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   ip += 8;
>   *sp++ = ins;
>   break;
>  case CEE_LDC_R4: {
>   float *f;
>   gboolean use_aotconst = 0;
># 6376 "method-to-ir.c"
>   f = mono_domain_alloc (cfg->domain, sizeof (float));
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   if (use_aotconst) {
>    MonoInst *cons;
>    int dreg;
>
>    do { do { do { (((cons))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((cons)))->data.op[0].const_val = (((cons)))->data.op[1].const_val = 0; (((cons)))->next = (((cons)))->prev = ((void *)0); (((cons)))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((cons)))->flags = 0; (((cons)))->type = 0; (((cons)))->dreg = -1; do { ((((cons))))->sreg1 = ((((cons))))->sreg2 = ((((cons))))->sreg3 = -1; } while (0); (((cons)))->cil_code = (((cfg)))->ip; } while (0); ((cons))->data.op[0].p = ((f)); ((cons))->data.op[1].src = (gpointer)((MONO_PATCH_INFO_R4)); ((cons))->type = STACK_PTR; ((cons))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((cons)); ((cons))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((cons)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((cons)); } } while (0); } while (0);
>
>    dreg = alloc_freg (cfg);
>    do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LOADR4_MEMBASE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = ((dreg)); ((ins))->sreg1 = ((cons->dreg)); ((ins))->data.op[0].const_val = ((0)); ((ins))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    ins->type = STACK_R8;
>   } else {
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_R4CONST); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->type = STACK_R8;
>    ins->dreg = alloc_dreg (cfg, STACK_R8);
>    ins->data.op[0].p = f;
>    do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   }
>   ++ip;
>   do { mono_rfloat mf; mf.ival = (((guint32) ( (((guint32) (*((const guint32 *) ((ip))))) << 24)| ((((guint32) (*((const guint32 *) ((ip))))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) ((ip))))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) ((ip))))) >> 24)) )); *(f) = mf.fval; } while (0);
>   ip += 4;
>   *sp++ = ins;
>   break;
>  }
>  case CEE_LDC_R8: {
>   double *d;
>   gboolean use_aotconst = 0;
># 6413 "method-to-ir.c"
>   d = mono_domain_alloc (cfg->domain, sizeof (double));
>   if (ip + 9 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   if (use_aotconst) {
>    MonoInst *cons;
>    int dreg;
>
>    do { do { do { (((cons))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((cons)))->data.op[0].const_val = (((cons)))->data.op[1].const_val = 0; (((cons)))->next = (((cons)))->prev = ((void *)0); (((cons)))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((cons)))->flags = 0; (((cons)))->type = 0; (((cons)))->dreg = -1; do { ((((cons))))->sreg1 = ((((cons))))->sreg2 = ((((cons))))->sreg3 = -1; } while (0); (((cons)))->cil_code = (((cfg)))->ip; } while (0); ((cons))->data.op[0].p = ((d)); ((cons))->data.op[1].src = (gpointer)((MONO_PATCH_INFO_R8)); ((cons))->type = STACK_PTR; ((cons))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((cons)); ((cons))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((cons)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((cons)); } } while (0); } while (0);
>
>    dreg = alloc_freg (cfg);
>    do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LOADR8_MEMBASE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = ((dreg)); ((ins))->sreg1 = ((cons->dreg)); ((ins))->data.op[0].const_val = ((0)); ((ins))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    ins->type = STACK_R8;
>   } else {
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_R8CONST); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->type = STACK_R8;
>    ins->dreg = alloc_dreg (cfg, STACK_R8);
>    ins->data.op[0].p = d;
>    do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   }
>   ++ip;
>   do { mono_rdouble mf; mf.ival = (((guint64) (((guint64)(((guint32) ( (((guint32) (((guint64)*((const guint64 *) ((ip)))) & 0xffffffff)) << 24)| ((((guint32) (((guint64)*((const guint64 *) ((ip)))) & 0xffffffff)) & 0xff0000) >> 8) | ((((guint32) (((guint64)*((const guint64 *) ((ip)))) & 0xffffffff)) & 0xff00) << 8) | (((guint32) (((guint64)*((const guint64 *) ((ip)))) & 0xffffffff)) >> 24)) ))) << 32) | ((guint32) ( (((guint32) (((guint64)*((const guint64 *) ((ip)))) >> 32)) << 24)| ((((guint32) (((guint64)*((const guint64 *) ((ip)))) >> 32)) & 0xff0000) >> 8) | ((((guint32) (((guint64)*((const guint64 *) ((ip)))) >> 32)) & 0xff00) << 8) | (((guint32) (((guint64)*((const guint64 *) ((ip)))) >> 32)) >> 24)) ))); ; *(d) = mf.fval; } while (0);
>   ip += 8;
>   *sp++ = ins;
>   break;
>  }
>  case CEE_DUP: {
>   MonoInst *temp, *store;
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   sp--;
>   ins = *sp;
>
>   temp = mono_compile_create_var (cfg, type_from_stack_type (ins), OP_LOCAL);
>   do { do { do { ((((store)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((store))))->data.op[0].const_val = ((((store))))->data.op[1].const_val = 0; ((((store))))->next = ((((store))))->prev = ((void *)0); ((((store))))->opcode = (OP_MOVE); ((((store))))->flags = 0; ((((store))))->type = 0; ((((store))))->dreg = -1; do { (((((store)))))->sreg1 = (((((store)))))->sreg2 = (((((store)))))->sreg3 = -1; } while (0); ((((store))))->cil_code = ((((cfg))))->ip; } while (0); (((store)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((temp->data.op[0].const_val))]->data.op[1].vtype)); (((store)))->klass = (((cfg))->varinfo [((temp->data.op[0].const_val))])->klass; (((store)))->sreg1 = (((ins)))->dreg; (((store)))->dreg = (((cfg))->varinfo [((temp->data.op[0].const_val))])->dreg; if ((((store)))->opcode == OP_VMOVE) (((store)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((temp->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((store)); ((store))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((store)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((store)); } } while (0); } while (0);
>
>   do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((temp->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((temp->data.op[0].const_val))]->data.op[1].vtype), (((ins)))); (((ins)))->klass = ((cfg))->varinfo [((temp->data.op[0].const_val))]->klass; (((ins)))->sreg1 = ((cfg))->varinfo [((temp->data.op[0].const_val))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((temp->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   *sp++ = ins;
>
>   do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((temp->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((temp->data.op[0].const_val))]->data.op[1].vtype), (((ins)))); (((ins)))->klass = ((cfg))->varinfo [((temp->data.op[0].const_val))]->klass; (((ins)))->sreg1 = ((cfg))->varinfo [((temp->data.op[0].const_val))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((temp->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   *sp++ = ins;
>
>   ++ip;
>   inline_costs += 2;
>   break;
>  }
>  case CEE_POP:
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   ip++;
>   --sp;
>
>
>
>
>
>
>   break;
>  case CEE_JMP: {
>   MonoCallInst *call;
>
>   do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (stack_start != sp)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>
>   cmethod = mini_get_method (cfg, method, token, ((void *)0), generic_context);
>
>   if (!cmethod || mono_loader_get_last_error ())
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>
>   if (cfg->generic_sharing_context && mono_method_check_context_used (cmethod))
>    do { if (cfg->generic_sharing_context) { if (cfg->verbose_level > 2) printf ("sharing failed for method %s.%s.%s/%d opcode %s line %d\n", method->klass->name_space, method->klass->name, method->name, method->signature->param_count, mono_opcode_name ((CEE_JMP)), 6486); mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); goto exception_exit; } } while (0);
>
>   if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS)
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
># 6512 "method-to-ir.c"
>   for (i = 0; i < num_args; ++i)
>
>    arg_array [i]->flags |= MONO_INST_VOLATILE;
>
>   do { (call) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoCallInst)); (call)->inst.opcode = (OP_JMP); (call)->inst.dreg = -1; do { (&(call)->inst)->sreg1 = (&(call)->inst)->sreg2 = (&(call)->inst)->sreg3 = -1; } while (0); (call)->inst.cil_code = (cfg)->ip; } while (0);
>   ins = (MonoInst*)call;
>   ins->data.op[0].p = cmethod;
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>
>
>   ip += 5;
>   start_new_bblock = 1;
>   break;
>  }
>  case CEE_CALLI:
>  case CEE_CALL:
>  case CEE_CALLVIRT: {
>   MonoInst *addr = ((void *)0);
>   MonoMethodSignature *fsig = ((void *)0);
>   int array_rank = 0;
>   int virtual = *ip == CEE_CALLVIRT;
>   int calli = *ip == CEE_CALLI;
>   gboolean pass_imt_from_rgctx = 0;
>   MonoInst *imt_arg = ((void *)0);
>   gboolean pass_vtable = 0;
>   gboolean pass_mrgctx = 0;
>   MonoInst *vtable_arg = ((void *)0);
>   gboolean check_this = 0;
>   gboolean supported_tail_call = 0;
>
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>
>   if (calli) {
>    cmethod = ((void *)0);
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>    addr = *sp;
>    if (method->wrapper_type != MONO_WRAPPER_NONE)
>     fsig = (MonoMethodSignature *)mono_method_get_wrapper_data (method, token);
>    else
>     fsig = mono_metadata_parse_signature (image, token);
>
>    n = fsig->param_count + fsig->hasthis;
>
>    if (method->dynamic && fsig->pinvoke) {
>     MonoInst *args [3];
>
>
>
>
>
>
>
>     do { do { do { (((args [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [0])))->data.op[0].const_val = (((args [0])))->data.op[1].const_val = 0; (((args [0])))->next = (((args [0])))->prev = ((void *)0); (((args [0])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((args [0])))->flags = 0; (((args [0])))->type = 0; (((args [0])))->dreg = -1; do { ((((args [0]))))->sreg1 = ((((args [0]))))->sreg2 = ((((args [0]))))->sreg3 = -1; } while (0); (((args [0])))->cil_code = (((cfg)))->ip; } while (0); ((args [0]))->data.op[0].p = ((method->klass->image)); ((args [0]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_IMAGE); ((args [0]))->type = STACK_PTR; ((args [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [0])); ((args [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [0])); } } while (0); } while (0);
>     do { do { do { (((args [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [1])))->data.op[0].const_val = (((args [1])))->data.op[1].const_val = 0; (((args [1])))->next = (((args [1])))->prev = ((void *)0); (((args [1])))->opcode = (OP_I8CONST); (((args [1])))->flags = 0; (((args [1])))->type = 0; (((args [1])))->dreg = -1; do { ((((args [1]))))->sreg1 = ((((args [1]))))->sreg2 = ((((args [1]))))->sreg3 = -1; } while (0); (((args [1])))->cil_code = (((cfg)))->ip; } while (0); ((args [1]))->data.op[0].p = ((fsig)); ((args [1]))->type = STACK_PTR; ((args [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [1])); ((args [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [1])); } } while (0); } while (0);
>     args [2] = addr;
>     addr = mono_emit_jit_icall (cfg, mono_get_native_calli_wrapper, args);
>    }
>   } else {
>    MonoMethod *cil_method;
>
>    if (method->wrapper_type != MONO_WRAPPER_NONE) {
>     cmethod = (MonoMethod *)mono_method_get_wrapper_data (method, token);
>     cil_method = cmethod;
>    } else if (constrained_call) {
>     if ((constrained_call->byval_arg.type == MONO_TYPE_VAR || constrained_call->byval_arg.type == MONO_TYPE_MVAR) && cfg->generic_sharing_context) {
>
>
>
>
>
>
>      cmethod = mini_get_method (cfg, method, token, ((void *)0), generic_context);
>      cil_method = cmethod;
>      do { if (!(!cmethod->klass->valuetype)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6587, "!cmethod->klass->valuetype"); } while (0);
>     } else {
>      cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
>     }
>    } else {
>     cmethod = mini_get_method (cfg, method, token, ((void *)0), generic_context);
>     cil_method = cmethod;
>    }
>
>    if (!cmethod || mono_loader_get_last_error ())
>     do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>    if (!dont_verify && !cfg->skip_visibility) {
>     MonoMethod *target_method = cil_method;
>     if (method->is_inflated) {
>      target_method = mini_get_method_allow_open (method, token, ((void *)0), &(mono_method_get_generic_container (method_definition)->context));
>     }
>     if (!mono_method_can_access_method (method_definition, target_method) &&
>      !mono_method_can_access_method (method, cil_method))
>      do { char *method_fname = mono_method_full_name (method, 1); char *cil_method_fname = mono_method_full_name (cil_method, 1); mono_cfg_set_exception (cfg, MONO_EXCEPTION_METHOD_ACCESS); cfg->exception_message = monoeg_g_strdup_printf ("Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname); monoeg_g_free (method_fname); monoeg_g_free (cil_method_fname); goto exception_exit; } while (0);
>    }
>
>    if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
>     ensure_method_is_allowed_to_call_method (cfg, method, cil_method, bblock, ip);
>
>    if (!virtual && (cmethod->flags & 0x0400))
>
>     virtual = 1;
>
>    {
>
>
>
>
>
>
>     const int test_flags = 0x0040 | 0x0020 | 0x0010;
>     const int expected_flags = 0x0040 | 0x0020;
>     if (!virtual && cmethod->klass->marshalbyref && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
>      virtual = 1;
>    }
>
>    if (!cmethod->klass->inited)
>     if (!mono_class_init (cmethod->klass))
>      do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>
>    if (cmethod->iflags & 0x1000 &&
>        mini_class_is_system_array (cmethod->klass)) {
>     array_rank = cmethod->klass->rank;
>     fsig = mono_method_signature (cmethod);
>    } else {
>     fsig = mono_method_signature (cmethod);
>
>     if (!fsig)
>      do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>
>     if (fsig->pinvoke) {
>      MonoMethod *wrapper = mono_marshal_get_native_wrapper (cmethod,
>       check_for_pending_exc, 0);
>      fsig = mono_method_signature (wrapper);
>     } else if (constrained_call) {
>      fsig = mono_method_signature (cmethod);
>     } else {
>      fsig = mono_method_get_signature_full (cmethod, image, token, generic_context);
>     }
>    }
>
>    mono_save_token_info (cfg, image, token, cil_method);
>
>    n = fsig->param_count + fsig->hasthis;
>
>    if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS) {
>     if (check_linkdemand (cfg, method, cmethod))
>      do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>     do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>    }
>
>    if (cmethod->string_ctor && method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE)
>     do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 6664); } while (0);
>   }
>
>   if (!cfg->generic_sharing_context && cmethod && cmethod->klass->generic_container)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   if (!cfg->generic_sharing_context && cmethod)
>    do { if (!(!mono_method_check_context_used (cmethod))) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6671, "!mono_method_check_context_used (cmethod)"); } while (0);
>
>   if ((sp - stack_start) < (n)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>
>
>   sp -= n;
>
>   if (constrained_call) {
>
>
>
>    if (constrained_call->valuetype && !cmethod->klass->valuetype) {
>
>
>
>
>
>     do { do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = ((mono_type_to_load_membase (((cfg)), ((&constrained_call->byval_arg))))); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->dreg = (0); (((ins)))->sreg1 = (((sp [0]->dreg))); (((ins)))->data.op[0].const_val = (((0))); (((ins)))->type = STACK_I4; } while (0); type_to_eval_stack_type (((cfg)), ((&constrained_call->byval_arg)), ((ins))); ((ins))->dreg = alloc_dreg (((cfg)), ((ins))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     ins->klass = constrained_call;
>     sp [0] = handle_box (cfg, ins, constrained_call, mono_class_check_context_used (constrained_call));
>     do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>    } else if (!constrained_call->valuetype) {
>     int dreg = alloc_ireg_ref (cfg);
>
>
>
>
>
>
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LOAD_MEMBASE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = ((dreg)); ((ins))->sreg1 = ((sp [0]->dreg)); ((ins))->data.op[0].const_val = ((0)); ((ins))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     ins->type = STACK_OBJ;
>     sp [0] = ins;
>    } else if (cmethod->klass->valuetype)
>     virtual = 0;
>    constrained_call = ((void *)0);
>   }
>
>   if (*ip != CEE_CALLI && check_call_signature (cfg, fsig, sp))
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>
>
>
>
>   if (cfg->generic_sharing_context && cmethod && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable_impl (cmethod, 1) && mono_class_needs_cctor_run (cmethod->klass, method)) {
>    emit_generic_class_init (cfg, cmethod->klass);
>    if (!(cmethod->klass) || (cmethod->klass)->exception_type) {cfg->exception_ptr = cmethod->klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>   }
>
>   if (cmethod && ((cmethod->flags & 0x0010) || cmethod->klass->valuetype) &&
>     (cmethod->klass->generic_class || cmethod->klass->generic_container)) {
>    gboolean sharing_enabled = mono_class_generic_sharing_enabled (cmethod->klass);
>    MonoGenericContext *context = mini_class_get_context (cmethod->klass);
>    gboolean context_sharable = mono_generic_context_is_sharable (context, 1);
># 6734 "method-to-ir.c"
>    if (sharing_enabled && context_sharable &&
>     !(mini_method_get_context (cmethod) && mini_method_get_context (cmethod)->method_inst))
>     pass_vtable = 1;
>   }
>
>   if (cmethod && mini_method_get_context (cmethod) &&
>     mini_method_get_context (cmethod)->method_inst) {
>    gboolean sharing_enabled = mono_class_generic_sharing_enabled (cmethod->klass);
>    MonoGenericContext *context = mini_method_get_context (cmethod);
>    gboolean context_sharable = mono_generic_context_is_sharable (context, 1);
>
>    do { if (!(!pass_vtable)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6745, "!pass_vtable"); } while (0);
>
>    if (sharing_enabled && context_sharable)
>     pass_mrgctx = 1;
>   }
>
>   if (cfg->generic_sharing_context && cmethod) {
>    MonoGenericContext *cmethod_context = mono_method_get_context (cmethod);
>
>    context_used = mono_method_check_context_used (cmethod);
>
>    if (context_used && (cmethod->klass->flags & 0x00000020)) {
>
>
>
>
>     if (!cmethod_context || !cmethod_context->method_inst)
>      pass_imt_from_rgctx = 1;
>    }
># 6776 "method-to-ir.c"
>    if (context_used &&
>      ((method->flags & 0x0010) || method->klass->valuetype))
>     mono_get_vtable_var (cfg);
>   }
>
>   if (pass_vtable) {
>    if (context_used) {
>     vtable_arg = emit_get_rgctx_klass (cfg, context_used, cmethod->klass, MONO_RGCTX_INFO_VTABLE);
>    } else {
>     MonoVTable *vtable = mono_class_vtable (cfg->domain, cmethod->klass);
>
>     if (!(cmethod->klass) || (cmethod->klass)->exception_type) {cfg->exception_ptr = cmethod->klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>     do { do { do { (((vtable_arg))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((vtable_arg)))->data.op[0].const_val = (((vtable_arg)))->data.op[1].const_val = 0; (((vtable_arg)))->next = (((vtable_arg)))->prev = ((void *)0); (((vtable_arg)))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((vtable_arg)))->flags = 0; (((vtable_arg)))->type = 0; (((vtable_arg)))->dreg = -1; do { ((((vtable_arg))))->sreg1 = ((((vtable_arg))))->sreg2 = ((((vtable_arg))))->sreg3 = -1; } while (0); (((vtable_arg)))->cil_code = (((cfg)))->ip; } while (0); ((vtable_arg))->data.op[0].p = (cfg->compile_aot ? (gpointer)((vtable)->klass) : (vtable)); ((vtable_arg))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_VTABLE); ((vtable_arg))->type = STACK_PTR; ((vtable_arg))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((vtable_arg)); ((vtable_arg))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((vtable_arg)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((vtable_arg)); } } while (0); } while (0);
>    }
>   }
>
>   if (pass_mrgctx) {
>    do { if (!(!vtable_arg)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6793, "!vtable_arg"); } while (0);
>
>    if (!cfg->compile_aot) {
>
>
>
>
>     mono_class_setup_vtable (cmethod->klass);
>     if (!(cmethod->klass) || (cmethod->klass)->exception_type) {cfg->exception_ptr = cmethod->klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>    }
>
>    vtable_arg = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_METHOD_RGCTX);
>
>
>    if ((!(cmethod->flags & 0x0040) ||
>      (((cmethod)->flags & 0x0020) || ((cmethod)->klass && ((cmethod)->klass->flags & 0x00000100)))) &&
>     !cmethod->klass->marshalbyref) {
>     if (virtual)
>      check_this = 1;
>     virtual = 0;
>    }
>   }
>
>   if (pass_imt_from_rgctx) {
>    do { if (!(!pass_vtable)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6817, "!pass_vtable"); } while (0);
>    do { if (!(cmethod)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6818, "cmethod"); } while (0);
>
>    imt_arg = emit_get_rgctx_method (cfg, context_used,
>     cmethod, MONO_RGCTX_INFO_METHOD);
>   }
>
>   if (check_this)
>    do { cfg->flags |= MONO_CFG_HAS_CHECK_THIS; if (cfg->explicit_null_checks) { do { if (cfg->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (sp [0]->dreg); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); } else { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_CHECK_THIS)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((sp [0]->dreg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_NOT_NULL)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((sp [0]->dreg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } while (0);
>
>
>   if (cmethod && virtual &&
>       (cmethod->flags & 0x0040) &&
>        !((((cmethod)->flags & 0x0020) || ((cmethod)->klass && ((cmethod)->klass->flags & 0x00000100))) &&
>         cmethod->wrapper_type != MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK) &&
>       mono_method_signature (cmethod)->generic_param_count) {
>    MonoInst *this_temp, *this_arg_temp, *store;
>    MonoInst *iargs [4];
>
>    do { if (!(mono_method_signature (cmethod)->is_inflated)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6836, "mono_method_signature (cmethod)->is_inflated"); } while (0);
>
>
>    do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
># 6851 "method-to-ir.c"
>    {
>     this_temp = mono_compile_create_var (cfg, type_from_stack_type (sp [0]), OP_LOCAL);
>     do { do { (((store))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((store)))->data.op[0].const_val = (((store)))->data.op[1].const_val = 0; (((store)))->next = (((store)))->prev = ((void *)0); (((store)))->opcode = (OP_MOVE); (((store)))->flags = 0; (((store)))->type = 0; (((store)))->dreg = -1; do { ((((store))))->sreg1 = ((((store))))->sreg2 = ((((store))))->sreg3 = -1; } while (0); (((store)))->cil_code = (((cfg)))->ip; } while (0); ((store))->opcode = mono_type_to_regmove (((cfg)), ((cfg)->varinfo [(this_temp->data.op[0].const_val)]->data.op[1].vtype)); ((store))->klass = ((cfg)->varinfo [(this_temp->data.op[0].const_val)])->klass; ((store))->sreg1 = ((sp [0]))->dreg; ((store))->dreg = ((cfg)->varinfo [(this_temp->data.op[0].const_val)])->dreg; if (((store))->opcode == OP_VMOVE) ((store))->klass = mono_class_from_mono_type (((cfg)->varinfo [(this_temp->data.op[0].const_val)]->data.op[1].vtype)); } while (0);
>     do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (store); (store)->prev = (bblock)->last_ins; (bblock)->last_ins = (store); } else { (bblock)->code = (bblock)->last_ins = (store); } } while (0);
>
>
>     this_arg_temp = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
>
>     do { do { do { ((((iargs [0])))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((iargs [0]))))->data.op[0].const_val = ((((iargs [0]))))->data.op[1].const_val = 0; ((((iargs [0]))))->next = ((((iargs [0]))))->prev = ((void *)0); ((((iargs [0]))))->opcode = (OP_MOVE); ((((iargs [0]))))->flags = 0; ((((iargs [0]))))->type = 0; ((((iargs [0]))))->dreg = -1; do { (((((iargs [0])))))->sreg1 = (((((iargs [0])))))->sreg2 = (((((iargs [0])))))->sreg3 = -1; } while (0); ((((iargs [0]))))->cil_code = ((((cfg))))->ip; } while (0); (((iargs [0])))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((this_temp->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((this_temp->data.op[0].const_val))]->data.op[1].vtype), (((iargs [0])))); (((iargs [0])))->klass = ((cfg))->varinfo [((this_temp->data.op[0].const_val))]->klass; (((iargs [0])))->sreg1 = ((cfg))->varinfo [((this_temp->data.op[0].const_val))]->dreg; (((iargs [0])))->dreg = alloc_dreg ((((cfg))), (((iargs [0])))->type); if ((((iargs [0])))->opcode == OP_VMOVE) (((iargs [0])))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((this_temp->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>     iargs [1] = emit_get_rgctx_method (cfg, context_used,
>                cmethod, MONO_RGCTX_INFO_METHOD);
>     do { do { do { ((((iargs [2])))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((iargs [2]))))->data.op[0].const_val = ((((iargs [2]))))->data.op[1].const_val = 0; ((((iargs [2]))))->next = ((((iargs [2]))))->prev = ((void *)0); ((((iargs [2]))))->opcode = (OP_LDADDR); ((((iargs [2]))))->flags = 0; ((((iargs [2]))))->type = 0; ((((iargs [2]))))->dreg = -1; do { (((((iargs [2])))))->sreg1 = (((((iargs [2])))))->sreg2 = (((((iargs [2])))))->sreg3 = -1; } while (0); ((((iargs [2]))))->cil_code = ((((cfg))))->ip; } while (0); (((iargs [2])))->data.op[0].p = ((cfg)->varinfo [((this_arg_temp->data.op[0].const_val))]); ((cfg)->varinfo [((this_arg_temp->data.op[0].const_val))])->flags |= MONO_INST_INDIRECT; (((iargs [2])))->type = STACK_MP; (((iargs [2])))->klass = ((cfg)->varinfo [((this_arg_temp->data.op[0].const_val))])->klass; (((iargs [2])))->dreg = alloc_dreg ((((cfg))), STACK_MP); if (8 == 4 && ((((cfg)->varinfo [((this_arg_temp->data.op[0].const_val))])->type) == STACK_I8)) { MonoInst *var1 = ((((cfg)->varinfo [((this_arg_temp->data.op[0].const_val))])->dreg + 1) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((this_arg_temp->data.op[0].const_val))])->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((cfg)->varinfo [((this_arg_temp->data.op[0].const_val))])->dreg + 2) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((this_arg_temp->data.op[0].const_val))])->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6862, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 6862, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [2])); ((iargs [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [2])); } } while (0); } while (0);
>     addr = mono_emit_jit_icall (cfg,
>            mono_helper_compile_generic_method, iargs);
>
>     do { do { do { ((((sp [0])))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((sp [0]))))->data.op[0].const_val = ((((sp [0]))))->data.op[1].const_val = 0; ((((sp [0]))))->next = ((((sp [0]))))->prev = ((void *)0); ((((sp [0]))))->opcode = (OP_MOVE); ((((sp [0]))))->flags = 0; ((((sp [0]))))->type = 0; ((((sp [0]))))->dreg = -1; do { (((((sp [0])))))->sreg1 = (((((sp [0])))))->sreg2 = (((((sp [0])))))->sreg3 = -1; } while (0); ((((sp [0]))))->cil_code = ((((cfg))))->ip; } while (0); (((sp [0])))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((this_arg_temp->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((this_arg_temp->data.op[0].const_val))]->data.op[1].vtype), (((sp [0])))); (((sp [0])))->klass = ((cfg))->varinfo [((this_arg_temp->data.op[0].const_val))]->klass; (((sp [0])))->sreg1 = ((cfg))->varinfo [((this_arg_temp->data.op[0].const_val))]->dreg; (((sp [0])))->dreg = alloc_dreg ((((cfg))), (((sp [0])))->type); if ((((sp [0])))->opcode == OP_VMOVE) (((sp [0])))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((this_arg_temp->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((sp [0])); ((sp [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((sp [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((sp [0])); } } while (0); } while (0);
>
>     ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, ((void *)0));
>    }
>
>    if (!mono_type_is_void (fsig->ret))
>     *sp++ = mono_emit_widen_call_res (cfg, ins, fsig);
>
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>
>    ip += 5;
>    ins_flag = 0;
>    break;
>   }
># 6894 "method-to-ir.c"
>   if (cmethod && cmethod->klass == mono_defaults.monitor_class && !__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("Enter") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("Enter")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Enter") + 1) - (size_t)(const void *)("Enter") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "Enter") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("Enter") && ((size_t)(const void *)(("Enter") + 1) - (size_t)(const void *)("Enter") == 1) ? __builtin_strcmp (cmethod->name, "Enter") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Enter"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Enter") && ((size_t)(const void *)(("Enter") + 1) - (size_t)(const void *)("Enter") == 1) && (__s2_len = __strlen_g (("Enter")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "Enter") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("Enter"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Enter"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Enter"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Enter"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "Enter")))); }) && mono_method_signature (cmethod)->param_count == 1) {
>    MonoBasicBlock *tbb;
>
>    do { (tbb) = cfg->cil_offset_to_bb [(ip + 5) - cfg->cil_start]; if (!(tbb)) { if ((ip + 5) >= end || (ip + 5) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tbb)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tbb))->block_num = cfg->num_bblocks++; } while (0); (tbb)->cil_code = (ip + 5); do { if (((tbb))->cil_code) { cfg->cil_offset_to_bb [((tbb))->cil_code - cfg->cil_start] = ((tbb)); } ((tbb))->real_offset = cfg->real_offset; } while (0); } } while (0);
>
>
>
>
>    if (tbb->try_start && ((tbb->region) & 0x7) == MONO_EXCEPTION_CLAUSE_FINALLY) {
>
>     tbb->extend_try_block = 1;
>    }
>   }
>
>
>   if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
>    bblock = cfg->cbb;
>    if (!mono_type_is_void (fsig->ret)) {
>     type_to_eval_stack_type ((cfg), fsig->ret, ins);
>     *sp = ins;
>     sp++;
>    }
>
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>
>    ip += 5;
>    ins_flag = 0;
>    break;
>   }
>
>
>   if ((cfg->opt & MONO_OPT_INLINE) && cmethod &&
>    (!virtual || !(cmethod->flags & 0x0040) || (((cmethod)->flags & 0x0020) || ((cmethod)->klass && ((cmethod)->klass->flags & 0x00000100)))) &&
>       !disable_inline && mono_method_check_inlining (cfg, cmethod) &&
>     !monoeg_g_list_find (dont_inline, cmethod)) {
>    int costs;
>    gboolean always = 0;
>
>    if ((cmethod->iflags & 0x1000) ||
>     (cmethod->flags & 0x2000)) {
>
>     do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>     cmethod = mono_marshal_get_native_wrapper (cmethod, check_for_pending_exc, 0);
>     always = 1;
>    }
>
>     if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, always))) {
>     ip += 5;
>     cfg->real_offset += 5;
>     bblock = cfg->cbb;
>
>      if (!mono_type_is_void (fsig->ret))
>
>       sp++;
>
>     inline_costs += costs;
>     ins_flag = 0;
>     break;
>    }
>   }
>
>   inline_costs += 10 * num_calls++;
>
>
>   if ((cfg->opt & MONO_OPT_TAILC) && *ip == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
>    gboolean has_vtargs = 0;
>    int i;
>
>
>    do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>
>
>    for (i = fsig->param_count - 1; i >= 0; i--) {
>     if (mono_type_is_struct (mono_method_signature (cmethod)->params [i]))
>      has_vtargs = 1;
>    }
>
>    if (!has_vtargs) {
>     for (i = 0; i < n; ++i)
>      do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), ((cfg)->arg_types [((i))])); (((ins)))->klass = ((cfg)->args [((i))])->klass; (((ins)))->sreg1 = (((sp [i])))->dreg; (((ins)))->dreg = ((cfg)->args [((i))])->dreg; if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type (((cfg)->arg_types [((i))])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BR); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>     do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>     tblock = start_bblock->out_bb [0];
>     link_bblock (cfg, bblock, tblock);
>     ins->data.op[0].target_block = tblock;
>     start_new_bblock = 1;
>
>
>     if (ip_in_bb (cfg, bblock, ip + 5))
>      ip += 6;
>     else
>      ip += 5;
>
>     ins_flag = 0;
>     break;
>    }
>   }
>
>
>
>
>   if (context_used && !imt_arg && !array_rank &&
>     (!mono_method_is_generic_sharable_impl (cmethod, 1) ||
>      !mono_class_generic_sharing_enabled (cmethod->klass)) &&
>     (!virtual || (((cmethod)->flags & 0x0020) || ((cmethod)->klass && ((cmethod)->klass->flags & 0x00000100))) ||
>      !(cmethod->flags & 0x0040))) {
>    do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>
>    do { if (!(cfg->generic_sharing_context && cmethod)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 7002, "cfg->generic_sharing_context && cmethod"); } while (0);
>    do { if (!(!addr)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 7003, "!addr"); } while (0);
># 7012 "method-to-ir.c"
>    addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
>   }
>
>
>   if (addr) {
>    do { if (!(!imt_arg)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 7017, "!imt_arg"); } while (0);
>
>    if (*ip == CEE_CALL)
>     do { if (!(context_used)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 7020, "context_used"); } while (0);
>    else if (*ip == CEE_CALLI)
>     do { if (!(!vtable_arg)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 7022, "!vtable_arg"); } while (0);
>    else
>
>     do { if (!(cmethod->flags & 0x0020 || !(cmethod->flags & 0x0020))) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n",
> "method-to-ir.c"
># 7025 "method-to-ir.c"
>     ,
> 7026
># 7025 "method-to-ir.c"
>     , "cmethod->flags & METHOD_ATTRIBUTE_FINAL || !(cmethod->flags & METHOD_ATTRIBUTE_FINAL)"); } while (0)
>                                                  ;
>
>
>    do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>
>    if (vtable_arg) {
>     MonoCallInst *call;
>
>     ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, vtable_arg);
>     call = (MonoCallInst*)ins;
>    } else {
>     if (addr->opcode == OP_AOTCONST && addr->data.op[1].const_val == MONO_PATCH_INFO_ICALL_ADDR) {
>
>
>
>
>      ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->data.op[0].p, fsig, sp);
>      do { (addr)->opcode = OP_NOP; (addr)->dreg = -1; do { ((addr))->sreg1 = ((addr))->sreg2 = ((addr))->sreg3 = -1; } while (0); } while (0);
>     } else if (addr->opcode == OP_GOT_ENTRY && addr->data.op[1].src->data.op[1].const_val == MONO_PATCH_INFO_ICALL_ADDR) {
>      ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->data.op[1].src->data.op[0].src, fsig, sp);
>      do { (addr)->opcode = OP_NOP; (addr)->dreg = -1; do { ((addr))->sreg1 = ((addr))->sreg2 = ((addr))->sreg3 = -1; } while (0); } while (0);
>     } else {
>      ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, ((void *)0));
>     }
>    }
>    if (!mono_type_is_void (fsig->ret))
>     *sp++ = mono_emit_widen_call_res (cfg, ins, fsig);
>
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>
>    ip += 5;
>    ins_flag = 0;
>    break;
>   }
>
>
>   if (array_rank) {
>    MonoInst *addr;
>
>    if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("Set") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("Set")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Set") + 1) - (size_t)(const void *)("Set") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "Set") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("Set") && ((size_t)(const void *)(("Set") + 1) - (size_t)(const void *)("Set") == 1) ? __builtin_strcmp (cmethod->name, "Set") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Set"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Set") && ((size_t)(const void *)(("Set") + 1) - (size_t)(const void *)("Set") == 1) && (__s2_len = __strlen_g (("Set")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "Set") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("Set"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Set"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Set"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Set"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "Set")))); }) == 0) {
>     MonoInst *val = sp [fsig->param_count];
>
>     if (val->type == STACK_OBJ) {
>      MonoInst *iargs [2];
>
>      iargs [0] = sp [0];
>      iargs [1] = val;
>
>      mono_emit_jit_icall (cfg, mono_helper_stelem_ref_check, iargs);
>     }
>
>     addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, 1);
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (mono_type_to_store_membase (((cfg)), ((fsig->params [fsig->param_count - 1])))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->sreg1 = (val->dreg); ((ins))->dreg = (addr->dreg); ((ins))->data.op[0].const_val = (0); type_to_eval_stack_type (((cfg)), ((fsig->params [fsig->param_count - 1])), ((ins))); ((ins))->klass = mono_class_from_mono_type ((fsig->params [fsig->param_count - 1])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     if (cfg->gen_write_barriers && val->type == STACK_OBJ && !(val->opcode == OP_I8CONST && val->data.op[0].const_val == 0))
>      emit_write_barrier (cfg, addr, val, 0);
>    } else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("Get") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("Get")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Get") + 1) - (size_t)(const void *)("Get") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "Get") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("Get") && ((size_t)(const void *)(("Get") + 1) - (size_t)(const void *)("Get") == 1) ? __builtin_strcmp (cmethod->name, "Get") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Get"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Get") && ((size_t)(const void *)(("Get") + 1) - (size_t)(const void *)("Get") == 1) && (__s2_len = __strlen_g (("Get")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "Get") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("Get"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Get"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Get"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Get"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "Get")))); }) == 0) {
>     addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, 0);
>
>     do { do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = ((mono_type_to_load_membase (((cfg)), ((fsig->ret))))); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->dreg = (0); (((ins)))->sreg1 = (((addr->dreg))); (((ins)))->data.op[0].const_val = (((0))); (((ins)))->type = STACK_I4; } while (0); type_to_eval_stack_type (((cfg)), ((fsig->ret)), ((ins))); ((ins))->dreg = alloc_dreg (((cfg)), ((ins))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>
>     *sp++ = ins;
>    } else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("Address") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("Address")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("Address") + 1) - (size_t)(const void *)("Address") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "Address") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("Address") && ((size_t)(const void *)(("Address") + 1) - (size_t)(const void *)("Address") == 1) ? __builtin_strcmp (cmethod->name, "Address") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("Address"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("Address") && ((size_t)(const void *)(("Address") + 1) - (size_t)(const void *)("Address") == 1) && (__s2_len = __strlen_g (("Address")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "Address") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("Address"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Address"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("Address"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("Address"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "Address")))); }) == 0) {
>     if (!cmethod->klass->element_class->valuetype && !readonly)
>      mini_emit_check_array_type (cfg, sp [0], cmethod->klass);
>     if (!(cmethod->klass) || (cmethod->klass)->exception_type) {cfg->exception_ptr = cmethod->klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>
>     readonly = 0;
>     addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, 0);
>     *sp++ = addr;
>    } else {
>     do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 7096); } while (0);
>    }
>
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>
>    ip += 5;
>    ins_flag = 0;
>    break;
>   }
>
>   ins = mini_redirect_call (cfg, cmethod, fsig, sp, virtual ? sp [0] : ((void *)0));
>   if (ins) {
>    if (!mono_type_is_void (fsig->ret))
>     *sp++ = mono_emit_widen_call_res (cfg, ins, fsig);
>
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>
>    ip += 5;
>    ins_flag = 0;
>    break;
>   }
>
>
>
>
>
>
>   supported_tail_call = cmethod &&
>    ((((ins_flag & MONO_INST_TAILCALL) && (*ip == CEE_CALL))
>      ))
>    && !vtable_arg && !cfg->generic_sharing_context && is_supported_tail_call (cfg, method, cmethod, fsig);
>
>   if (supported_tail_call) {
>    MonoCallInst *call;
>
>
>    do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>
>
>
>
>
>
>
>    do { (call) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoCallInst)); (call)->inst.opcode = (OP_JMP); (call)->inst.dreg = -1; do { (&(call)->inst)->sreg1 = (&(call)->inst)->sreg2 = (&(call)->inst)->sreg3 = -1; } while (0); (call)->inst.cil_code = (cfg)->ip; } while (0);
>    call->tail_call = 1;
>    call->method = cmethod;
>    call->signature = mono_method_signature (cmethod);
>
>
>
>
>
>    for (i = 0; i < n; ++i) {
>
>     arg_array [i]->flags |= MONO_INST_VOLATILE;
>     do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), ((cfg)->arg_types [((i))])); (((ins)))->klass = ((cfg)->args [((i))])->klass; (((ins)))->sreg1 = (((sp [i])))->dreg; (((ins)))->dreg = ((cfg)->args [((i))])->dreg; if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type (((cfg)->arg_types [((i))])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    }
>
>
>    ins = (MonoInst*)call;
>    ins->data.op[0].p = cmethod;
>    ins->data.op[1].p = arg_array [0];
>    do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>    link_bblock (cfg, bblock, end_bblock);
>    start_new_bblock = 1;
>
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>
>    ip += 5;
>    ins_flag = 0;
>
>
>
>
>
>
>
>    do { (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; if (!(tblock)) { if ((ip) >= end || (ip) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (ip); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>    if (tblock == bblock || tblock->in_count == 0)
>     ip += 1;
>    break;
>   }
>
>
>   do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>   ins = mono_emit_method_call_full (cfg, cmethod, fsig, sp, virtual ? sp [0] : ((void *)0),
>             imt_arg, vtable_arg);
>
>   if (!mono_type_is_void (fsig->ret))
>    *sp++ = mono_emit_widen_call_res (cfg, ins, fsig);
>
>   do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>
>   ip += 5;
>   ins_flag = 0;
>   break;
>  }
>  case CEE_RET:
>   if (cfg->method != method) {
>
>
>
>
>
>
>
>    if (return_var && cfg->cbb->in_count) {
>     MonoInst *store;
>     if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>     --sp;
>
>     do { do { do { ((((store)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((store))))->data.op[0].const_val = ((((store))))->data.op[1].const_val = 0; ((((store))))->next = ((((store))))->prev = ((void *)0); ((((store))))->opcode = (OP_MOVE); ((((store))))->flags = 0; ((((store))))->type = 0; ((((store))))->dreg = -1; do { (((((store)))))->sreg1 = (((((store)))))->sreg2 = (((((store)))))->sreg3 = -1; } while (0); ((((store))))->cil_code = ((((cfg))))->ip; } while (0); (((store)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((return_var->data.op[0].const_val))]->data.op[1].vtype)); (((store)))->klass = (((cfg))->varinfo [((return_var->data.op[0].const_val))])->klass; (((store)))->sreg1 = (((*sp)))->dreg; (((store)))->dreg = (((cfg))->varinfo [((return_var->data.op[0].const_val))])->dreg; if ((((store)))->opcode == OP_VMOVE) (((store)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((return_var->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((store)); ((store))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((store)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((store)); } } while (0); } while (0);
>     cfg->ret_var_set = 1;
>    }
>   } else {
>    if (cfg->ret) {
>     MonoType *ret_type = mono_method_signature (method)->ret;
>
>     if (seq_points) {
>
>
>
>
>
>
>
>      do { do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = (OP_SEQ_POINT); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); (ins)->data.op[1].const_val = (ip - header->code); (ins)->flags = 1 ? MONO_INST_SINGLE_STEP_LOC : 0; } while (0);
>      do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>     }
>
>     do { if (!(!return_var)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 7227, "!return_var"); } while (0);
>     if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>     --sp;
>
>     if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
>      do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>     if (mini_type_to_stind (cfg, ret_type) == CEE_STOBJ) {
>      MonoInst *ret_addr;
>
>      if (!cfg->vret_addr) {
>       MonoInst *ins;
>
>       do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_MOVE); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->opcode = mono_type_to_regmove (((cfg)), ((ret_type))); ((ins))->klass = ((cfg->ret))->klass; ((ins))->sreg1 = (((*sp)))->dreg; ((ins))->dreg = ((cfg->ret))->dreg; if (((ins))->opcode == OP_VMOVE) ((ins))->klass = mono_class_from_mono_type (((ret_type))); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>      } else {
>       do { do { do { (((ret_addr))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ret_addr)))->data.op[0].const_val = (((ret_addr)))->data.op[1].const_val = 0; (((ret_addr)))->next = (((ret_addr)))->prev = ((void *)0); (((ret_addr)))->opcode = (OP_MOVE); (((ret_addr)))->flags = 0; (((ret_addr)))->type = 0; (((ret_addr)))->dreg = -1; do { ((((ret_addr))))->sreg1 = ((((ret_addr))))->sreg2 = ((((ret_addr))))->sreg3 = -1; } while (0); (((ret_addr)))->cil_code = (((cfg)))->ip; } while (0); ((ret_addr))->type = STACK_MP; ((ret_addr))->klass = (cfg)->ret->klass; ((ret_addr))->sreg1 = (cfg)->vret_addr->dreg; ((ret_addr))->dreg = alloc_dreg (((cfg)), ((ret_addr))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ret_addr)); ((ret_addr))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ret_addr)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ret_addr)); } } while (0); } while (0);
>
>       do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_STOREV_MEMBASE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->sreg1 = ((*sp)->dreg); ((ins))->dreg = (ret_addr->dreg); ((ins))->data.op[0].const_val = (0); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>       ins->klass = mono_class_from_mono_type (ret_type);
>      }
>     } else {
># 7260 "method-to-ir.c"
>      mono_arch_emit_setret (cfg, method, *sp);
>
>     }
>    }
>   }
>   if (sp != stack_start)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BR); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ip++;
>   ins->data.op[0].target_block = end_bblock;
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   link_bblock (cfg, bblock, end_bblock);
>   start_new_bblock = 1;
>   break;
>  case CEE_BR_S:
>   if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BR); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ip++;
>   target = ip + 1 + (signed char)(*ip);
>   ++ip;
>   do { (tblock) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(tblock)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (target); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   link_bblock (cfg, bblock, tblock);
>   ins->data.op[0].target_block = tblock;
>   if (sp != stack_start) {
>    handle_stack_args (cfg, stack_start, sp - stack_start);
>    sp = stack_start;
>    if (cfg->unverifiable) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   }
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   start_new_bblock = 1;
>   inline_costs += 10;
>   break;
>  case CEE_BEQ_S:
>  case CEE_BGE_S:
>  case CEE_BGT_S:
>  case CEE_BLE_S:
>  case CEE_BLT_S:
>  case CEE_BNE_UN_S:
>  case CEE_BGE_UN_S:
>  case CEE_BGT_UN_S:
>  case CEE_BLE_UN_S:
>  case CEE_BLT_UN_S:
>   if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if ((sp - stack_start) < (2)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (*ip + 13); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ip++;
>   target = ip + 1 + *(signed char*)ip;
>   ip++;
>
>   do { MonoInst *cmp; sp -= 2; do { (cmp) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (cmp)->data.op[0].const_val = (cmp)->data.op[1].const_val = 0; (cmp)->next = (cmp)->prev = ((void *)0); (cmp)->opcode = (OP_COMPARE); (cmp)->flags = 0; (cmp)->type = 0; (cmp)->dreg = -1; do { ((cmp))->sreg1 = ((cmp))->sreg2 = ((cmp))->sreg3 = -1; } while (0); (cmp)->cil_code = (cfg)->ip; } while (0); cmp->sreg1 = sp [0]->dreg; cmp->sreg2 = sp [1]->dreg; type_from_op (cmp, sp [0], sp [1]); if (!(cmp)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); type_from_op (ins, sp [0], sp [1]); ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); do { (tblock) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(tblock)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (target); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0); link_bblock (cfg, bblock, tblock); ins->data.op[1].many_blocks[0] = tblock; if ((((void *)0))) { link_bblock (cfg, bblock, (((void *)0))); ins->data.op[1].many_blocks[1] = (((void *)0)); start_new_bblock = 1; } else { do { (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; if (!(tblock)) { if ((ip) >= end || (ip) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (ip); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0); link_bblock (cfg, bblock, tblock); ins->data.op[1].many_blocks[1] = tblock; start_new_bblock = 2; } if (sp != stack_start) { handle_stack_args (cfg, stack_start, sp - stack_start); if (cfg->unverifiable) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); } do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (cmp); (cmp)->prev = (bblock)->last_ins; (bblock)->last_ins = (cmp); } else { (bblock)->code = (bblock)->last_ins = (cmp); } } while (0); do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0); } while (0);
>
>   sp = stack_start;
>   inline_costs += 10;
>   break;
>  case CEE_BR:
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BR); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ip++;
>
>   target = ip + 4 + (gint32)(((guint32) ( (((guint32) (*((const guint32 *) (ip)))) << 24)| ((((guint32) (*((const guint32 *) (ip)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip)))) >> 24)) ));
>   ip += 4;
>   do { (tblock) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(tblock)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (target); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   link_bblock (cfg, bblock, tblock);
>   ins->data.op[0].target_block = tblock;
>   if (sp != stack_start) {
>    handle_stack_args (cfg, stack_start, sp - stack_start);
>    sp = stack_start;
>    if (cfg->unverifiable) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   }
>
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>
>   start_new_bblock = 1;
>   inline_costs += 10;
>   break;
>  case CEE_BRFALSE_S:
>  case CEE_BRTRUE_S:
>  case CEE_BRFALSE:
>  case CEE_BRTRUE: {
>   MonoInst *cmp;
>   gboolean is_short = ((*ip) == CEE_BRFALSE_S) || ((*ip) == CEE_BRTRUE_S);
>   gboolean is_true = ((*ip) == CEE_BRTRUE_S) || ((*ip) == CEE_BRTRUE);
>   guint32 opsize = is_short ? 1 : 4;
>
>   if (ip + opsize > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (sp [-1]->type == STACK_VTYPE || sp [-1]->type == STACK_R8)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   ip ++;
>   target = ip + opsize + (is_short ? *(signed char*)ip : (gint32)(((guint32) ( (((guint32) (*((const guint32 *) (ip)))) << 24)| ((((guint32) (*((const guint32 *) (ip)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip)))) >> 24)) )));
>   ip += opsize;
>
>   sp--;
>
>   do { (tblock) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(tblock)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (target); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   link_bblock (cfg, bblock, tblock);
>   do { (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; if (!(tblock)) { if ((ip) >= end || (ip) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (ip); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   link_bblock (cfg, bblock, tblock);
>
>   if (sp != stack_start) {
>    handle_stack_args (cfg, stack_start, sp - stack_start);
>    if (cfg->unverifiable) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   }
>
>   do { (cmp) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (cmp)->data.op[0].const_val = (cmp)->data.op[1].const_val = 0; (cmp)->next = (cmp)->prev = ((void *)0); (cmp)->opcode = (OP_ICOMPARE_IMM); (cmp)->flags = 0; (cmp)->type = 0; (cmp)->dreg = -1; do { ((cmp))->sreg1 = ((cmp))->sreg2 = ((cmp))->sreg3 = -1; } while (0); (cmp)->cil_code = (cfg)->ip; } while (0);
>   cmp->sreg1 = sp [0]->dreg;
>   type_from_op (cmp, sp [0], ((void *)0));
>   if (!(cmp)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
># 7381 "method-to-ir.c"
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (cmp); (cmp)->prev = (bblock)->last_ins; (bblock)->last_ins = (cmp); } else { (bblock)->code = (bblock)->last_ins = (cmp); } } while (0);
>
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (is_true ? CEE_BNE_UN : CEE_BEQ); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   type_from_op (ins, sp [0], ((void *)0));
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2);
>   do { (tblock) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(tblock)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (target); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   ins->data.op[1].many_blocks[0] = tblock;
>   do { (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; if (!(tblock)) { if ((ip) >= end || (ip) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (ip); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   ins->data.op[1].many_blocks[1] = tblock;
>   start_new_bblock = 2;
>
>   sp = stack_start;
>   inline_costs += 10;
>   break;
>  }
>  case CEE_BEQ:
>  case CEE_BGE:
>  case CEE_BGT:
>  case CEE_BLE:
>  case CEE_BLT:
>  case CEE_BNE_UN:
>  case CEE_BGE_UN:
>  case CEE_BGT_UN:
>  case CEE_BLE_UN:
>  case CEE_BLT_UN:
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if ((sp - stack_start) < (2)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (*ip); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ip++;
>   target = ip + 4 + (gint32)(((guint32) ( (((guint32) (*((const guint32 *) (ip)))) << 24)| ((((guint32) (*((const guint32 *) (ip)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip)))) >> 24)) ));
>   ip += 4;
>
>   do { MonoInst *cmp; sp -= 2; do { (cmp) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (cmp)->data.op[0].const_val = (cmp)->data.op[1].const_val = 0; (cmp)->next = (cmp)->prev = ((void *)0); (cmp)->opcode = (OP_COMPARE); (cmp)->flags = 0; (cmp)->type = 0; (cmp)->dreg = -1; do { ((cmp))->sreg1 = ((cmp))->sreg2 = ((cmp))->sreg3 = -1; } while (0); (cmp)->cil_code = (cfg)->ip; } while (0); cmp->sreg1 = sp [0]->dreg; cmp->sreg2 = sp [1]->dreg; type_from_op (cmp, sp [0], sp [1]); if (!(cmp)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); type_from_op (ins, sp [0], sp [1]); ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); do { (tblock) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(tblock)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (target); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0); link_bblock (cfg, bblock, tblock); ins->data.op[1].many_blocks[0] = tblock; if ((((void *)0))) { link_bblock (cfg, bblock, (((void *)0))); ins->data.op[1].many_blocks[1] = (((void *)0)); start_new_bblock = 1; } else { do { (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; if (!(tblock)) { if ((ip) >= end || (ip) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (ip); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0); link_bblock (cfg, bblock, tblock); ins->data.op[1].many_blocks[1] = tblock; start_new_bblock = 2; } if (sp != stack_start) { handle_stack_args (cfg, stack_start, sp - stack_start); if (cfg->unverifiable) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); } do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (cmp); (cmp)->prev = (bblock)->last_ins; (bblock)->last_ins = (cmp); } else { (bblock)->code = (bblock)->last_ins = (cmp); } } while (0); do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0); } while (0);
>
>   sp = stack_start;
>   inline_costs += 10;
>   break;
>  case CEE_SWITCH: {
>   MonoInst *src1;
>   MonoBasicBlock **targets;
>   MonoBasicBlock *default_bblock;
>   MonoJumpInfoBBTable *table;
>   int offset_reg = alloc_preg (cfg);
>   int target_reg = alloc_preg (cfg);
>   int table_reg = alloc_preg (cfg);
>   int sum_reg = alloc_preg (cfg);
>   gboolean use_op_switch;
>
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   n = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   --sp;
>   src1 = sp [0];
>   if ((src1->type != STACK_I4) && (src1->type != STACK_PTR))
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   ip += 5;
>   if (ip + n * sizeof (guint32) > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   target = ip + n * sizeof (guint32);
>
>   do { (default_bblock) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(default_bblock)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((default_bblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((default_bblock))->block_num = cfg->num_bblocks++; } while (0); (default_bblock)->cil_code = (target); do { if (((default_bblock))->cil_code) { cfg->cil_offset_to_bb [((default_bblock))->cil_code - cfg->cil_start] = ((default_bblock)); } ((default_bblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   default_bblock->flags |= BB_INDIRECT_JUMP_TARGET;
>
>   targets = mono_mempool_alloc (cfg->mempool, sizeof (MonoBasicBlock*) * n);
>   for (i = 0; i < n; ++i) {
>    do { (tblock) = cfg->cil_offset_to_bb [(target + (gint32)(((guint32) ( (((guint32) (*((const guint32 *) (ip)))) << 24)| ((((guint32) (*((const guint32 *) (ip)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip)))) >> 24)) ))) - cfg->cil_start]; if (!(tblock)) { if ((target + (gint32)(((guint32) ( (((guint32) (*((const guint32 *) (ip)))) << 24)| ((((guint32) (*((const guint32 *) (ip)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip)))) >> 24)) ))) >= end || (target + (gint32)(((guint32) ( (((guint32) (*((const guint32 *) (ip)))) << 24)| ((((guint32) (*((const guint32 *) (ip)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip)))) >> 24)) ))) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (target + (gint32)(((guint32) ( (((guint32) (*((const guint32 *) (ip)))) << 24)| ((((guint32) (*((const guint32 *) (ip)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip)))) >> 24)) ))); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>    targets [i] = tblock;
>    targets [i]->flags |= BB_INDIRECT_JUMP_TARGET;
>    ip += 4;
>   }
>
>   if (sp != stack_start) {
>
>
>
>
>    link_bblock (cfg, bblock, default_bblock);
>    for (i = 0; i < n; ++i)
>     link_bblock (cfg, bblock, targets [i]);
>
>    handle_stack_args (cfg, stack_start, sp - stack_start);
>    sp = stack_start;
>    if (cfg->unverifiable) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   }
>
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_ICOMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = src1->dreg; inst->data.op[1].const_val = (mgreg_t)(n); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_IBGE_UN)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_IBGE_UN) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (default_bblock); mono_link_bblock ((cfg), (cfg)->cbb, (default_bblock)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (default_bblock); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (default_bblock)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>   bblock = cfg->cbb;
>
>   for (i = 0; i < n; ++i)
>    link_bblock (cfg, bblock, targets [i]);
>
>   table = mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfoBBTable));
>   table->table = targets;
>   table->table_size = n;
>
>   use_op_switch = 0;
>
>
>
>
>
>
>
>   if ((0))
>    use_op_switch = 1;
>
>   cfg->cbb->has_jump_table = 1;
>
>   if (use_op_switch) {
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_SWITCH); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->sreg1 = src1->dreg;
>    ins->data.op[0].p = table;
>    ins->data.op[1].many_blocks = targets;
>    ins->klass = ((gpointer)(gulong) (n));
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>   } else {
>    if (sizeof (gpointer) == 8)
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_SHL_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = offset_reg; inst->sreg1 = src1->dreg; inst->data.op[1].const_val = (mgreg_t)(3); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>    else
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_SHL_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = offset_reg; inst->sreg1 = src1->dreg; inst->data.op[1].const_val = (mgreg_t)(2); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>
>
>    do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_ZEXT_I4)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((offset_reg)); (((inst)))->sreg1 = ((offset_reg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0);
>
>
>    if (cfg->compile_aot) {
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = table_reg; inst->data.op[0].p = table; inst->data.op[1].const_val = MONO_PATCH_INFO_SWITCH; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>    } else {
>     do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_JUMP_TABLE); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>     ins->data.op[1].const_val = MONO_PATCH_INFO_SWITCH;
>     ins->data.op[0].p = table;
>     ins->dreg = table_reg;
>     do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>    }
>
>
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LADD)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = sum_reg; inst->sreg1 = table_reg; inst->sreg2 = offset_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (target_reg); inst->sreg1 = (sum_reg); inst->data.op[0].const_val = (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>    do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_BR_REG)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((target_reg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0);
>   }
>   start_new_bblock = 1;
>   inline_costs += (10 * 2);
>   break;
>  }
>  case CEE_LDIND_I1:
>  case CEE_LDIND_U1:
>  case CEE_LDIND_I2:
>  case CEE_LDIND_U2:
>  case CEE_LDIND_I4:
>  case CEE_LDIND_U4:
>  case CEE_LDIND_I8:
>  case CEE_LDIND_I:
>  case CEE_LDIND_R4:
>  case CEE_LDIND_R8:
>  case CEE_LDIND_REF:
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>
>   switch (*ip) {
>   case CEE_LDIND_R4:
>   case CEE_LDIND_R8:
>    dreg = alloc_freg (cfg);
>    break;
>   case CEE_LDIND_I8:
>    dreg = alloc_lreg (cfg);
>    break;
>   case CEE_LDIND_REF:
>    dreg = alloc_ireg_ref (cfg);
>    break;
>   default:
>    dreg = alloc_preg (cfg);
>   }
>
>   do { do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((ldind_to_load_membase (*ip))); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); (ins)->dreg = (dreg); (ins)->sreg1 = (sp [0]->dreg); (ins)->data.op[0].const_val = (0); (ins)->type = STACK_I4; } while (0);
>   ins->type = ldind_type [*ip - CEE_LDIND_I1];
>   ins->flags |= ins_flag;
>   ins_flag = 0;
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   *sp++ = ins;
>   ++ip;
>   break;
>  case CEE_STIND_REF:
>  case CEE_STIND_I1:
>  case CEE_STIND_I2:
>  case CEE_STIND_I4:
>  case CEE_STIND_I8:
>  case CEE_STIND_R4:
>  case CEE_STIND_R8:
>  case CEE_STIND_I:
>   if ((sp - stack_start) < (2)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   sp -= 2;
>
>   do { do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((stind_to_store_membase (*ip))); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); (ins)->sreg1 = sp [1]->dreg; (ins)->dreg = sp [0]->dreg; (ins)->data.op[0].const_val = 0; } while (0);
>   ins->flags |= ins_flag;
>   ins_flag = 0;
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>
>   if (cfg->gen_write_barriers && *ip == CEE_STIND_REF && method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER && !((sp [1]->opcode == OP_I8CONST) && (sp [1]->data.op[0].p == 0)))
>    emit_write_barrier (cfg, sp [0], sp [1], -1);
>
>   inline_costs += 1;
>   ++ip;
>   break;
>
>  case CEE_MUL:
>   if ((sp - stack_start) < (2)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = ((*ip)); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   sp -= 2;
>   ins->sreg1 = sp [0]->dreg;
>   ins->sreg2 = sp [1]->dreg;
>   type_from_op (ins, sp [0], sp [1]);
>   if (!(ins)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   ins->dreg = alloc_dreg ((cfg), (ins)->type);
>
>
>   if ((sp [1]->opcode == OP_ICONST) && mono_arch_is_inst_imm (sp [1]->data.op[0].const_val)) {
>    int imm_opcode = mono_op_to_op_imm (ins->opcode);
>    if (imm_opcode != -1) {
>     ins->opcode = imm_opcode;
>     ins->data.op[1].p = (gpointer)(gssize)(sp [1]->data.op[0].const_val);
>     ins->sreg2 = -1;
>
>     sp [1]->opcode = OP_NOP;
>    }
>   }
>
>   do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0);
>
>   *sp++ = mono_decompose_opcode (cfg, ins);
>   ip++;
>   break;
>  case CEE_ADD:
>  case CEE_SUB:
>  case CEE_DIV:
>  case CEE_DIV_UN:
>  case CEE_REM:
>  case CEE_REM_UN:
>  case CEE_AND:
>  case CEE_OR:
>  case CEE_XOR:
>  case CEE_SHL:
>  case CEE_SHR:
>  case CEE_SHR_UN:
>   if ((sp - stack_start) < (2)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = ((*ip)); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   sp -= 2;
>   ins->sreg1 = sp [0]->dreg;
>   ins->sreg2 = sp [1]->dreg;
>   type_from_op (ins, sp [0], sp [1]);
>   if (!(ins)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { if ((sp [0])->type == STACK_PTR && (sp [1])->type == STACK_I4) { MonoInst *widen; int dr = alloc_preg (cfg); do { do { do { (((widen))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((widen)))->data.op[0].const_val = (((widen)))->data.op[1].const_val = 0; (((widen)))->next = (((widen)))->prev = ((void *)0); (((widen)))->opcode = (((OP_SEXT_I4))); (((widen)))->flags = 0; (((widen)))->type = 0; (((widen)))->dreg = -1; do { ((((widen))))->sreg1 = ((((widen))))->sreg2 = ((((widen))))->sreg3 = -1; } while (0); (((widen)))->cil_code = (((cfg)))->ip; } while (0); ((widen))->dreg = (dr); ((widen))->sreg1 = ((sp [1])->dreg); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((widen)); ((widen))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((widen)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((widen)); } } while (0); } while (0); (ins)->sreg2 = widen->dreg; } } while (0);
>   ins->dreg = alloc_dreg ((cfg), (ins)->type);
>
>
>
>
>   if (((sp [1]->opcode == OP_ICONST) || (sp [1]->opcode == OP_I8CONST)) && mono_arch_is_inst_imm (sp [1]->opcode == OP_ICONST ? sp [1]->data.op[0].const_val : sp [1]->data.i8const)) {
>    int imm_opcode;
>
>    imm_opcode = mono_op_to_op_imm_noemul (ins->opcode);
>    if (imm_opcode != -1) {
>     ins->opcode = imm_opcode;
>     if (sp [1]->opcode == OP_I8CONST) {
>
>      ins->data.op[1].const_val = sp [1]->data.i8const;
>
>
>
>
>     }
>     else
>      ins->data.op[1].const_val = (gssize)(sp [1]->data.op[0].const_val);
>     ins->sreg2 = -1;
>
>
>     if (sp [1]->next == ((void *)0))
>      sp [1]->opcode = OP_NOP;
>    }
>   }
>   do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0);
>
>   *sp++ = mono_decompose_opcode (cfg, ins);
>   ip++;
>   break;
>  case CEE_NEG:
>  case CEE_NOT:
>  case CEE_CONV_I1:
>  case CEE_CONV_I2:
>  case CEE_CONV_I4:
>  case CEE_CONV_R4:
>  case CEE_CONV_R8:
>  case CEE_CONV_U4:
>  case CEE_CONV_I8:
>  case CEE_CONV_U8:
>  case CEE_CONV_OVF_I8:
>  case CEE_CONV_OVF_U8:
>  case CEE_CONV_R_UN:
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>
>   if ((((*ip) == CEE_CONV_I8) || ((*ip) == CEE_CONV_U8)) && (sp [-1]->opcode == OP_ICONST)) {
>    int data = sp [-1]->data.op[0].const_val;
>    sp [-1]->opcode = OP_I8CONST;
>    sp [-1]->type = STACK_I8;
>
>    if ((*ip) == CEE_CONV_U8)
>     sp [-1]->data.op[0].const_val = (guint32)data;
>    else
>     sp [-1]->data.op[0].const_val = data;
>
>
>
>
>
>
>
>    sp [-1]->dreg = alloc_dreg (cfg, STACK_I8);
>   }
>   else {
>    do { do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = ((*ip)); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0); sp--; ins->sreg1 = sp [0]->dreg; type_from_op (ins, sp [0], ((void *)0)); if (!(ins)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); (ins)->dreg = alloc_dreg ((cfg), (ins)->type); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); *sp++ = mono_decompose_opcode (cfg, ins); } while (0);
>   }
>   ip++;
>   break;
>  case CEE_CONV_OVF_I4:
>  case CEE_CONV_OVF_I1:
>  case CEE_CONV_OVF_I2:
>  case CEE_CONV_OVF_I:
>  case CEE_CONV_OVF_U:
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   if (sp [-1]->type == STACK_R8) {
>    do { do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = ((CEE_CONV_OVF_I8)); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0); sp--; ins->sreg1 = sp [0]->dreg; type_from_op (ins, sp [0], ((void *)0)); if (!(ins)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); (ins)->dreg = alloc_dreg ((cfg), (ins)->type); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); *sp++ = mono_decompose_opcode (cfg, ins); } while (0);
>    do { do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = ((*ip)); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0); sp--; ins->sreg1 = sp [0]->dreg; type_from_op (ins, sp [0], ((void *)0)); if (!(ins)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); (ins)->dreg = alloc_dreg ((cfg), (ins)->type); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); *sp++ = mono_decompose_opcode (cfg, ins); } while (0);
>   } else {
>    do { do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = ((*ip)); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0); sp--; ins->sreg1 = sp [0]->dreg; type_from_op (ins, sp [0], ((void *)0)); if (!(ins)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); (ins)->dreg = alloc_dreg ((cfg), (ins)->type); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); *sp++ = mono_decompose_opcode (cfg, ins); } while (0);
>   }
>   ip++;
>   break;
>  case CEE_CONV_OVF_U1:
>  case CEE_CONV_OVF_U2:
>  case CEE_CONV_OVF_U4:
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   if (sp [-1]->type == STACK_R8) {
>    do { do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = ((CEE_CONV_OVF_U8)); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0); sp--; ins->sreg1 = sp [0]->dreg; type_from_op (ins, sp [0], ((void *)0)); if (!(ins)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); (ins)->dreg = alloc_dreg ((cfg), (ins)->type); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); *sp++ = mono_decompose_opcode (cfg, ins); } while (0);
>    do { do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = ((*ip)); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0); sp--; ins->sreg1 = sp [0]->dreg; type_from_op (ins, sp [0], ((void *)0)); if (!(ins)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); (ins)->dreg = alloc_dreg ((cfg), (ins)->type); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); *sp++ = mono_decompose_opcode (cfg, ins); } while (0);
>   } else {
>    do { do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = ((*ip)); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0); sp--; ins->sreg1 = sp [0]->dreg; type_from_op (ins, sp [0], ((void *)0)); if (!(ins)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); (ins)->dreg = alloc_dreg ((cfg), (ins)->type); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); *sp++ = mono_decompose_opcode (cfg, ins); } while (0);
>   }
>   ip++;
>   break;
>  case CEE_CONV_OVF_I1_UN:
>  case CEE_CONV_OVF_I2_UN:
>  case CEE_CONV_OVF_I4_UN:
>  case CEE_CONV_OVF_I8_UN:
>  case CEE_CONV_OVF_U1_UN:
>  case CEE_CONV_OVF_U2_UN:
>  case CEE_CONV_OVF_U4_UN:
>  case CEE_CONV_OVF_U8_UN:
>  case CEE_CONV_OVF_I_UN:
>  case CEE_CONV_OVF_U_UN:
>  case CEE_CONV_U2:
>  case CEE_CONV_U1:
>  case CEE_CONV_I:
>  case CEE_CONV_U:
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = ((*ip)); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0); sp--; ins->sreg1 = sp [0]->dreg; type_from_op (ins, sp [0], ((void *)0)); if (!(ins)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); (ins)->dreg = alloc_dreg ((cfg), (ins)->type); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); *sp++ = mono_decompose_opcode (cfg, ins); } while (0);
>   do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>   ip++;
>   break;
>  case CEE_ADD_OVF:
>  case CEE_ADD_OVF_UN:
>  case CEE_MUL_OVF:
>  case CEE_MUL_OVF_UN:
>  case CEE_SUB_OVF:
>  case CEE_SUB_OVF_UN:
>   if ((sp - stack_start) < (2)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = ((*ip)); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0); sp -= 2; ins->sreg1 = sp [0]->dreg; ins->sreg2 = sp [1]->dreg; type_from_op (ins, sp [0], sp [1]); if (!(ins)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { if ((sp [0])->type == STACK_PTR && (sp [1])->type == STACK_I4) { MonoInst *widen; int dr = alloc_preg (cfg); do { do { do { (((widen))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((widen)))->data.op[0].const_val = (((widen)))->data.op[1].const_val = 0; (((widen)))->next = (((widen)))->prev = ((void *)0); (((widen)))->opcode = (((OP_SEXT_I4))); (((widen)))->flags = 0; (((widen)))->type = 0; (((widen)))->dreg = -1; do { ((((widen))))->sreg1 = ((((widen))))->sreg2 = ((((widen))))->sreg3 = -1; } while (0); (((widen)))->cil_code = (((cfg)))->ip; } while (0); ((widen))->dreg = (dr); ((widen))->sreg1 = ((sp [1])->dreg); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((widen)); ((widen))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((widen)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((widen)); } } while (0); } while (0); (ins)->sreg2 = widen->dreg; } } while (0); ins->dreg = alloc_dreg ((cfg), (ins)->type); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); *sp++ = mono_decompose_opcode ((cfg), (ins)); } while (0);
>   ip++;
>   break;
>  case CEE_CPOBJ:
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if ((sp - stack_start) < (2)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   klass = mini_get_class (method, token, generic_context);
>   if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>   sp -= 2;
>   if (generic_class_is_reference_type (cfg, klass)) {
>    MonoInst *store, *load;
>    int dreg = alloc_ireg_ref (cfg);
>
>    do { do { ((load)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((load))->data.op[0].const_val = ((load))->data.op[1].const_val = 0; ((load))->next = ((load))->prev = ((void *)0); ((load))->opcode = ((OP_LOAD_MEMBASE)); ((load))->flags = 0; ((load))->type = 0; ((load))->dreg = -1; do { (((load)))->sreg1 = (((load)))->sreg2 = (((load)))->sreg3 = -1; } while (0); ((load))->cil_code = ((cfg))->ip; } while (0); (load)->dreg = (dreg); (load)->sreg1 = (sp [1]->dreg); (load)->data.op[0].const_val = (0); (load)->type = STACK_I4; } while (0);
>    load->flags |= ins_flag;
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (load); (load)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (load); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (load); } } while (0);
>
>    do { do { ((store)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((store))->data.op[0].const_val = ((store))->data.op[1].const_val = 0; ((store))->next = ((store))->prev = ((void *)0); ((store))->opcode = ((OP_STORE_MEMBASE_REG)); ((store))->flags = 0; ((store))->type = 0; ((store))->dreg = -1; do { (((store)))->sreg1 = (((store)))->sreg2 = (((store)))->sreg3 = -1; } while (0); ((store))->cil_code = ((cfg))->ip; } while (0); (store)->sreg1 = dreg; (store)->dreg = sp [0]->dreg; (store)->data.op[0].const_val = 0; } while (0);
>    store->flags |= ins_flag;
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (store); (store)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (store); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (store); } } while (0);
>
>    if (cfg->gen_write_barriers && cfg->method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER)
>     emit_write_barrier (cfg, sp [0], sp [1], -1);
>   } else {
>    mini_emit_stobj (cfg, sp [0], sp [1], klass, 0);
>   }
>   ins_flag = 0;
>   ip += 5;
>   break;
>  case CEE_LDOBJ: {
>   int loc_index = -1;
>   int stloc_len = 0;
>
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   klass = mini_get_class (method, token, generic_context);
>   if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>
>
>   switch (ip [5]) {
>   case CEE_STLOC_S:
>    loc_index = ip [6];
>    stloc_len = 2;
>    break;
>   case CEE_STLOC_0:
>   case CEE_STLOC_1:
>   case CEE_STLOC_2:
>   case CEE_STLOC_3:
>    loc_index = ip [5] - CEE_STLOC_0;
>    stloc_len = 1;
>    break;
>   default:
>    break;
>   }
>
>   if ((loc_index != -1) && ip_in_bb (cfg, bblock, ip + 5)) {
>    if ((unsigned)(loc_index) >= (unsigned)header->num_locals) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>    do { do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = ((mono_type_to_load_membase (((cfg)), ((&klass->byval_arg))))); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->dreg = (0); (((ins)))->sreg1 = (((sp [0]->dreg))); (((ins)))->data.op[0].const_val = (((0))); (((ins)))->type = STACK_I4; } while (0); type_to_eval_stack_type (((cfg)), ((&klass->byval_arg)), ((ins))); ((ins))->dreg = alloc_dreg (((cfg)), ((ins))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    ins->dreg = cfg->locals [loc_index]->dreg;
>    ip += 5;
>    ip += stloc_len;
>    break;
>   }
>
>
>
>   if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, bblock, ip + 5) && (((guint32) ( (((guint32) (*((const guint32 *) (ip + 6)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 6)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 6)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 6)))) >> 24)) )) == token) && !generic_class_is_reference_type (cfg, klass)) {
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>    sp --;
>
>    mini_emit_stobj (cfg, sp [0], sp [1], klass, 0);
>
>    ip += 5 + 5;
>    ins_flag = 0;
>    break;
>   }
>
>   do { do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = ((mono_type_to_load_membase (((cfg)), ((&klass->byval_arg))))); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->dreg = (0); (((ins)))->sreg1 = (((sp [0]->dreg))); (((ins)))->data.op[0].const_val = (((0))); (((ins)))->type = STACK_I4; } while (0); type_to_eval_stack_type (((cfg)), ((&klass->byval_arg)), ((ins))); ((ins))->dreg = alloc_dreg (((cfg)), ((ins))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   *sp++ = ins;
>
>   ip += 5;
>   ins_flag = 0;
>   inline_costs += 1;
>   break;
>  }
>  case CEE_LDSTR:
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   n = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>
>   if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD) {
>    do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((mono_method_get_wrapper_data (method, n))); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    ins->type = STACK_OBJ;
>    *sp = ins;
>   }
>   else if (method->wrapper_type != MONO_WRAPPER_NONE) {
>    MonoInst *iargs [1];
>
>    do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_I8CONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].p = ((mono_method_get_wrapper_data (method, n))); ((iargs [0]))->type = STACK_PTR; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>    *sp = mono_emit_jit_icall (cfg, mono_string_new_wrapper, iargs);
>   } else {
>    if (cfg->opt & MONO_OPT_SHARED) {
>     MonoInst *iargs [3];
>
>     if (cfg->compile_aot) {
>      cfg->ldstr_list = monoeg_g_list_prepend (cfg->ldstr_list, ((gpointer)(glong) (n)));
>     }
>     do { do { if (((cfg)->opt & MONO_OPT_SHARED) || (cfg)->compile_aot) { MonoInst* __domain_var = mono_get_domainvar ((cfg)); do { do { ((((iargs [0])))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((iargs [0]))))->data.op[0].const_val = ((((iargs [0]))))->data.op[1].const_val = 0; ((((iargs [0]))))->next = ((((iargs [0]))))->prev = ((void *)0); ((((iargs [0]))))->opcode = (OP_MOVE); ((((iargs [0]))))->flags = 0; ((((iargs [0]))))->type = 0; ((((iargs [0]))))->dreg = -1; do { (((((iargs [0])))))->sreg1 = (((((iargs [0])))))->sreg2 = (((((iargs [0])))))->sreg3 = -1; } while (0); ((((iargs [0]))))->cil_code = ((((cfg))))->ip; } while (0); (((iargs [0])))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype), (((iargs [0])))); (((iargs [0])))->klass = ((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->klass; (((iargs [0])))->sreg1 = ((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->dreg; (((iargs [0])))->dreg = alloc_dreg ((((cfg))), (((iargs [0])))->type); if ((((iargs [0])))->opcode == OP_VMOVE) (((iargs [0])))->klass = mono_class_from_mono_type ((((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); } while (0); } else { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_I8CONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].p = (((cfg))->domain); ((iargs [0]))->type = STACK_PTR; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>     do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].p = ((image)); ((iargs [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_IMAGE); ((iargs [1]))->type = STACK_PTR; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>     do { do { do { (((iargs [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [2])))->data.op[0].const_val = (((iargs [2])))->data.op[1].const_val = 0; (((iargs [2])))->next = (((iargs [2])))->prev = ((void *)0); (((iargs [2])))->opcode = (OP_ICONST); (((iargs [2])))->flags = 0; (((iargs [2])))->type = 0; (((iargs [2])))->dreg = -1; do { ((((iargs [2]))))->sreg1 = ((((iargs [2]))))->sreg2 = ((((iargs [2]))))->sreg3 = -1; } while (0); (((iargs [2])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [2]))->data.op[0].const_val = ((((n & 0xffffff)))); ((iargs [2]))->type = STACK_I4; ((iargs [2]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [2])); ((iargs [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [2])); } } while (0); } while (0);
>     *sp = mono_emit_jit_icall (cfg, mono_ldstr, iargs);
>     mono_ldstr (cfg->domain, image, ((n & 0xffffff)));
>    } else {
>     if (bblock->out_of_line) {
>      MonoInst *iargs [2];
>
>      if (image == mono_defaults.corlib) {
>
>
>
>
>       do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_ICONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].const_val = ((((n & 0xffffff)))); ((iargs [0]))->type = STACK_I4; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>       *sp = mono_emit_jit_icall (cfg, mono_helper_ldstr_mscorlib, iargs);
>      } else {
>
>       do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].p = ((image)); ((iargs [0]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_IMAGE); ((iargs [0]))->type = STACK_PTR; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>       do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = (OP_ICONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].const_val = ((((n & 0xffffff)))); ((iargs [1]))->type = STACK_I4; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>       *sp = mono_emit_jit_icall (cfg, mono_helper_ldstr, iargs);
>      }
>     }
>     else
>     if (cfg->compile_aot) {
>      do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_AOTCONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = mono_jump_info_token_new2 (((cfg))->mempool, ((image)), ((n)), (((void *)0))); ((ins))->data.op[1].p = (gpointer)(MONO_PATCH_INFO_LDSTR); ((ins))->type = (STACK_OBJ); ((ins))->klass = (mono_defaults.string_class); ((ins))->dreg = alloc_dreg (((cfg)), (STACK_OBJ)); } while (0);
>      *sp = ins;
>      do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>     }
>     else {
>      do { do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = (OP_I8CONST); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); (ins)->data.op[0].p = (((void *)0)); (ins)->type = STACK_PTR; (ins)->dreg = alloc_dreg ((cfg), STACK_PTR); } while (0);
>      ins->type = STACK_OBJ;
>      ins->data.op[0].p = mono_ldstr (cfg->domain, image, ((n & 0xffffff)));
>      if (!ins->data.op[0].p)
>       do { mono_cfg_set_exception (cfg, MONO_EXCEPTION_OUT_OF_MEMORY); goto exception_exit; } while (0);
>
>      *sp = ins;
>      do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>     }
>    }
>   }
>
>   sp++;
>   ip += 5;
>   break;
>  case CEE_NEWOBJ: {
>   MonoInst *iargs [2];
>   MonoMethodSignature *fsig;
>   MonoInst this_ins;
>   MonoInst *alloc;
>   MonoInst *vtable_arg = ((void *)0);
>
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   cmethod = mini_get_method (cfg, method, token, ((void *)0), generic_context);
>   if (!cmethod || mono_loader_get_last_error ())
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>   fsig = mono_method_get_signature (cmethod, image, token);
>   if (!fsig)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>
>   mono_save_token_info (cfg, image, token, cmethod);
>
>   if (!mono_class_init (cmethod->klass))
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>
>   if (cfg->generic_sharing_context)
>    context_used = mono_method_check_context_used (cmethod);
>
>   if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS) {
>    if (check_linkdemand (cfg, method, cmethod))
>     do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>   } else if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) {
>    ensure_method_is_allowed_to_call_method (cfg, method, cmethod, bblock, ip);
>    }
>
>   if (cfg->generic_sharing_context && cmethod && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable_impl (cmethod, 1) && mono_class_needs_cctor_run (cmethod->klass, method)) {
>    emit_generic_class_init (cfg, cmethod->klass);
>    if (!(cmethod->klass) || (cmethod->klass)->exception_type) {cfg->exception_ptr = cmethod->klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>   }
>
>   if (cmethod->klass->valuetype && mono_class_generic_sharing_enabled (cmethod->klass) &&
>     mono_method_is_generic_sharable_impl (cmethod, 1)) {
>    if (cmethod->is_inflated && mono_method_get_context (cmethod)->method_inst) {
>     mono_class_vtable (cfg->domain, cmethod->klass);
>     if (!(cmethod->klass) || (cmethod->klass)->exception_type) {cfg->exception_ptr = cmethod->klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>
>     vtable_arg = emit_get_rgctx_method (cfg, context_used,
>              cmethod, MONO_RGCTX_INFO_METHOD_RGCTX);
>    } else {
>     if (context_used) {
>      vtable_arg = emit_get_rgctx_klass (cfg, context_used,
>       cmethod->klass, MONO_RGCTX_INFO_VTABLE);
>     } else {
>      MonoVTable *vtable = mono_class_vtable (cfg->domain, cmethod->klass);
>
>      if (!(cmethod->klass) || (cmethod->klass)->exception_type) {cfg->exception_ptr = cmethod->klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>      do { do { do { (((vtable_arg))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((vtable_arg)))->data.op[0].const_val = (((vtable_arg)))->data.op[1].const_val = 0; (((vtable_arg)))->next = (((vtable_arg)))->prev = ((void *)0); (((vtable_arg)))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((vtable_arg)))->flags = 0; (((vtable_arg)))->type = 0; (((vtable_arg)))->dreg = -1; do { ((((vtable_arg))))->sreg1 = ((((vtable_arg))))->sreg2 = ((((vtable_arg))))->sreg3 = -1; } while (0); (((vtable_arg)))->cil_code = (((cfg)))->ip; } while (0); ((vtable_arg))->data.op[0].p = (cfg->compile_aot ? (gpointer)((vtable)->klass) : (vtable)); ((vtable_arg))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_VTABLE); ((vtable_arg))->type = STACK_PTR; ((vtable_arg))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((vtable_arg)); ((vtable_arg))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((vtable_arg)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((vtable_arg)); } } while (0); } while (0);
>     }
>    }
>   }
>
>   n = fsig->param_count;
>   if ((sp - stack_start) < (n)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>
>
>
>
>   if (bblock->out_of_line && cmethod->klass->image == mono_defaults.corlib &&
>    is_exception_class (cmethod->klass) && n <= 2 &&
>    ((n < 1) || (!fsig->params [0]->byref && fsig->params [0]->type == MONO_TYPE_STRING)) &&
>    ((n < 2) || (!fsig->params [1]->byref && fsig->params [1]->type == MONO_TYPE_STRING))) {
>    MonoInst *iargs [3];
>
>    do { if (!(!vtable_arg)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 7991, "!vtable_arg"); } while (0);
>
>    sp -= n;
>
>    do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_ICONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].const_val = ((cmethod->klass->type_token)); ((iargs [0]))->type = STACK_I4; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>    switch (n) {
>    case 0:
>     *sp ++ = mono_emit_jit_icall (cfg, mono_create_corlib_exception_0, iargs);
>     break;
>    case 1:
>     iargs [1] = sp [0];
>     *sp ++ = mono_emit_jit_icall (cfg, mono_create_corlib_exception_1, iargs);
>     break;
>    case 2:
>     iargs [1] = sp [0];
>     iargs [2] = sp [1];
>     *sp ++ = mono_emit_jit_icall (cfg, mono_create_corlib_exception_2, iargs);
>     break;
>    default:
>     do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 8010); } while (0);
>    }
>
>    ip += 5;
>    inline_costs += 5;
>    break;
>   }
>
>
>   while (n--) {
>    --sp;
>    sp [1] = sp [0];
>   }
>
>
>   this_ins.type = STACK_OBJ;
>   sp [0] = &this_ins;
>   if (check_call_signature (cfg, fsig, sp))
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   iargs [0] = ((void *)0);
>
>   if (mini_class_is_system_array (cmethod->klass)) {
>    do { if (!(!vtable_arg)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8033, "!vtable_arg"); } while (0);
>
>    *sp = emit_get_rgctx_method (cfg, context_used,
>            cmethod, MONO_RGCTX_INFO_METHOD);
>
>
>    if (fsig->param_count == 1)
>     alloc = mono_emit_jit_icall (cfg, mono_array_new_1, sp);
>    else if (fsig->param_count == 2)
>     alloc = mono_emit_jit_icall (cfg, mono_array_new_2, sp);
>    else if (fsig->param_count == 3)
>     alloc = mono_emit_jit_icall (cfg, mono_array_new_3, sp);
>    else
>     alloc = handle_array_new (cfg, fsig->param_count, sp, ip);
>   } else if (cmethod->string_ctor) {
>    do { if (!(!context_used)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8048, "!context_used"); } while (0);
>    do { if (!(!vtable_arg)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8049, "!vtable_arg"); } while (0);
>
>    do { do { do { (((*sp))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((*sp)))->data.op[0].const_val = (((*sp)))->data.op[1].const_val = 0; (((*sp)))->next = (((*sp)))->prev = ((void *)0); (((*sp)))->opcode = (OP_I8CONST); (((*sp)))->flags = 0; (((*sp)))->type = 0; (((*sp)))->dreg = -1; do { ((((*sp))))->sreg1 = ((((*sp))))->sreg2 = ((((*sp))))->sreg3 = -1; } while (0); (((*sp)))->cil_code = (((cfg)))->ip; } while (0); ((*sp))->data.op[0].p = ((((void *)0))); ((*sp))->type = STACK_PTR; ((*sp))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((*sp)); ((*sp))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((*sp)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((*sp)); } } while (0); } while (0);
>
>    alloc = mono_emit_method_call_full (cfg, cmethod, fsig, sp, ((void *)0), ((void *)0), ((void *)0));
>   } else {
>    MonoInst* callvirt_this_arg = ((void *)0);
>
>    if (cmethod->klass->valuetype) {
>     iargs [0] = mono_compile_create_var (cfg, &cmethod->klass->byval_arg, OP_LOCAL);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((0) ? OP_XZERO : OP_VZERO); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = iargs [0]->dreg; (inst)->type = STACK_VTYPE; (inst)->klass = (cmethod->klass); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>     do { do { do { ((((*sp)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((*sp))))->data.op[0].const_val = ((((*sp))))->data.op[1].const_val = 0; ((((*sp))))->next = ((((*sp))))->prev = ((void *)0); ((((*sp))))->opcode = (OP_LDADDR); ((((*sp))))->flags = 0; ((((*sp))))->type = 0; ((((*sp))))->dreg = -1; do { (((((*sp)))))->sreg1 = (((((*sp)))))->sreg2 = (((((*sp)))))->sreg3 = -1; } while (0); ((((*sp))))->cil_code = ((((cfg))))->ip; } while (0); (((*sp)))->data.op[0].p = ((cfg)->varinfo [((iargs [0]->data.op[0].const_val))]); ((cfg)->varinfo [((iargs [0]->data.op[0].const_val))])->flags |= MONO_INST_INDIRECT; (((*sp)))->type = STACK_MP; (((*sp)))->klass = ((cfg)->varinfo [((iargs [0]->data.op[0].const_val))])->klass; (((*sp)))->dreg = alloc_dreg ((((cfg))), STACK_MP); if (8 == 4 && ((((cfg)->varinfo [((iargs [0]->data.op[0].const_val))])->type) == STACK_I8)) { MonoInst *var1 = ((((cfg)->varinfo [((iargs [0]->data.op[0].const_val))])->dreg + 1) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((iargs [0]->data.op[0].const_val))])->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((cfg)->varinfo [((iargs [0]->data.op[0].const_val))])->dreg + 2) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((iargs [0]->data.op[0].const_val))])->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8060, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8060, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((*sp)); ((*sp))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((*sp)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((*sp)); } } while (0); } while (0);
>
>     alloc = ((void *)0);
>
>
>
>
>
>
>    } else if (context_used) {
>     alloc = handle_alloc (cfg, cmethod->klass, 0, context_used);
>     *sp = alloc;
>    } else {
>     MonoVTable *vtable = mono_class_vtable (cfg->domain, cmethod->klass);
>
>     if (!(cmethod->klass) || (cmethod->klass)->exception_type) {cfg->exception_ptr = cmethod->klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>
>
>
>
>
>
>     if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(monoeg_g_slist_find (class_inits, vtable))) {
>      mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, ((void *)0));
>      if (cfg->verbose_level > 2)
>       printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
>      class_inits = monoeg_g_slist_prepend (class_inits, vtable);
>     }
>
>     alloc = handle_alloc (cfg, cmethod->klass, 0, 0);
>     *sp = alloc;
>    }
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>
>    if (alloc)
>     do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_NOT_NULL)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((alloc->dreg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0);
>
>
>
>    if (cmethod->klass->marshalbyref)
>     callvirt_this_arg = sp [0];
>
>
>    if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp))) {
>     if (!mono_type_is_void (fsig->ret)) {
>      type_to_eval_stack_type ((cfg), fsig->ret, ins);
>      *sp = ins;
>      sp++;
>     }
>
>     do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>    } else if ((cfg->opt & MONO_OPT_INLINE) && cmethod && !context_used && !vtable_arg &&
>        !disable_inline && mono_method_check_inlining (cfg, cmethod) &&
>        !mono_class_is_subclass_of (cmethod->klass, mono_defaults.exception_class, 0) &&
>        !monoeg_g_list_find (dont_inline, cmethod)) {
>     int costs;
>
>     if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, 0))) {
>      cfg->real_offset += 5;
>      bblock = cfg->cbb;
>
>      inline_costs += costs - 5;
>     } else {
>      do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>      mono_emit_method_call_full (cfg, cmethod, fsig, sp, callvirt_this_arg, ((void *)0), ((void *)0));
>     }
>    } else if (context_used &&
>      (!mono_method_is_generic_sharable_impl (cmethod, 1) ||
>       !mono_class_generic_sharing_enabled (cmethod->klass))) {
>     MonoInst *cmethod_addr;
>
>     cmethod_addr = emit_get_rgctx_method (cfg, context_used,
>      cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
>
>     mono_emit_calli (cfg, fsig, sp, cmethod_addr, vtable_arg);
>    } else {
>     do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>     ins = mono_emit_method_call_full (cfg, cmethod, fsig, sp,
>               callvirt_this_arg, ((void *)0), vtable_arg);
>    }
>   }
>
>   if (alloc == ((void *)0)) {
>
>    do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((iargs [0]->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((iargs [0]->data.op[0].const_val))]->data.op[1].vtype), (((ins)))); (((ins)))->klass = ((cfg))->varinfo [((iargs [0]->data.op[0].const_val))]->klass; (((ins)))->sreg1 = ((cfg))->varinfo [((iargs [0]->data.op[0].const_val))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((iargs [0]->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    type_to_eval_stack_type (cfg, &ins->klass->byval_arg, ins);
>    *sp++= ins;
>   }
>   else
>    *sp++ = alloc;
>
>   ip += 5;
>   inline_costs += 5;
>   break;
>  }
>  case CEE_CASTCLASS:
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   klass = mini_get_class (method, token, generic_context);
>   if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>   if (sp [0]->type != STACK_OBJ)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   if (cfg->generic_sharing_context)
>    context_used = mono_class_check_context_used (klass);
>
>   if (!context_used && mini_class_has_reference_variant_generic_argument (klass, context_used)) {
>    MonoMethod *mono_castclass = mono_marshal_get_castclass_with_cache ();
>    MonoInst *args [3];
>
>
>    args [0] = *sp;
>
>
>    do { do { do { (((args [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [1])))->data.op[0].const_val = (((args [1])))->data.op[1].const_val = 0; (((args [1])))->next = (((args [1])))->prev = ((void *)0); (((args [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((args [1])))->flags = 0; (((args [1])))->type = 0; (((args [1])))->dreg = -1; do { ((((args [1]))))->sreg1 = ((((args [1]))))->sreg2 = ((((args [1]))))->sreg3 = -1; } while (0); (((args [1])))->cil_code = (((cfg)))->ip; } while (0); ((args [1]))->data.op[0].p = ((klass)); ((args [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_CLASS); ((args [1]))->type = STACK_PTR; ((args [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [1])); ((args [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [1])); } } while (0); } while (0);
>
>
>    if (cfg->compile_aot)
>     do { do { do { (((args [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [2])))->data.op[0].const_val = (((args [2])))->data.op[1].const_val = 0; (((args [2])))->next = (((args [2])))->prev = ((void *)0); (((args [2])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((args [2])))->flags = 0; (((args [2])))->type = 0; (((args [2])))->dreg = -1; do { ((((args [2]))))->sreg1 = ((((args [2]))))->sreg2 = ((((args [2]))))->sreg3 = -1; } while (0); (((args [2])))->cil_code = (((cfg)))->ip; } while (0); ((args [2]))->data.op[0].p = ((((void *)0))); ((args [2]))->data.op[1].src = (gpointer)((MONO_PATCH_INFO_CASTCLASS_CACHE)); ((args [2]))->type = STACK_PTR; ((args [2]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [2])); ((args [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [2])); } } while (0); } while (0);
>    else
>     do { do { do { (((args [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [2])))->data.op[0].const_val = (((args [2])))->data.op[1].const_val = 0; (((args [2])))->next = (((args [2])))->prev = ((void *)0); (((args [2])))->opcode = (OP_I8CONST); (((args [2])))->flags = 0; (((args [2])))->type = 0; (((args [2])))->dreg = -1; do { ((((args [2]))))->sreg1 = ((((args [2]))))->sreg2 = ((((args [2]))))->sreg3 = -1; } while (0); (((args [2])))->cil_code = (((cfg)))->ip; } while (0); ((args [2]))->data.op[0].p = ((mono_domain_alloc0 (cfg->domain, sizeof (gpointer)))); ((args [2]))->type = STACK_PTR; ((args [2]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [2])); ((args [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [2])); } } while (0); } while (0);
>
>
>    *sp++ = mono_emit_method_call (cfg, mono_castclass, args, ((void *)0));
>    ip += 5;
>    inline_costs += 2;
>   } else if (!context_used && (klass->marshalbyref || klass->flags & 0x00000020)) {
>    MonoMethod *mono_castclass;
>    MonoInst *iargs [1];
>    int costs;
>
>    mono_castclass = mono_marshal_get_castclass (klass);
>    iargs [0] = sp [0];
>
>    costs = inline_method (cfg, mono_castclass, mono_method_signature (mono_castclass),
>          iargs, ip, cfg->real_offset, dont_inline, 1);
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>    do { if (!(costs > 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8199, "costs > 0"); } while (0);
>
>    ip += 5;
>    cfg->real_offset += 5;
>    bblock = cfg->cbb;
>
>     *sp++ = iargs [0];
>
>    inline_costs += costs;
>   }
>   else {
>    ins = handle_castclass (cfg, klass, *sp, context_used);
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>    bblock = cfg->cbb;
>    *sp ++ = ins;
>    ip += 5;
>   }
>   break;
>  case CEE_ISINST: {
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   klass = mini_get_class (method, token, generic_context);
>   if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>   if (sp [0]->type != STACK_OBJ)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   if (cfg->generic_sharing_context)
>    context_used = mono_class_check_context_used (klass);
>
>   if (!context_used && mini_class_has_reference_variant_generic_argument (klass, context_used)) {
>    MonoMethod *mono_isinst = mono_marshal_get_isinst_with_cache ();
>    MonoInst *args [3];
>
>
>    args [0] = *sp;
>
>
>    do { do { do { (((args [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [1])))->data.op[0].const_val = (((args [1])))->data.op[1].const_val = 0; (((args [1])))->next = (((args [1])))->prev = ((void *)0); (((args [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((args [1])))->flags = 0; (((args [1])))->type = 0; (((args [1])))->dreg = -1; do { ((((args [1]))))->sreg1 = ((((args [1]))))->sreg2 = ((((args [1]))))->sreg3 = -1; } while (0); (((args [1])))->cil_code = (((cfg)))->ip; } while (0); ((args [1]))->data.op[0].p = ((klass)); ((args [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_CLASS); ((args [1]))->type = STACK_PTR; ((args [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [1])); ((args [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [1])); } } while (0); } while (0);
>
>
>    if (cfg->compile_aot)
>     do { do { do { (((args [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [2])))->data.op[0].const_val = (((args [2])))->data.op[1].const_val = 0; (((args [2])))->next = (((args [2])))->prev = ((void *)0); (((args [2])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((args [2])))->flags = 0; (((args [2])))->type = 0; (((args [2])))->dreg = -1; do { ((((args [2]))))->sreg1 = ((((args [2]))))->sreg2 = ((((args [2]))))->sreg3 = -1; } while (0); (((args [2])))->cil_code = (((cfg)))->ip; } while (0); ((args [2]))->data.op[0].p = ((((void *)0))); ((args [2]))->data.op[1].src = (gpointer)((MONO_PATCH_INFO_CASTCLASS_CACHE)); ((args [2]))->type = STACK_PTR; ((args [2]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [2])); ((args [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [2])); } } while (0); } while (0);
>    else
>     do { do { do { (((args [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [2])))->data.op[0].const_val = (((args [2])))->data.op[1].const_val = 0; (((args [2])))->next = (((args [2])))->prev = ((void *)0); (((args [2])))->opcode = (OP_I8CONST); (((args [2])))->flags = 0; (((args [2])))->type = 0; (((args [2])))->dreg = -1; do { ((((args [2]))))->sreg1 = ((((args [2]))))->sreg2 = ((((args [2]))))->sreg3 = -1; } while (0); (((args [2])))->cil_code = (((cfg)))->ip; } while (0); ((args [2]))->data.op[0].p = ((mono_domain_alloc0 (cfg->domain, sizeof (gpointer)))); ((args [2]))->type = STACK_PTR; ((args [2]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [2])); ((args [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [2])); } } while (0); } while (0);
>
>    *sp++ = mono_emit_method_call (cfg, mono_isinst, args, ((void *)0));
>    ip += 5;
>    inline_costs += 2;
>   } else if (!context_used && (klass->marshalbyref || klass->flags & 0x00000020)) {
>    MonoMethod *mono_isinst;
>    MonoInst *iargs [1];
>    int costs;
>
>    mono_isinst = mono_marshal_get_isinst (klass);
>    iargs [0] = sp [0];
>
>    costs = inline_method (cfg, mono_isinst, mono_method_signature (mono_isinst),
>          iargs, ip, cfg->real_offset, dont_inline, 1);
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>    do { if (!(costs > 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8260, "costs > 0"); } while (0);
>
>    ip += 5;
>    cfg->real_offset += 5;
>    bblock = cfg->cbb;
>
>    *sp++= iargs [0];
>
>    inline_costs += costs;
>   }
>   else {
>    ins = handle_isinst (cfg, klass, *sp, context_used);
>    do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>    bblock = cfg->cbb;
>    *sp ++ = ins;
>    ip += 5;
>   }
>   break;
>  }
>  case CEE_UNBOX_ANY: {
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   klass = mini_get_class (method, token, generic_context);
>   if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>
>   mono_save_token_info (cfg, image, token, klass);
>
>   if (cfg->generic_sharing_context)
>    context_used = mono_class_check_context_used (klass);
>
>   if (generic_class_is_reference_type (cfg, klass)) {
>
>    if (!context_used && mini_class_has_reference_variant_generic_argument (klass, context_used)) {
>     MonoMethod *mono_castclass = mono_marshal_get_castclass_with_cache ();
>     MonoInst *args [3];
>
>
>     args [0] = *sp;
>
>
>     do { do { do { (((args [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [1])))->data.op[0].const_val = (((args [1])))->data.op[1].const_val = 0; (((args [1])))->next = (((args [1])))->prev = ((void *)0); (((args [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((args [1])))->flags = 0; (((args [1])))->type = 0; (((args [1])))->dreg = -1; do { ((((args [1]))))->sreg1 = ((((args [1]))))->sreg2 = ((((args [1]))))->sreg3 = -1; } while (0); (((args [1])))->cil_code = (((cfg)))->ip; } while (0); ((args [1]))->data.op[0].p = ((klass)); ((args [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_CLASS); ((args [1]))->type = STACK_PTR; ((args [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [1])); ((args [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [1])); } } while (0); } while (0);
>
>
>
>     if (cfg->compile_aot)
>      do { do { do { (((args [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [2])))->data.op[0].const_val = (((args [2])))->data.op[1].const_val = 0; (((args [2])))->next = (((args [2])))->prev = ((void *)0); (((args [2])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((args [2])))->flags = 0; (((args [2])))->type = 0; (((args [2])))->dreg = -1; do { ((((args [2]))))->sreg1 = ((((args [2]))))->sreg2 = ((((args [2]))))->sreg3 = -1; } while (0); (((args [2])))->cil_code = (((cfg)))->ip; } while (0); ((args [2]))->data.op[0].p = ((((void *)0))); ((args [2]))->data.op[1].src = (gpointer)((MONO_PATCH_INFO_CASTCLASS_CACHE)); ((args [2]))->type = STACK_PTR; ((args [2]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [2])); ((args [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [2])); } } while (0); } while (0);
>     else
>      do { do { do { (((args [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((args [2])))->data.op[0].const_val = (((args [2])))->data.op[1].const_val = 0; (((args [2])))->next = (((args [2])))->prev = ((void *)0); (((args [2])))->opcode = (OP_I8CONST); (((args [2])))->flags = 0; (((args [2])))->type = 0; (((args [2])))->dreg = -1; do { ((((args [2]))))->sreg1 = ((((args [2]))))->sreg2 = ((((args [2]))))->sreg3 = -1; } while (0); (((args [2])))->cil_code = (((cfg)))->ip; } while (0); ((args [2]))->data.op[0].p = ((mono_domain_alloc0 (cfg->domain, sizeof (gpointer)))); ((args [2]))->type = STACK_PTR; ((args [2]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((args [2])); ((args [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((args [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((args [2])); } } while (0); } while (0);
>
>
>     *sp++ = mono_emit_method_call (cfg, mono_castclass, args, ((void *)0));
>     ip += 5;
>     inline_costs += 2;
>    } else if (!context_used && (klass->marshalbyref || klass->flags & 0x00000020)) {
>     MonoMethod *mono_castclass;
>     MonoInst *iargs [1];
>     int costs;
>
>     mono_castclass = mono_marshal_get_castclass (klass);
>     iargs [0] = sp [0];
>
>     costs = inline_method (cfg, mono_castclass, mono_method_signature (mono_castclass),
>             iargs, ip, cfg->real_offset, dont_inline, 1);
>     do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>     do { if (!(costs > 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8326, "costs > 0"); } while (0);
>
>     ip += 5;
>     cfg->real_offset += 5;
>     bblock = cfg->cbb;
>
>     *sp++ = iargs [0];
>     inline_costs += costs;
>    } else {
>     ins = handle_castclass (cfg, klass, *sp, context_used);
>     do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>     bblock = cfg->cbb;
>     *sp ++ = ins;
>     ip += 5;
>    }
>    break;
>   }
>
>   if (mono_class_is_nullable (klass)) {
>    ins = handle_unbox_nullable (cfg, *sp, klass, context_used);
>    *sp++= ins;
>    ip += 5;
>    break;
>   }
>
>
>   ins = handle_unbox (cfg, klass, sp, context_used);
>   *sp = ins;
>
>   ip += 5;
>
>
>   do { do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = ((mono_type_to_load_membase (((cfg)), ((&klass->byval_arg))))); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->dreg = (0); (((ins)))->sreg1 = (((sp [0]->dreg))); (((ins)))->data.op[0].const_val = (((0))); (((ins)))->type = STACK_I4; } while (0); type_to_eval_stack_type (((cfg)), ((&klass->byval_arg)), ((ins))); ((ins))->dreg = alloc_dreg (((cfg)), ((ins))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   *sp++ = ins;
>
>   inline_costs += 2;
>   break;
>  }
>  case CEE_BOX: {
>   MonoInst *val;
>
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>   val = *sp;
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   klass = mini_get_class (method, token, generic_context);
>   if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>
>   mono_save_token_info (cfg, image, token, klass);
>
>   if (cfg->generic_sharing_context)
>    context_used = mono_class_check_context_used (klass);
>
>   if (generic_class_is_reference_type (cfg, klass)) {
>    *sp++ = val;
>    ip += 5;
>    break;
>   }
>
>   if (klass == mono_defaults.void_class)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (target_type_is_incompatible (cfg, &klass->byval_arg, *sp))
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>
>
>   if (!mono_class_is_nullable (klass) &&
>    ip + 5 < end && ip_in_bb (cfg, bblock, ip + 5) &&
>    (ip [5] == CEE_BRTRUE ||
>     ip [5] == CEE_BRTRUE_S ||
>     ip [5] == CEE_BRFALSE ||
>     ip [5] == CEE_BRFALSE_S)) {
>    gboolean is_true = ip [5] == CEE_BRTRUE || ip [5] == CEE_BRTRUE_S;
>    int dreg;
>    MonoBasicBlock *true_bb, *false_bb;
>
>    ip += 5;
>
>    if (cfg->verbose_level > 3) {
>     printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (((void *)0), method, ip, ((void *)0)));
>     printf ("<box+brtrue opt>\n");
>    }
>
>    switch (*ip) {
>    case CEE_BRTRUE_S:
>    case CEE_BRFALSE_S:
>     if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>     ip++;
>     target = ip + 1 + (signed char)(*ip);
>     ip++;
>     break;
>    case CEE_BRTRUE:
>    case CEE_BRFALSE:
>     if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>     ip++;
>     target = ip + 4 + (gint)((((guint32) ( (((guint32) (*((const guint32 *) (ip)))) << 24)| ((((guint32) (*((const guint32 *) (ip)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip)))) >> 24)) )));
>     ip += 4;
>     break;
>    default:
>     do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 8426); } while (0);
>    }
>
>
>
>
>
>
>
>    do { (true_bb) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(true_bb)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((true_bb)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((true_bb))->block_num = cfg->num_bblocks++; } while (0); (true_bb)->cil_code = (target); do { if (((true_bb))->cil_code) { cfg->cil_offset_to_bb [((true_bb))->cil_code - cfg->cil_start] = ((true_bb)); } ((true_bb))->real_offset = cfg->real_offset; } while (0); } } while (0);
>    do { (false_bb) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; if (!(false_bb)) { if ((ip) >= end || (ip) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((false_bb)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((false_bb))->block_num = cfg->num_bblocks++; } while (0); (false_bb)->cil_code = (ip); do { if (((false_bb))->cil_code) { cfg->cil_offset_to_bb [((false_bb))->cil_code - cfg->cil_start] = ((false_bb)); } ((false_bb))->real_offset = cfg->real_offset; } while (0); } } while (0);
>
>    mono_link_bblock (cfg, cfg->cbb, true_bb);
>    mono_link_bblock (cfg, cfg->cbb, false_bb);
>
>    if (sp != stack_start) {
>     handle_stack_args (cfg, stack_start, sp - stack_start);
>     sp = stack_start;
>     if (cfg->unverifiable) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    }
>
>    if ((0)) {
>     dreg = alloc_ireg (cfg);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_ICONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = dreg; inst->data.op[0].const_val = 0; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = dreg; inst->data.op[1].const_val = (mgreg_t)(is_true ? 0 : 1); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>     do { MonoInst *ins; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_IBEQ)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (true_bb); ins->data.op[1].many_blocks[1] = (false_bb); mono_link_bblock ((cfg), (cfg)->cbb, (true_bb)); mono_link_bblock ((cfg), (cfg)->cbb, (false_bb)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); } while (0);
>    } else {
>
>     do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BR); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>     ins->data.op[0].target_block = is_true ? true_bb : false_bb;
>     do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>    }
>
>    start_new_bblock = 1;
>    break;
>   }
>
>   *sp++ = handle_box (cfg, val, klass, context_used);
>
>   do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>   ip += 5;
>   inline_costs += 1;
>   break;
>  }
>  case CEE_UNBOX: {
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   klass = mini_get_class (method, token, generic_context);
>   if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>
>   mono_save_token_info (cfg, image, token, klass);
>
>   if (cfg->generic_sharing_context)
>    context_used = mono_class_check_context_used (klass);
>
>   if (mono_class_is_nullable (klass)) {
>    MonoInst *val;
>
>    val = handle_unbox_nullable (cfg, *sp, klass, context_used);
>    do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_LDADDR); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((((val->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(val->dreg)] : ((void *)0)))); ((((val->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(val->dreg)] : ((void *)0))))->flags |= MONO_INST_INDIRECT; ((ins))->type = STACK_MP; ((ins))->klass = ((((val->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(val->dreg)] : ((void *)0))))->klass; ((ins))->dreg = alloc_dreg (((cfg)), STACK_MP); if (8 == 4 && ((((((val->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(val->dreg)] : ((void *)0))))->type) == STACK_I8)) { MonoInst *var1 = ((((((val->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(val->dreg)] : ((void *)0))))->dreg + 1) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [(((((val->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(val->dreg)] : ((void *)0))))->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((((val->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(val->dreg)] : ((void *)0))))->dreg + 2) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [(((((val->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(val->dreg)] : ((void *)0))))->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8488, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8488, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>
>    *sp++= ins;
>   } else {
>    ins = handle_unbox (cfg, klass, sp, context_used);
>    *sp++ = ins;
>   }
>   ip += 5;
>   inline_costs += 2;
>   break;
>  }
>  case CEE_LDFLD:
>  case CEE_LDFLDA:
>  case CEE_STFLD: {
>   MonoClassField *field;
>   int costs;
>   guint foffset;
>
>   if (*ip == CEE_STFLD) {
>    if ((sp - stack_start) < (2)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    sp -= 2;
>   } else {
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>   }
>   if (sp [0]->type == STACK_I4 || sp [0]->type == STACK_I8 || sp [0]->type == STACK_R8)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (*ip != CEE_LDFLD && sp [0]->type == STACK_VTYPE)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   if (method->wrapper_type != MONO_WRAPPER_NONE) {
>    field = mono_method_get_wrapper_data (method, token);
>    klass = field->parent;
>   }
>   else {
>    field = mono_field_from_token (image, token, &klass, generic_context);
>   }
>   if (!field)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>   if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_field (method, field))
>    do { char *method_fname = mono_method_full_name (method, 1); char *field_fname = mono_field_full_name (field); mono_cfg_set_exception (cfg, MONO_EXCEPTION_FIELD_ACCESS); cfg->exception_message = monoeg_g_strdup_printf ("Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname); monoeg_g_free (method_fname); monoeg_g_free (field_fname); goto exception_exit; } while (0);
>   mono_class_init (klass);
>
>
>
>
>
>
>
>   foffset = klass->valuetype? field->offset - sizeof (MonoObject): field->offset;
>   if (*ip == CEE_STFLD) {
>    if (target_type_is_incompatible (cfg, field->type, sp [1]))
>     do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if ((klass->marshalbyref && !(mono_method_signature (cfg->method)->hasthis && ((sp [0])->opcode == OP_MOVE) && ((sp [0])->sreg1 == cfg->args [0]->dreg))) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
>     MonoMethod *stfld_wrapper = mono_marshal_get_stfld_wrapper (field->type);
>     MonoInst *iargs [5];
>
>     iargs [0] = sp [0];
>     do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].p = ((klass)); ((iargs [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_CLASS); ((iargs [1]))->type = STACK_PTR; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>     do { do { do { (((iargs [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [2])))->data.op[0].const_val = (((iargs [2])))->data.op[1].const_val = 0; (((iargs [2])))->next = (((iargs [2])))->prev = ((void *)0); (((iargs [2])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [2])))->flags = 0; (((iargs [2])))->type = 0; (((iargs [2])))->dreg = -1; do { ((((iargs [2]))))->sreg1 = ((((iargs [2]))))->sreg2 = ((((iargs [2]))))->sreg3 = -1; } while (0); (((iargs [2])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [2]))->data.op[0].p = ((field)); ((iargs [2]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_FIELD); ((iargs [2]))->type = STACK_PTR; ((iargs [2]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [2])); ((iargs [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [2])); } } while (0); } while (0);
>     do { do { do { (((iargs [3]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [3])))->data.op[0].const_val = (((iargs [3])))->data.op[1].const_val = 0; (((iargs [3])))->next = (((iargs [3])))->prev = ((void *)0); (((iargs [3])))->opcode = (OP_ICONST); (((iargs [3])))->flags = 0; (((iargs [3])))->type = 0; (((iargs [3])))->dreg = -1; do { ((((iargs [3]))))->sreg1 = ((((iargs [3]))))->sreg2 = ((((iargs [3]))))->sreg3 = -1; } while (0); (((iargs [3])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [3]))->data.op[0].const_val = ((klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset)); ((iargs [3]))->type = STACK_I4; ((iargs [3]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [3])); ((iargs [3]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [3])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [3])); } } while (0); } while (0)
>                        ;
>     iargs [4] = sp [1];
>
>     if (cfg->opt & MONO_OPT_INLINE || cfg->compile_aot) {
>      costs = inline_method (cfg, stfld_wrapper, mono_method_signature (stfld_wrapper),
>               iargs, ip, cfg->real_offset, dont_inline, 1);
>      do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>      do { if (!(costs > 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8557, "costs > 0"); } while (0);
>
>      cfg->real_offset += 5;
>      bblock = cfg->cbb;
>
>      inline_costs += costs;
>     } else {
>      mono_emit_method_call (cfg, stfld_wrapper, iargs, ((void *)0));
>     }
>    } else {
>     MonoInst *store;
>
>     do { if (cfg->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (sp [0]->dreg); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0);
>
>     do { do { do { (((store))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((store)))->data.op[0].const_val = (((store)))->data.op[1].const_val = 0; (((store)))->next = (((store)))->prev = ((void *)0); (((store)))->opcode = (mono_type_to_store_membase (((cfg)), ((field->type)))); (((store)))->flags = 0; (((store)))->type = 0; (((store)))->dreg = -1; do { ((((store))))->sreg1 = ((((store))))->sreg2 = ((((store))))->sreg3 = -1; } while (0); (((store)))->cil_code = (((cfg)))->ip; } while (0); ((store))->sreg1 = (sp [1]->dreg); ((store))->dreg = (sp [0]->dreg); ((store))->data.op[0].const_val = (foffset); type_to_eval_stack_type (((cfg)), ((field->type)), ((store))); ((store))->klass = mono_class_from_mono_type ((field->type)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((store)); ((store))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((store)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((store)); } } while (0); } while (0);
>     if (sp [0]->opcode != OP_LDADDR)
>      store->flags |= MONO_INST_FAULT;
>
>    if (cfg->gen_write_barriers && mini_type_to_stind (cfg, field->type) == CEE_STIND_REF && !(sp [1]->opcode == OP_I8CONST && sp [1]->data.op[0].const_val == 0)) {
>
>     MonoInst *ptr;
>     int dreg;
>
>     dreg = alloc_ireg_mp (cfg);
>     do { do { do { (((ptr))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ptr)))->data.op[0].const_val = (((ptr)))->data.op[1].const_val = 0; (((ptr)))->next = (((ptr)))->prev = ((void *)0); (((ptr)))->opcode = (((OP_LADD_IMM))); (((ptr)))->flags = 0; (((ptr)))->type = 0; (((ptr)))->dreg = -1; do { ((((ptr))))->sreg1 = ((((ptr))))->sreg2 = ((((ptr))))->sreg3 = -1; } while (0); (((ptr)))->cil_code = (((cfg)))->ip; } while (0); ((ptr))->dreg = (dreg); ((ptr))->sreg1 = (sp [0]->dreg); ((ptr))->data.op[1].const_val = ((foffset)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ptr)); ((ptr))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ptr)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ptr)); } } while (0); } while (0);
>     emit_write_barrier (cfg, ptr, sp [1], -1);
>    }
>
>     store->flags |= ins_flag;
>    }
>    ins_flag = 0;
>    ip += 5;
>    break;
>   }
>
>   if ((klass->marshalbyref && !(mono_method_signature (cfg->method)->hasthis && ((sp [0])->opcode == OP_MOVE) && ((sp [0])->sreg1 == cfg->args [0]->dreg))) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
>    MonoMethod *wrapper = (*ip == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
>    MonoInst *iargs [4];
>
>    iargs [0] = sp [0];
>    do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].p = ((klass)); ((iargs [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_CLASS); ((iargs [1]))->type = STACK_PTR; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>    do { do { do { (((iargs [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [2])))->data.op[0].const_val = (((iargs [2])))->data.op[1].const_val = 0; (((iargs [2])))->next = (((iargs [2])))->prev = ((void *)0); (((iargs [2])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [2])))->flags = 0; (((iargs [2])))->type = 0; (((iargs [2])))->dreg = -1; do { ((((iargs [2]))))->sreg1 = ((((iargs [2]))))->sreg2 = ((((iargs [2]))))->sreg3 = -1; } while (0); (((iargs [2])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [2]))->data.op[0].p = ((field)); ((iargs [2]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_FIELD); ((iargs [2]))->type = STACK_PTR; ((iargs [2]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [2])); ((iargs [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [2])); } } while (0); } while (0);
>    do { do { do { (((iargs [3]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [3])))->data.op[0].const_val = (((iargs [3])))->data.op[1].const_val = 0; (((iargs [3])))->next = (((iargs [3])))->prev = ((void *)0); (((iargs [3])))->opcode = (OP_ICONST); (((iargs [3])))->flags = 0; (((iargs [3])))->type = 0; (((iargs [3])))->dreg = -1; do { ((((iargs [3]))))->sreg1 = ((((iargs [3]))))->sreg2 = ((((iargs [3]))))->sreg3 = -1; } while (0); (((iargs [3])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [3]))->data.op[0].const_val = ((klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset)); ((iargs [3]))->type = STACK_I4; ((iargs [3]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [3])); ((iargs [3]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [3])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [3])); } } while (0); } while (0);
>    if (cfg->opt & MONO_OPT_INLINE || cfg->compile_aot) {
>     costs = inline_method (cfg, wrapper, mono_method_signature (wrapper),
>             iargs, ip, cfg->real_offset, dont_inline, 1);
>     do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>     bblock = cfg->cbb;
>     do { if (!(costs > 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8605, "costs > 0"); } while (0);
>
>     cfg->real_offset += 5;
>
>     *sp++ = iargs [0];
>
>     inline_costs += costs;
>    } else {
>     ins = mono_emit_method_call (cfg, wrapper, iargs, ((void *)0));
>     *sp++ = ins;
>    }
>   } else {
>    if (sp [0]->type == STACK_VTYPE) {
>     MonoInst *var;
>
>
>
>     var = ((sp [0]->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(sp [0]->dreg)] : ((void *)0));
>     if (!var)
>      var = mono_compile_create_var_for_vreg (cfg, &klass->byval_arg, OP_LOCAL, sp [0]->dreg);
>     else
>      do { if (!(var->klass == klass)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8626, "var->klass == klass"); } while (0);
>
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_LDADDR); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((var)); ((var))->flags |= MONO_INST_INDIRECT; ((ins))->type = STACK_MP; ((ins))->klass = ((var))->klass; ((ins))->dreg = alloc_dreg (((cfg)), STACK_MP); if (8 == 4 && ((((var))->type) == STACK_I8)) { MonoInst *var1 = ((((var))->dreg + 1) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [(((var))->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((var))->dreg + 2) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [(((var))->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8628, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8628, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     sp [0] = ins;
>    }
>
>    if (*ip == CEE_LDFLDA) {
>     if (sp [0]->type == STACK_OBJ) {
>      do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = sp [0]->dreg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>      do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>     }
>
>     dreg = alloc_ireg_mp (cfg);
>
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LADD_IMM))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = (dreg); ((ins))->sreg1 = (sp [0]->dreg); ((ins))->data.op[1].const_val = ((foffset)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     ins->klass = mono_class_from_mono_type (field->type);
>     ins->type = STACK_MP;
>     *sp++ = ins;
>    } else {
>     MonoInst *load;
>
>     do { if (cfg->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (sp [0]->dreg); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0);
>
>     do { do { do { do { ((((load)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((load))))->data.op[0].const_val = ((((load))))->data.op[1].const_val = 0; ((((load))))->next = ((((load))))->prev = ((void *)0); ((((load))))->opcode = ((mono_type_to_load_membase (((cfg)), ((field->type))))); ((((load))))->flags = 0; ((((load))))->type = 0; ((((load))))->dreg = -1; do { (((((load)))))->sreg1 = (((((load)))))->sreg2 = (((((load)))))->sreg3 = -1; } while (0); ((((load))))->cil_code = ((((cfg))))->ip; } while (0); (((load)))->dreg = (0); (((load)))->sreg1 = (((sp [0]->dreg))); (((load)))->data.op[0].const_val = (((foffset))); (((load)))->type = STACK_I4; } while (0); type_to_eval_stack_type (((cfg)), ((field->type)), ((load))); ((load))->dreg = alloc_dreg (((cfg)), ((load))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((load)); ((load))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((load)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((load)); } } while (0); } while (0);
>     load->flags |= ins_flag;
>     if (sp [0]->opcode != OP_LDADDR)
>      load->flags |= MONO_INST_FAULT;
>     *sp++ = load;
>    }
>   }
>   ins_flag = 0;
>   ip += 5;
>   break;
>  }
>  case CEE_LDSFLD:
>  case CEE_LDSFLDA:
>  case CEE_STSFLD: {
>   MonoClassField *field;
>   gpointer addr = ((void *)0);
>   gboolean is_special_static;
>   MonoType *ftype;
>
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>
>   if (method->wrapper_type != MONO_WRAPPER_NONE) {
>    field = mono_method_get_wrapper_data (method, token);
>    klass = field->parent;
>   }
>   else
>    field = mono_field_from_token (image, token, &klass, generic_context);
>   if (!field)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>   mono_class_init (klass);
>   if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_field (method, field))
>    do { char *method_fname = mono_method_full_name (method, 1); char *field_fname = mono_field_full_name (field); mono_cfg_set_exception (cfg, MONO_EXCEPTION_FIELD_ACCESS); cfg->exception_message = monoeg_g_strdup_printf ("Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname); monoeg_g_free (method_fname); monoeg_g_free (field_fname); goto exception_exit; } while (0);
>
>
>   if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
>    ensure_method_is_allowed_to_access_field (cfg, method, field, bblock, ip);
># 8694 "method-to-ir.c"
>   do { if (cfg->generic_sharing_context) { if (cfg->verbose_level > 2) printf ("sharing failed for method %s.%s.%s/%d opcode %s line %d\n", method->klass->name_space, method->klass->name, method->name, method->signature->param_count, mono_opcode_name ((*ip)), 8694); mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); goto exception_exit; } } while (0);
>
>
>   if (cfg->generic_sharing_context)
>    context_used = mono_class_check_context_used (klass);
>
>   ftype = mono_field_get_type (field);
>
>   do { if (!(!(ftype->attrs & 0x0040))) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8702, "!(ftype->attrs & FIELD_ATTRIBUTE_LITERAL)"); } while (0);
>
>
>
>
>   if (!context_used && !(cfg->opt & MONO_OPT_SHARED)) {
>    mono_class_vtable (cfg->domain, klass);
>    if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>   }
>   do { do { int ret = pthread_mutex_lock (&(&(cfg->domain)->lock)->mutex); if (ret != 0) monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_WARNING, "Bad call to mono_mutex_lock result %d", ret); do { if (!(ret == 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8711, "ret == 0"); } while (0); } while (0); do {} while (0); } while (0);
>   if (cfg->domain->special_static_fields)
>    addr = monoeg_g_hash_table_lookup (cfg->domain->special_static_fields, field);
>   do { do {} while (0); do { int ret = pthread_mutex_unlock (&(&(cfg->domain)->lock)->mutex); if (ret != 0) monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_WARNING, "Bad call to mono_mutex_unlock result %d", ret); do { if (!(ret == 0)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8714, "ret == 0"); } while (0); } while (0); } while (0);
>
>   is_special_static = mono_class_field_is_special_static (field);
>
>
>   if (is_special_static && ((gsize)addr & 0x80000000) == 0 && mono_get_thread_intrinsic (cfg) && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
>
>
>
>
>
>    guint32 offset;
>    int idx, static_data_reg, array_reg, dreg;
>    MonoInst *thread_ins;
>
>
>
>
>
>    thread_ins = mono_get_thread_intrinsic (cfg);
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (thread_ins); (thread_ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (thread_ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (thread_ins); } } while (0);
>    static_data_reg = alloc_ireg (cfg);
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (static_data_reg); inst->sreg1 = (thread_ins->dreg); inst->data.op[0].const_val = (__builtin_offsetof (MonoInternalThread, static_data)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>    if (cfg->compile_aot) {
>     int offset_reg, offset2_reg, idx_reg;
>
>
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((field)); ((ins))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_SFLDA); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     offset_reg = ins->dreg;
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_IAND_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = offset_reg; inst->sreg1 = offset_reg; inst->data.op[1].const_val = (mgreg_t)(0x7fffffff); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>     idx_reg = alloc_ireg (cfg);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_ISHR_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = idx_reg; inst->sreg1 = offset_reg; inst->data.op[1].const_val = (mgreg_t)(24); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_ISUB_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = idx_reg; inst->sreg1 = idx_reg; inst->data.op[1].const_val = (mgreg_t)(1); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_ISHL_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = idx_reg; inst->sreg1 = idx_reg; inst->data.op[1].const_val = (mgreg_t)(sizeof (gpointer) == 8 ? 3 : 2); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_LADD)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = static_data_reg; inst->sreg1 = static_data_reg; inst->sreg2 = idx_reg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>     array_reg = alloc_ireg (cfg);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (array_reg); inst->sreg1 = (static_data_reg); inst->data.op[0].const_val = (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>     offset2_reg = alloc_ireg (cfg);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_IAND_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = offset2_reg; inst->sreg1 = offset_reg; inst->data.op[1].const_val = (mgreg_t)(0xffffff); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>     dreg = alloc_ireg (cfg);
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LADD))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = ((dreg)); ((ins))->sreg1 = ((array_reg)); ((ins))->sreg2 = ((offset2_reg)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    } else {
>     offset = (gsize)addr & 0x7fffffff;
>     idx = (offset >> 24) - 1;
>
>     array_reg = alloc_ireg (cfg);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (array_reg); inst->sreg1 = (static_data_reg); inst->data.op[0].const_val = (idx * sizeof (gpointer)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>     dreg = alloc_ireg (cfg);
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_ADD_IMM))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = (dreg); ((ins))->sreg1 = (array_reg); ((ins))->data.op[1].const_val = (((offset & 0xffffff))); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    }
>   } else if ((cfg->opt & MONO_OPT_SHARED) ||
>     (cfg->compile_aot && is_special_static) ||
>     (context_used && is_special_static)) {
>    MonoInst *iargs [2];
>
>    do { if (!(field->parent)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8770, "field->parent"); } while (0);
>    do { do { if (((cfg)->opt & MONO_OPT_SHARED) || (cfg)->compile_aot) { MonoInst* __domain_var = mono_get_domainvar ((cfg)); do { do { ((((iargs [0])))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((iargs [0]))))->data.op[0].const_val = ((((iargs [0]))))->data.op[1].const_val = 0; ((((iargs [0]))))->next = ((((iargs [0]))))->prev = ((void *)0); ((((iargs [0]))))->opcode = (OP_MOVE); ((((iargs [0]))))->flags = 0; ((((iargs [0]))))->type = 0; ((((iargs [0]))))->dreg = -1; do { (((((iargs [0])))))->sreg1 = (((((iargs [0])))))->sreg2 = (((((iargs [0])))))->sreg3 = -1; } while (0); ((((iargs [0]))))->cil_code = ((((cfg))))->ip; } while (0); (((iargs [0])))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype), (((iargs [0])))); (((iargs [0])))->klass = ((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->klass; (((iargs [0])))->sreg1 = ((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->dreg; (((iargs [0])))->dreg = alloc_dreg ((((cfg))), (((iargs [0])))->type); if ((((iargs [0])))->opcode == OP_VMOVE) (((iargs [0])))->klass = mono_class_from_mono_type ((((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); } while (0); } else { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_I8CONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].p = (((cfg))->domain); ((iargs [0]))->type = STACK_PTR; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>    if (context_used) {
>     iargs [1] = emit_get_rgctx_field (cfg, context_used,
>      field, MONO_RGCTX_INFO_CLASS_FIELD);
>    } else {
>     do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].p = ((field)); ((iargs [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_FIELD); ((iargs [1]))->type = STACK_PTR; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>    }
>    ins = mono_emit_jit_icall (cfg, mono_class_static_field_address, iargs);
>   } else if (context_used) {
>    MonoInst *static_data;
>
>
>
>
>
>
>
>    if (mono_class_needs_cctor_run (klass, method))
>     emit_generic_class_init (cfg, klass);
>
>
>
>
>
>
>    static_data = emit_get_rgctx_klass (cfg, context_used,
>     klass, MONO_RGCTX_INFO_STATIC_DATA);
>
>    if (field->offset == 0) {
>     ins = static_data;
>    } else {
>     int addr_reg = mono_alloc_preg (cfg);
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LADD_IMM))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = (addr_reg); ((ins))->sreg1 = (static_data->dreg); ((ins))->data.op[1].const_val = ((field->offset)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    }
>    } else if ((cfg->opt & MONO_OPT_SHARED) || (cfg->compile_aot && addr)) {
>    MonoInst *iargs [2];
>
>    do { if (!(field->parent)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 8808, "field->parent"); } while (0);
>    do { do { if (((cfg)->opt & MONO_OPT_SHARED) || (cfg)->compile_aot) { MonoInst* __domain_var = mono_get_domainvar ((cfg)); do { do { ((((iargs [0])))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((iargs [0]))))->data.op[0].const_val = ((((iargs [0]))))->data.op[1].const_val = 0; ((((iargs [0]))))->next = ((((iargs [0]))))->prev = ((void *)0); ((((iargs [0]))))->opcode = (OP_MOVE); ((((iargs [0]))))->flags = 0; ((((iargs [0]))))->type = 0; ((((iargs [0]))))->dreg = -1; do { (((((iargs [0])))))->sreg1 = (((((iargs [0])))))->sreg2 = (((((iargs [0])))))->sreg3 = -1; } while (0); ((((iargs [0]))))->cil_code = ((((cfg))))->ip; } while (0); (((iargs [0])))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype), (((iargs [0])))); (((iargs [0])))->klass = ((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->klass; (((iargs [0])))->sreg1 = ((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->dreg; (((iargs [0])))->dreg = alloc_dreg ((((cfg))), (((iargs [0])))->type); if ((((iargs [0])))->opcode == OP_VMOVE) (((iargs [0])))->klass = mono_class_from_mono_type ((((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); } while (0); } else { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_I8CONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].p = (((cfg))->domain); ((iargs [0]))->type = STACK_PTR; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>    do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].p = ((field)); ((iargs [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_FIELD); ((iargs [1]))->type = STACK_PTR; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>    ins = mono_emit_jit_icall (cfg, mono_class_static_field_address, iargs);
>   } else {
>    MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
>
>    if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>    if (!addr) {
>     if (mini_field_access_needs_cctor_run (cfg, method, vtable)) {
>      if (!(monoeg_g_slist_find (class_inits, vtable))) {
>       mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, ((void *)0));
>       if (cfg->verbose_level > 2)
>        printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
>       class_inits = monoeg_g_slist_prepend (class_inits, vtable);
>      }
>     } else {
>      if (cfg->run_cctors) {
>       MonoException *ex;
>
>
>
>       if (! vtable->initialized)
>        do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>       ex = mono_runtime_class_init_full (vtable, 0);
>       if (ex) {
>        set_exception_object (cfg, ex);
>        goto exception_exit;
>       }
>      }
>     }
>     addr = (char*)vtable->data + field->offset;
>
>     if (cfg->compile_aot)
>      do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((field)); ((ins))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_SFLDA); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     else
>      do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((addr)); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    } else {
>     MonoInst *iargs [1];
>     do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_ICONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].const_val = ((((guint)(long) (addr)))); ((iargs [0]))->type = STACK_I4; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>     ins = mono_emit_jit_icall (cfg, mono_get_special_static_data, iargs);
>    }
>   }
>
>
>
>   if (*ip == CEE_LDSFLDA) {
>    ins->klass = mono_class_from_mono_type (ftype);
>    ins->type = STACK_PTR;
>    *sp++ = ins;
>   } else if (*ip == CEE_STSFLD) {
>    MonoInst *store;
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    sp--;
>
>    do { do { do { (((store))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((store)))->data.op[0].const_val = (((store)))->data.op[1].const_val = 0; (((store)))->next = (((store)))->prev = ((void *)0); (((store)))->opcode = (mono_type_to_store_membase (((cfg)), ((ftype)))); (((store)))->flags = 0; (((store)))->type = 0; (((store)))->dreg = -1; do { ((((store))))->sreg1 = ((((store))))->sreg2 = ((((store))))->sreg3 = -1; } while (0); (((store)))->cil_code = (((cfg)))->ip; } while (0); ((store))->sreg1 = (sp [0]->dreg); ((store))->dreg = (ins->dreg); ((store))->data.op[0].const_val = (0); type_to_eval_stack_type (((cfg)), ((ftype)), ((store))); ((store))->klass = mono_class_from_mono_type ((ftype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((store)); ((store))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((store)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((store)); } } while (0); } while (0);
>    store->flags |= ins_flag;
>   } else {
>    gboolean is_const = 0;
>    MonoVTable *vtable = ((void *)0);
>
>    if (!context_used) {
>     vtable = mono_class_vtable (cfg->domain, klass);
>     if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>    }
>    if (!context_used && !((cfg->opt & MONO_OPT_SHARED) || cfg->compile_aot) &&
>        vtable->initialized && (ftype->attrs & 0x0020)) {
>     gpointer addr = (char*)vtable->data + field->offset;
>     int ro_type = ftype->type;
>     if (ro_type == MONO_TYPE_VALUETYPE && ftype->data.klass->enumtype) {
>      ro_type = mono_class_enum_basetype (ftype->data.klass)->type;
>     }
>
>     is_const = 1;
>     switch (ro_type) {
>     case MONO_TYPE_BOOLEAN:
>     case MONO_TYPE_U1:
>      do { do { do { (((*sp))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((*sp)))->data.op[0].const_val = (((*sp)))->data.op[1].const_val = 0; (((*sp)))->next = (((*sp)))->prev = ((void *)0); (((*sp)))->opcode = (OP_ICONST); (((*sp)))->flags = 0; (((*sp)))->type = 0; (((*sp)))->dreg = -1; do { ((((*sp))))->sreg1 = ((((*sp))))->sreg2 = ((((*sp))))->sreg3 = -1; } while (0); (((*sp)))->cil_code = (((cfg)))->ip; } while (0); ((*sp))->data.op[0].const_val = ((*((guint8 *)addr))); ((*sp))->type = STACK_I4; ((*sp))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((*sp)); ((*sp))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((*sp)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((*sp)); } } while (0); } while (0);
>      sp++;
>      break;
>     case MONO_TYPE_I1:
>      do { do { do { (((*sp))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((*sp)))->data.op[0].const_val = (((*sp)))->data.op[1].const_val = 0; (((*sp)))->next = (((*sp)))->prev = ((void *)0); (((*sp)))->opcode = (OP_ICONST); (((*sp)))->flags = 0; (((*sp)))->type = 0; (((*sp)))->dreg = -1; do { ((((*sp))))->sreg1 = ((((*sp))))->sreg2 = ((((*sp))))->sreg3 = -1; } while (0); (((*sp)))->cil_code = (((cfg)))->ip; } while (0); ((*sp))->data.op[0].const_val = ((*((gint8 *)addr))); ((*sp))->type = STACK_I4; ((*sp))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((*sp)); ((*sp))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((*sp)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((*sp)); } } while (0); } while (0);
>      sp++;
>      break;
>     case MONO_TYPE_CHAR:
>     case MONO_TYPE_U2:
>      do { do { do { (((*sp))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((*sp)))->data.op[0].const_val = (((*sp)))->data.op[1].const_val = 0; (((*sp)))->next = (((*sp)))->prev = ((void *)0); (((*sp)))->opcode = (OP_ICONST); (((*sp)))->flags = 0; (((*sp)))->type = 0; (((*sp)))->dreg = -1; do { ((((*sp))))->sreg1 = ((((*sp))))->sreg2 = ((((*sp))))->sreg3 = -1; } while (0); (((*sp)))->cil_code = (((cfg)))->ip; } while (0); ((*sp))->data.op[0].const_val = ((*((guint16 *)addr))); ((*sp))->type = STACK_I4; ((*sp))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((*sp)); ((*sp))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((*sp)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((*sp)); } } while (0); } while (0);
>      sp++;
>      break;
>     case MONO_TYPE_I2:
>      do { do { do { (((*sp))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((*sp)))->data.op[0].const_val = (((*sp)))->data.op[1].const_val = 0; (((*sp)))->next = (((*sp)))->prev = ((void *)0); (((*sp)))->opcode = (OP_ICONST); (((*sp)))->flags = 0; (((*sp)))->type = 0; (((*sp)))->dreg = -1; do { ((((*sp))))->sreg1 = ((((*sp))))->sreg2 = ((((*sp))))->sreg3 = -1; } while (0); (((*sp)))->cil_code = (((cfg)))->ip; } while (0); ((*sp))->data.op[0].const_val = ((*((gint16 *)addr))); ((*sp))->type = STACK_I4; ((*sp))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((*sp)); ((*sp))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((*sp)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((*sp)); } } while (0); } while (0);
>      sp++;
>      break;
>      break;
>     case MONO_TYPE_I4:
>      do { do { do { (((*sp))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((*sp)))->data.op[0].const_val = (((*sp)))->data.op[1].const_val = 0; (((*sp)))->next = (((*sp)))->prev = ((void *)0); (((*sp)))->opcode = (OP_ICONST); (((*sp)))->flags = 0; (((*sp)))->type = 0; (((*sp)))->dreg = -1; do { ((((*sp))))->sreg1 = ((((*sp))))->sreg2 = ((((*sp))))->sreg3 = -1; } while (0); (((*sp)))->cil_code = (((cfg)))->ip; } while (0); ((*sp))->data.op[0].const_val = ((*((gint32 *)addr))); ((*sp))->type = STACK_I4; ((*sp))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((*sp)); ((*sp))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((*sp)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((*sp)); } } while (0); } while (0);
>      sp++;
>      break;
>     case MONO_TYPE_U4:
>      do { do { do { (((*sp))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((*sp)))->data.op[0].const_val = (((*sp)))->data.op[1].const_val = 0; (((*sp)))->next = (((*sp)))->prev = ((void *)0); (((*sp)))->opcode = (OP_ICONST); (((*sp)))->flags = 0; (((*sp)))->type = 0; (((*sp)))->dreg = -1; do { ((((*sp))))->sreg1 = ((((*sp))))->sreg2 = ((((*sp))))->sreg3 = -1; } while (0); (((*sp)))->cil_code = (((cfg)))->ip; } while (0); ((*sp))->data.op[0].const_val = ((*((guint32 *)addr))); ((*sp))->type = STACK_I4; ((*sp))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((*sp)); ((*sp))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((*sp)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((*sp)); } } while (0); } while (0);
>      sp++;
>      break;
>     case MONO_TYPE_I:
>     case MONO_TYPE_U:
>     case MONO_TYPE_PTR:
>     case MONO_TYPE_FNPTR:
>      do { do { do { (((*sp))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((*sp)))->data.op[0].const_val = (((*sp)))->data.op[1].const_val = 0; (((*sp)))->next = (((*sp)))->prev = ((void *)0); (((*sp)))->opcode = (OP_I8CONST); (((*sp)))->flags = 0; (((*sp)))->type = 0; (((*sp)))->dreg = -1; do { ((((*sp))))->sreg1 = ((((*sp))))->sreg2 = ((((*sp))))->sreg3 = -1; } while (0); (((*sp)))->cil_code = (((cfg)))->ip; } while (0); ((*sp))->data.op[0].p = ((*((gpointer *)addr))); ((*sp))->type = STACK_PTR; ((*sp))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((*sp)); ((*sp))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((*sp)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((*sp)); } } while (0); } while (0);
>      type_to_eval_stack_type ((cfg), field->type, *sp);
>      sp++;
>      break;
>     case MONO_TYPE_STRING:
>     case MONO_TYPE_OBJECT:
>     case MONO_TYPE_CLASS:
>     case MONO_TYPE_SZARRAY:
>     case MONO_TYPE_ARRAY:
>      if (!mono_gc_is_moving ()) {
>       do { do { do { (((*sp))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((*sp)))->data.op[0].const_val = (((*sp)))->data.op[1].const_val = 0; (((*sp)))->next = (((*sp)))->prev = ((void *)0); (((*sp)))->opcode = (OP_I8CONST); (((*sp)))->flags = 0; (((*sp)))->type = 0; (((*sp)))->dreg = -1; do { ((((*sp))))->sreg1 = ((((*sp))))->sreg2 = ((((*sp))))->sreg3 = -1; } while (0); (((*sp)))->cil_code = (((cfg)))->ip; } while (0); ((*sp))->data.op[0].p = ((*((gpointer *)addr))); ((*sp))->type = STACK_PTR; ((*sp))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((*sp)); ((*sp))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((*sp)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((*sp)); } } while (0); } while (0);
>       type_to_eval_stack_type ((cfg), field->type, *sp);
>       sp++;
>      } else {
>       is_const = 0;
>      }
>      break;
>     case MONO_TYPE_I8:
>     case MONO_TYPE_U8:
>      do { do { do { (((*sp))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((*sp)))->data.op[0].const_val = (((*sp)))->data.op[1].const_val = 0; (((*sp)))->next = (((*sp)))->prev = ((void *)0); (((*sp)))->opcode = (OP_I8CONST); (((*sp)))->flags = 0; (((*sp)))->type = 0; (((*sp)))->dreg = -1; do { ((((*sp))))->sreg1 = ((((*sp))))->sreg2 = ((((*sp))))->sreg3 = -1; } while (0); (((*sp)))->cil_code = (((cfg)))->ip; } while (0); ((*sp))->dreg = alloc_lreg (((cfg))); ((*sp))->type = STACK_I8; ((*sp))->data.i8const = ((*((gint64 *)addr))); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((*sp)); ((*sp))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((*sp)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((*sp)); } } while (0); } while (0);
>      sp++;
>      break;
>     case MONO_TYPE_R4:
>     case MONO_TYPE_R8:
>     case MONO_TYPE_VALUETYPE:
>     default:
>      is_const = 0;
>      break;
>     }
>    }
>
>    if (!is_const) {
>     MonoInst *load;
>
>     if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>     do { do { do { do { ((((load)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((load))))->data.op[0].const_val = ((((load))))->data.op[1].const_val = 0; ((((load))))->next = ((((load))))->prev = ((void *)0); ((((load))))->opcode = ((mono_type_to_load_membase (((cfg)), ((field->type))))); ((((load))))->flags = 0; ((((load))))->type = 0; ((((load))))->dreg = -1; do { (((((load)))))->sreg1 = (((((load)))))->sreg2 = (((((load)))))->sreg3 = -1; } while (0); ((((load))))->cil_code = ((((cfg))))->ip; } while (0); (((load)))->dreg = (0); (((load)))->sreg1 = (((ins->dreg))); (((load)))->data.op[0].const_val = (((0))); (((load)))->type = STACK_I4; } while (0); type_to_eval_stack_type (((cfg)), ((field->type)), ((load))); ((load))->dreg = alloc_dreg (((cfg)), ((load))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((load)); ((load))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((load)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((load)); } } while (0); } while (0);
>     load->flags |= ins_flag;
>     ins_flag = 0;
>     *sp++ = load;
>    }
>   }
>   ins_flag = 0;
>   ip += 5;
>   break;
>  }
>  case CEE_STOBJ:
>   if ((sp - stack_start) < (2)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   sp -= 2;
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   klass = mini_get_class (method, token, generic_context);
>   if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (mono_type_to_store_membase (((cfg)), ((&klass->byval_arg)))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->sreg1 = (sp [1]->dreg); ((ins))->dreg = (sp [0]->dreg); ((ins))->data.op[0].const_val = (0); type_to_eval_stack_type (((cfg)), ((&klass->byval_arg)), ((ins))); ((ins))->klass = mono_class_from_mono_type ((&klass->byval_arg)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   if (cfg->gen_write_barriers && cfg->method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER &&
>     generic_class_is_reference_type (cfg, klass)) {
>
>    emit_write_barrier (cfg, sp [0], sp [1], -1);
>   }
>   ins_flag = 0;
>   ip += 5;
>   inline_costs += 1;
>   break;
>
>
>
>
>  case CEE_NEWARR: {
>   MonoInst *len_ins;
>   const char *data_ptr;
>   int data_size = 0;
>   guint32 field_token;
>
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>
>   klass = mini_get_class (method, token, generic_context);
>   if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>
>   if (cfg->generic_sharing_context)
>    context_used = mono_class_check_context_used (klass);
>
>   if (sp [0]->type == STACK_I8 || (8 == 8 && sp [0]->type == STACK_PTR)) {
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_LCONV_TO_I4); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->sreg1 = sp [0]->dreg;
>    ins->type = STACK_I4;
>    ins->dreg = alloc_ireg (cfg);
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>    *sp = mono_decompose_opcode (cfg, ins);
>   }
>
>   if (context_used) {
>    MonoInst *args [3];
>    MonoClass *array_class = mono_array_class_get (klass, 1);
># 9024 "method-to-ir.c"
>    MonoMethod *managed_alloc = ((void *)0);
>
>
>
>
>    args [0] = emit_get_rgctx_klass (cfg, context_used,
>     array_class, MONO_RGCTX_INFO_VTABLE);
>
>    args [1] = sp [0];
>
>    if (managed_alloc)
>     ins = mono_emit_method_call (cfg, managed_alloc, args, ((void *)0));
>    else
>     ins = mono_emit_jit_icall (cfg, mono_array_new_specific, args);
>   } else {
>    if (cfg->opt & MONO_OPT_SHARED) {
>
>     MonoInst *iargs [3];
>
>     do { do { if (((cfg)->opt & MONO_OPT_SHARED) || (cfg)->compile_aot) { MonoInst* __domain_var = mono_get_domainvar ((cfg)); do { do { ((((iargs [0])))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((iargs [0]))))->data.op[0].const_val = ((((iargs [0]))))->data.op[1].const_val = 0; ((((iargs [0]))))->next = ((((iargs [0]))))->prev = ((void *)0); ((((iargs [0]))))->opcode = (OP_MOVE); ((((iargs [0]))))->flags = 0; ((((iargs [0]))))->type = 0; ((((iargs [0]))))->dreg = -1; do { (((((iargs [0])))))->sreg1 = (((((iargs [0])))))->sreg2 = (((((iargs [0])))))->sreg3 = -1; } while (0); ((((iargs [0]))))->cil_code = ((((cfg))))->ip; } while (0); (((iargs [0])))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype), (((iargs [0])))); (((iargs [0])))->klass = ((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->klass; (((iargs [0])))->sreg1 = ((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->dreg; (((iargs [0])))->dreg = alloc_dreg ((((cfg))), (((iargs [0])))->type); if ((((iargs [0])))->opcode == OP_VMOVE) (((iargs [0])))->klass = mono_class_from_mono_type ((((cfg))->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); } while (0); } else { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_I8CONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].p = (((cfg))->domain); ((iargs [0]))->type = STACK_PTR; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>     do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].p = ((klass)); ((iargs [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_CLASS); ((iargs [1]))->type = STACK_PTR; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>     iargs [2] = sp [0];
>
>     ins = mono_emit_jit_icall (cfg, mono_array_new, iargs);
>    } else {
>
>     MonoClass *array_type = mono_array_class_get (klass, 1);
>     mono_class_vtable (cfg->domain, array_type);
>     if (!(array_type) || (array_type)->exception_type) {cfg->exception_ptr = array_type; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>
>     do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_NEWARR); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>     ins->dreg = alloc_ireg_ref (cfg);
>     ins->sreg1 = sp [0]->dreg;
>     ins->data.op[1].klass = klass;
>     ins->type = STACK_OBJ;
>     ins->klass = klass;
>     do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>     cfg->flags |= MONO_CFG_HAS_ARRAY_ACCESS;
>     cfg->cbb->has_array_access = 1;
>
>
>     mono_get_got_var (cfg);
>    }
>   }
>
>   len_ins = sp [0];
>   ip += 5;
>   *sp++ = ins;
>   inline_costs += 1;
>
>
>
>
>
>
>
>   if ((cfg->opt & MONO_OPT_INTRINS) && ip + 6 < end && ip_in_bb (cfg, bblock, ip + 6) && (len_ins->opcode == OP_ICONST) && (data_ptr = initialize_array_data (method, cfg->compile_aot, ip, klass, len_ins->data.op[0].const_val, &data_size, &field_token))) {
>    MonoMethod *memcpy_method = get_memcpy_method ();
>    MonoInst *iargs [3];
>    int add_reg = alloc_ireg_mp (cfg);
>
>    do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (((OP_LADD_IMM))); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->dreg = (add_reg); ((iargs [0]))->sreg1 = (ins->dreg); ((iargs [0]))->data.op[1].const_val = ((__builtin_offsetof (MonoArray, vector))); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>    if (cfg->compile_aot) {
>     do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = (OP_AOTCONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].p = mono_jump_info_token_new2 (((cfg))->mempool, ((method->klass->image)), ((((guint)(long) (field_token)))), (((void *)0))); ((iargs [1]))->data.op[1].p = (gpointer)((MONO_PATCH_INFO_RVA)); ((iargs [1]))->type = ((STACK_PTR)); ((iargs [1]))->klass = ((((void *)0))); ((iargs [1]))->dreg = alloc_dreg (((cfg)), ((STACK_PTR))); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>    } else {
>     do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = (OP_I8CONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].p = (((char*)data_ptr)); ((iargs [1]))->type = STACK_PTR; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>    }
>    do { do { do { (((iargs [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [2])))->data.op[0].const_val = (((iargs [2])))->data.op[1].const_val = 0; (((iargs [2])))->next = (((iargs [2])))->prev = ((void *)0); (((iargs [2])))->opcode = (OP_ICONST); (((iargs [2])))->flags = 0; (((iargs [2])))->type = 0; (((iargs [2])))->dreg = -1; do { ((((iargs [2]))))->sreg1 = ((((iargs [2]))))->sreg2 = ((((iargs [2]))))->sreg3 = -1; } while (0); (((iargs [2])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [2]))->data.op[0].const_val = ((data_size)); ((iargs [2]))->type = STACK_I4; ((iargs [2]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [2])); ((iargs [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [2])); } } while (0); } while (0);
>    mono_emit_method_call (cfg, memcpy_method, iargs, ((void *)0));
>    ip += 11;
>   }
>
>   break;
>  }
>  case CEE_LDLEN:
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>   if (sp [0]->type != STACK_OBJ)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_LDLEN); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ins->dreg = alloc_preg (cfg);
>   ins->sreg1 = sp [0]->dreg;
>   ins->type = STACK_I4;
>
>   ins->flags |= MONO_INST_FAULT;
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>   cfg->flags |= MONO_CFG_HAS_ARRAY_ACCESS;
>   cfg->cbb->has_array_access = 1;
>   ip ++;
>   *sp++ = ins;
>   break;
>  case CEE_LDELEMA:
>   if ((sp - stack_start) < (2)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   sp -= 2;
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   if (sp [0]->type != STACK_OBJ)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   cfg->flags |= MONO_CFG_HAS_LDELEMA;
>
>   klass = mini_get_class (method, (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) )), generic_context);
>   if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>
>
>
>
>   if (!klass->valuetype && method->wrapper_type == MONO_WRAPPER_NONE && !readonly) {
>    MonoClass *array_class = mono_array_class_get (klass, 1);
>    mini_emit_check_array_type (cfg, sp [0], array_class);
>    if (!(array_class) || (array_class)->exception_type) {cfg->exception_ptr = array_class; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>   }
>
>   readonly = 0;
>   ins = mini_emit_ldelema_1_ins (cfg, klass, sp [0], sp [1], 1);
>   *sp++ = ins;
>   ip += 5;
>   break;
>  case CEE_LDELEM:
>  case CEE_LDELEM_I1:
>  case CEE_LDELEM_U1:
>  case CEE_LDELEM_I2:
>  case CEE_LDELEM_U2:
>  case CEE_LDELEM_I4:
>  case CEE_LDELEM_U4:
>  case CEE_LDELEM_I8:
>  case CEE_LDELEM_I:
>  case CEE_LDELEM_R4:
>  case CEE_LDELEM_R8:
>  case CEE_LDELEM_REF: {
>   MonoInst *addr;
>
>   if ((sp - stack_start) < (2)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   sp -= 2;
>
>   if (*ip == CEE_LDELEM) {
>    if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>    klass = mini_get_class (method, token, generic_context);
>    if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>    mono_class_init (klass);
>   }
>   else
>    klass = array_access_to_klass (*ip);
>
>   if (sp [0]->type != STACK_OBJ)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   cfg->flags |= MONO_CFG_HAS_LDELEMA;
>
>   if (sp [1]->opcode == OP_ICONST) {
>    int array_reg = sp [0]->dreg;
>    int index_reg = sp [1]->dreg;
>    int offset = (mono_class_array_element_size (klass) * sp [1]->data.op[0].const_val) + __builtin_offsetof (MonoArray, vector);
>
>    do { if (!(cfg->opt & MONO_OPT_UNSAFE)) { if (!(cfg->opt & MONO_OPT_ABCREM)) { do { if (cfg->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (array_reg); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((0)) do { int _length_reg = alloc_ireg ((cfg)); if (1) do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((array_reg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = ((((OP_LOADI4_MEMBASE)))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = (((((cfg)))))->ip; } while (0); ((inst))->dreg = (((_length_reg))); ((inst))->sreg1 = ((((array_reg)))); ((inst))->data.op[0].const_val = (((__builtin_offsetof (MonoArray, max_length)))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); else do { MonoInst *inst; int __ins_flags = MONO_INST_CONSTANT_LOAD; if (__ins_flags & MONO_INST_FAULT) { do { if (((cfg))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (((array_reg))); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((((cfg)))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((((cfg)))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((((cfg)))))->cbb)->last_ins) { ((((((cfg)))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((((cfg)))))->cbb)->last_ins; ((((((cfg)))))->cbb)->last_ins = (((inst))); } else { ((((((cfg)))))->cbb)->code = ((((((cfg)))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((cfg)->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = (((OP_LOADI4_MEMBASE))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = ((((cfg))))->ip; } while (0); ((inst))->dreg = ((_length_reg)); ((inst))->sreg1 = (((array_reg))); ((inst))->data.op[0].const_val = ((__builtin_offsetof (MonoArray, max_length))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = -1; inst->sreg1 = _length_reg; inst->sreg2 = (index_reg); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_LE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->data.op[1].p = (char*)"IndexOutOfRangeException"; do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); } while (0); else do { int _length_reg = alloc_ireg (((cfg))); if (1) do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if (((((cfg))))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((((cfg))))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((((cfg))))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (((((array_reg))))); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((((cfg))))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((((cfg))))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((((((cfg)))))->cbb)->last_ins) { ((((((cfg)))))->cbb)->last_ins->next = (inst); (inst)->prev = ((((((cfg)))))->cbb)->last_ins; ((((((cfg)))))->cbb)->last_ins = (inst); } else { ((((((cfg)))))->cbb)->code = ((((((cfg)))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((((((cfg)))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((((((cfg)))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((((((cfg)))))))->cbb)->last_ins) { ((((((((cfg)))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((((((cfg)))))))->cbb)->last_ins; ((((((((cfg)))))))->cbb)->last_ins = (((inst))); } else { ((((((((cfg)))))))->cbb)->code = ((((((((cfg)))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((((cfg)))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc (((((((cfg))))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = ((((OP_LOADI4_MEMBASE)))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = ((((((cfg))))))->ip; } while (0); ((inst))->dreg = (((_length_reg))); ((inst))->sreg1 = (((((array_reg))))); ((inst))->data.op[0].const_val = ((((__builtin_offsetof (MonoArray, max_length))))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); else do { MonoInst *inst; int __ins_flags = MONO_INST_CONSTANT_LOAD; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((array_reg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = (((OP_LOADI4_MEMBASE))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = (((((cfg)))))->ip; } while (0); ((inst))->dreg = ((_length_reg)); ((inst))->sreg1 = ((((array_reg)))); ((inst))->data.op[0].const_val = (((__builtin_offsetof (MonoArray, max_length)))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = _length_reg; inst->sreg2 = ((index_reg)); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_LE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->data.op[1].p = (char*)"IndexOutOfRangeException"; do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); } while (0); } else { MonoInst *ins; do { (ins) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BOUNDS_CHECK); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = ((cfg))->ip; } while (0); ins->sreg1 = array_reg; ins->sreg2 = index_reg; ins->data.op[1].const_val = __builtin_offsetof (MonoArray, max_length); ins->flags |= MONO_INST_FAULT; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); (cfg)->flags |= MONO_CFG_HAS_ARRAY_ACCESS; (cfg)->cbb->has_array_access = 1; } } } while (0);
>    do { do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = ((mono_type_to_load_membase (((cfg)), ((&klass->byval_arg))))); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->dreg = (0); (((ins)))->sreg1 = (((array_reg))); (((ins)))->data.op[0].const_val = (((offset))); (((ins)))->type = STACK_I4; } while (0); type_to_eval_stack_type (((cfg)), ((&klass->byval_arg)), ((ins))); ((ins))->dreg = alloc_dreg (((cfg)), ((ins))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   } else {
>    addr = mini_emit_ldelema_1_ins (cfg, klass, sp [0], sp [1], 1);
>    do { do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = ((mono_type_to_load_membase (((cfg)), ((&klass->byval_arg))))); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->dreg = (0); (((ins)))->sreg1 = (((addr->dreg))); (((ins)))->data.op[0].const_val = (((0))); (((ins)))->type = STACK_I4; } while (0); type_to_eval_stack_type (((cfg)), ((&klass->byval_arg)), ((ins))); ((ins))->dreg = alloc_dreg (((cfg)), ((ins))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   }
>   *sp++ = ins;
>   if (*ip == CEE_LDELEM)
>    ip += 5;
>   else
>    ++ip;
>   break;
>  }
>  case CEE_STELEM_I:
>  case CEE_STELEM_I1:
>  case CEE_STELEM_I2:
>  case CEE_STELEM_I4:
>  case CEE_STELEM_I8:
>  case CEE_STELEM_R4:
>  case CEE_STELEM_R8:
>  case CEE_STELEM_REF:
>  case CEE_STELEM: {
>   MonoInst *addr;
>
>   if ((sp - stack_start) < (3)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   sp -= 3;
>
>   cfg->flags |= MONO_CFG_HAS_LDELEMA;
>
>   if (*ip == CEE_STELEM) {
>    if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>    klass = mini_get_class (method, token, generic_context);
>    if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>    mono_class_init (klass);
>   }
>   else
>    klass = array_access_to_klass (*ip);
>
>   if (sp [0]->type != STACK_OBJ)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>
>   if (generic_class_is_reference_type (cfg, klass) &&
>    !(sp [2]->opcode == OP_I8CONST && sp [2]->data.op[0].p == ((void *)0))) {
>    MonoClass *obj_array = ({ static MonoClass *tmp_klass; if (!tmp_klass) { tmp_klass = mono_array_class_get ((mono_defaults.object_class), (1)); do { if (!(tmp_klass)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9224, "tmp_klass"); } while (0); }; tmp_klass; });
>    MonoMethod *helper = mono_marshal_get_virtual_stelemref (obj_array);
>    MonoInst *iargs [3];
>
>    if (!helper->slot)
>     mono_class_setup_vtable (obj_array);
>    do { if (!(helper->slot)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9230, "helper->slot"); } while (0);
>
>    if (sp [0]->type != STACK_OBJ)
>     do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (sp [2]->type != STACK_OBJ)
>     do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>    iargs [2] = sp [2];
>    iargs [1] = sp [1];
>    iargs [0] = sp [0];
>
>    mono_emit_method_call (cfg, helper, iargs, sp [0]);
>   } else {
>    if (sp [1]->opcode == OP_ICONST) {
>     int array_reg = sp [0]->dreg;
>     int index_reg = sp [1]->dreg;
>     int offset = (mono_class_array_element_size (klass) * sp [1]->data.op[0].const_val) + __builtin_offsetof (MonoArray, vector);
>
>     do { if (!(cfg->opt & MONO_OPT_UNSAFE)) { if (!(cfg->opt & MONO_OPT_ABCREM)) { do { if (cfg->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (array_reg); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((cfg)))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (((inst))); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((0)) do { int _length_reg = alloc_ireg ((cfg)); if (1) do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((array_reg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = ((((OP_LOADI4_MEMBASE)))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = (((((cfg)))))->ip; } while (0); ((inst))->dreg = (((_length_reg))); ((inst))->sreg1 = ((((array_reg)))); ((inst))->data.op[0].const_val = (((__builtin_offsetof (MonoArray, max_length)))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); else do { MonoInst *inst; int __ins_flags = MONO_INST_CONSTANT_LOAD; if (__ins_flags & MONO_INST_FAULT) { do { if (((cfg))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (((array_reg))); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((((cfg)))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((((cfg)))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((((cfg)))))->cbb)->last_ins) { ((((((cfg)))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((((cfg)))))->cbb)->last_ins; ((((((cfg)))))->cbb)->last_ins = (((inst))); } else { ((((((cfg)))))->cbb)->code = ((((((cfg)))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((cfg)->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = (((OP_LOADI4_MEMBASE))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = ((((cfg))))->ip; } while (0); ((inst))->dreg = ((_length_reg)); ((inst))->sreg1 = (((array_reg))); ((inst))->data.op[0].const_val = ((__builtin_offsetof (MonoArray, max_length))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = -1; inst->sreg1 = _length_reg; inst->sreg2 = (index_reg); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_LE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->data.op[1].p = (char*)"IndexOutOfRangeException"; do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); } while (0); else do { int _length_reg = alloc_ireg (((cfg))); if (1) do { MonoInst *inst; int __ins_flags = MONO_INST_FAULT; if (__ins_flags & MONO_INST_FAULT) { do { if (((((cfg))))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((((cfg))))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((((cfg))))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = (((((array_reg))))); inst->data.op[1].const_val = (mgreg_t)(0); do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((((cfg))))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((((cfg))))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if (((((((cfg)))))->cbb)->last_ins) { ((((((cfg)))))->cbb)->last_ins->next = (inst); (inst)->prev = ((((((cfg)))))->cbb)->last_ins; ((((((cfg)))))->cbb)->last_ins = (inst); } else { ((((((cfg)))))->cbb)->code = ((((((cfg)))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc ((((((((((cfg)))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = (((((((((cfg)))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if (((((((((cfg)))))))->cbb)->last_ins) { ((((((((cfg)))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = ((((((((cfg)))))))->cbb)->last_ins; ((((((((cfg)))))))->cbb)->last_ins = (((inst))); } else { ((((((((cfg)))))))->cbb)->code = ((((((((cfg)))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if ((((cfg)))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc (((((((cfg))))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = ((((OP_LOADI4_MEMBASE)))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = ((((((cfg))))))->ip; } while (0); ((inst))->dreg = (((_length_reg))); ((inst))->sreg1 = (((((array_reg))))); ((inst))->data.op[0].const_val = ((((__builtin_offsetof (MonoArray, max_length))))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); else do { MonoInst *inst; int __ins_flags = MONO_INST_CONSTANT_LOAD; if (__ins_flags & MONO_INST_FAULT) { do { if ((((cfg)))->explicit_null_checks) { do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = ((((array_reg)))); inst->data.op[1].const_val = (mgreg_t)(0); do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((((cfg)))))->ip; } while (0); inst->data.op[1].p = (char*)"NullReferenceException"; do { if ((((((cfg))))->cbb)->last_ins) { (((((cfg))))->cbb)->last_ins->next = (inst); (inst)->prev = (((((cfg))))->cbb)->last_ins; (((((cfg))))->cbb)->last_ins = (inst); } else { (((((cfg))))->cbb)->code = (((((cfg))))->cbb)->last_ins = (inst); } } while (0); } while (0); } else { do { if ((0) && !0) do { if ((0)) { do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((((((cfg))))))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_IMPLICIT_EXCEPTION)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((((((cfg))))))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((-1)); } while (0); do { if ((((((((cfg))))))->cbb)->last_ins) { (((((((cfg))))))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((((((cfg))))))->cbb)->last_ins; (((((((cfg))))))->cbb)->last_ins = (((inst))); } else { (((((((cfg))))))->cbb)->code = (((((((cfg))))))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0); } } while (0); } while (0); } } while (0); if (((cfg))->explicit_null_checks) __ins_flags &= ~MONO_INST_FAULT; } do { do { (((inst))) = mono_mempool_alloc ((((((cfg)))))->mempool, sizeof (MonoInst)); (((inst)))->data.op[0].const_val = (((inst)))->data.op[1].const_val = 0; (((inst)))->next = (((inst)))->prev = ((void *)0); (((inst)))->opcode = (((OP_LOADI4_MEMBASE))); (((inst)))->flags = 0; (((inst)))->type = 0; (((inst)))->dreg = -1; do { ((((inst))))->sreg1 = ((((inst))))->sreg2 = ((((inst))))->sreg3 = -1; } while (0); (((inst)))->cil_code = (((((cfg)))))->ip; } while (0); ((inst))->dreg = ((_length_reg)); ((inst))->sreg1 = ((((array_reg)))); ((inst))->data.op[0].const_val = (((__builtin_offsetof (MonoArray, max_length)))); ((inst))->type = STACK_I4; } while (0); inst->flags = (__ins_flags); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->dreg = -1; inst->sreg1 = _length_reg; inst->sreg2 = ((index_reg)); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (inst); (inst)->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (inst); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (inst); } } while (0); } while (0); do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_LE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((((cfg))))->ip; } while (0); inst->data.op[1].p = (char*)"IndexOutOfRangeException"; do { if (((((cfg)))->cbb)->last_ins) { ((((cfg)))->cbb)->last_ins->next = (inst); (inst)->prev = ((((cfg)))->cbb)->last_ins; ((((cfg)))->cbb)->last_ins = (inst); } else { ((((cfg)))->cbb)->code = ((((cfg)))->cbb)->last_ins = (inst); } } while (0); } while (0); } while (0); } else { MonoInst *ins; do { (ins) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BOUNDS_CHECK); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = ((cfg))->ip; } while (0); ins->sreg1 = array_reg; ins->sreg2 = index_reg; ins->data.op[1].const_val = __builtin_offsetof (MonoArray, max_length); ins->flags |= MONO_INST_FAULT; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); (cfg)->flags |= MONO_CFG_HAS_ARRAY_ACCESS; (cfg)->cbb->has_array_access = 1; } } } while (0);
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (mono_type_to_store_membase (((cfg)), ((&klass->byval_arg)))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->sreg1 = (sp [2]->dreg); ((ins))->dreg = (array_reg); ((ins))->data.op[0].const_val = (offset); type_to_eval_stack_type (((cfg)), ((&klass->byval_arg)), ((ins))); ((ins))->klass = mono_class_from_mono_type ((&klass->byval_arg)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    } else {
>     addr = mini_emit_ldelema_1_ins (cfg, klass, sp [0], sp [1], 1);
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (mono_type_to_store_membase (((cfg)), ((&klass->byval_arg)))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->sreg1 = (sp [2]->dreg); ((ins))->dreg = (addr->dreg); ((ins))->data.op[0].const_val = (0); type_to_eval_stack_type (((cfg)), ((&klass->byval_arg)), ((ins))); ((ins))->klass = mono_class_from_mono_type ((&klass->byval_arg)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    }
>   }
>
>   if (*ip == CEE_STELEM)
>    ip += 5;
>   else
>    ++ip;
>   inline_costs += 1;
>   break;
>  }
>  case CEE_CKFINITE: {
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   --sp;
>
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_CKFINITE); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   ins->sreg1 = sp [0]->dreg;
>   ins->dreg = alloc_freg (cfg);
>   ins->type = STACK_R8;
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>
>   *sp++ = mono_decompose_opcode (cfg, ins);
>
>   ++ip;
>   break;
>  }
>  case CEE_REFANYVAL: {
>   MonoInst *src_var, *src;
>
>   int klass_reg = alloc_preg (cfg);
>   int dreg = alloc_preg (cfg);
>
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (*ip); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   --sp;
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   klass = mono_class_get_full (image, (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) )), generic_context);
>   if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>   mono_class_init (klass);
>
>   if (cfg->generic_sharing_context)
>    context_used = mono_class_check_context_used (klass);
>
>
>   src_var = ((sp [0]->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(sp [0]->dreg)] : ((void *)0));
>   if (!src_var)
>    src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
>   do { do { do { (((src))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((src)))->data.op[0].const_val = (((src)))->data.op[1].const_val = 0; (((src)))->next = (((src)))->prev = ((void *)0); (((src)))->opcode = (OP_LDADDR); (((src)))->flags = 0; (((src)))->type = 0; (((src)))->dreg = -1; do { ((((src))))->sreg1 = ((((src))))->sreg2 = ((((src))))->sreg3 = -1; } while (0); (((src)))->cil_code = (((cfg)))->ip; } while (0); ((src))->data.op[0].p = ((src_var)); ((src_var))->flags |= MONO_INST_INDIRECT; ((src))->type = STACK_MP; ((src))->klass = ((src_var))->klass; ((src))->dreg = alloc_dreg (((cfg)), STACK_MP); if (8 == 4 && ((((src_var))->type) == STACK_I8)) { MonoInst *var1 = ((((src_var))->dreg + 1) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [(((src_var))->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((src_var))->dreg + 2) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [(((src_var))->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9299, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9299, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((src)); ((src))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((src)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((src)); } } while (0); } while (0);
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (((OP_LOAD_MEMBASE))); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = (((cfg)))->ip; } while (0); inst->dreg = (klass_reg); inst->sreg1 = (src->dreg); inst->data.op[0].const_val = (__builtin_offsetof (MonoTypedRef, klass)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>   if (context_used) {
>    MonoInst *klass_ins;
>
>    klass_ins = emit_get_rgctx_klass (cfg, context_used,
>      klass, MONO_RGCTX_INFO_KLASS);
>
>
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = klass_reg; inst->sreg2 = klass_ins->dreg; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_NE_UN)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"InvalidCastException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   } else {
>    mini_emit_class_check (cfg, klass_reg, klass);
>   }
>   do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_LOAD_MEMBASE))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = ((dreg)); ((ins))->sreg1 = ((src->dreg)); ((ins))->data.op[0].const_val = ((__builtin_offsetof (MonoTypedRef, value))); ((ins))->type = STACK_I4; } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ins->type = STACK_MP;
>   *sp++ = ins;
>   ip += 5;
>   break;
>  }
>  case CEE_MKREFANY: {
>   MonoInst *loc, *addr;
>
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (*ip); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   --sp;
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   klass = mono_class_get_full (image, (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) )), generic_context);
>   if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>   mono_class_init (klass);
>
>   if (cfg->generic_sharing_context)
>    context_used = mono_class_check_context_used (klass);
>
>   loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
>   do { do { do { ((((addr)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((addr))))->data.op[0].const_val = ((((addr))))->data.op[1].const_val = 0; ((((addr))))->next = ((((addr))))->prev = ((void *)0); ((((addr))))->opcode = (OP_LDADDR); ((((addr))))->flags = 0; ((((addr))))->type = 0; ((((addr))))->dreg = -1; do { (((((addr)))))->sreg1 = (((((addr)))))->sreg2 = (((((addr)))))->sreg3 = -1; } while (0); ((((addr))))->cil_code = ((((cfg))))->ip; } while (0); (((addr)))->data.op[0].p = ((cfg)->varinfo [((loc->data.op[0].const_val))]); ((cfg)->varinfo [((loc->data.op[0].const_val))])->flags |= MONO_INST_INDIRECT; (((addr)))->type = STACK_MP; (((addr)))->klass = ((cfg)->varinfo [((loc->data.op[0].const_val))])->klass; (((addr)))->dreg = alloc_dreg ((((cfg))), STACK_MP); if (8 == 4 && ((((cfg)->varinfo [((loc->data.op[0].const_val))])->type) == STACK_I8)) { MonoInst *var1 = ((((cfg)->varinfo [((loc->data.op[0].const_val))])->dreg + 1) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((loc->data.op[0].const_val))])->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((cfg)->varinfo [((loc->data.op[0].const_val))])->dreg + 2) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((loc->data.op[0].const_val))])->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9335, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9335, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((addr)); ((addr))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((addr)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((addr)); } } while (0); } while (0);
>
>   if (context_used) {
>    MonoInst *const_ins;
>    int type_reg = alloc_preg (cfg);
>
>    const_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI8_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = const_ins->dreg; (inst)->dreg = addr->dreg; (inst)->data.op[0].const_val = __builtin_offsetof (MonoTypedRef, klass); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_ADD_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = type_reg; inst->sreg1 = const_ins->dreg; inst->data.op[1].const_val = (mgreg_t)(__builtin_offsetof (MonoClass, byval_arg)); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI8_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = type_reg; (inst)->dreg = addr->dreg; (inst)->data.op[0].const_val = __builtin_offsetof (MonoTypedRef, type); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   } else if (cfg->compile_aot) {
>    int const_reg = alloc_preg (cfg);
>    int type_reg = alloc_preg (cfg);
>
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_AOTCONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = const_reg; inst->data.op[0].p = klass; inst->data.op[1].const_val = MONO_PATCH_INFO_CLASS; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI8_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = const_reg; (inst)->dreg = addr->dreg; (inst)->data.op[0].const_val = __builtin_offsetof (MonoTypedRef, klass); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_ADD_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = type_reg; inst->sreg1 = const_reg; inst->data.op[1].const_val = (mgreg_t)(__builtin_offsetof (MonoClass, byval_arg)); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI8_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = type_reg; (inst)->dreg = addr->dreg; (inst)->data.op[0].const_val = __builtin_offsetof (MonoTypedRef, type); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>   } else {
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI8_MEMBASE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = addr->dreg; inst->data.op[0].const_val = __builtin_offsetof (MonoTypedRef, type); inst->data.op[1].const_val = (mgreg_t)(&klass->byval_arg); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI8_MEMBASE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = addr->dreg; inst->data.op[0].const_val = __builtin_offsetof (MonoTypedRef, klass); inst->data.op[1].const_val = (mgreg_t)(klass); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   }
>   do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STOREI8_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = sp [0]->dreg; (inst)->dreg = addr->dreg; (inst)->data.op[0].const_val = __builtin_offsetof (MonoTypedRef, value); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>   do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((loc->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((loc->data.op[0].const_val))]->data.op[1].vtype), (((ins)))); (((ins)))->klass = ((cfg))->varinfo [((loc->data.op[0].const_val))]->klass; (((ins)))->sreg1 = ((cfg))->varinfo [((loc->data.op[0].const_val))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((loc->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   ins->type = STACK_VTYPE;
>   ins->klass = mono_defaults.typed_reference_class;
>   *sp++ = ins;
>   ip += 5;
>   break;
>  }
>  case CEE_LDTOKEN: {
>   gpointer handle;
>   MonoClass *handle_class;
>
>   if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   n = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>
>   if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD ||
>     method->wrapper_type == MONO_WRAPPER_SYNCHRONIZED) {
>    handle = mono_method_get_wrapper_data (method, n);
>    handle_class = mono_method_get_wrapper_data (method, n + 1);
>    if (handle_class == mono_defaults.typehandle_class)
>     handle = &((MonoClass*)handle)->byval_arg;
>   }
>   else {
>    handle = mono_ldtoken (image, n, &handle_class, generic_context);
>   }
>   if (!handle)
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>   mono_class_init (handle_class);
>   if (cfg->generic_sharing_context) {
>    if (((n) >> 24) == MONO_TABLE_TYPEDEF ||
>      ((n) >> 24) == MONO_TABLE_TYPEREF) {
>
>
>
>     context_used = 0;
>    } else if (handle_class == mono_defaults.typehandle_class) {
>
>
>
>
>     if (mono_type_get_type (handle) == MONO_TYPE_CLASS)
>      context_used = 0;
>     else
>      context_used = mono_class_check_context_used (mono_class_from_mono_type (handle));
>    } else if (handle_class == mono_defaults.fieldhandle_class)
>     context_used = mono_class_check_context_used (((MonoClassField*)handle)->parent);
>    else if (handle_class == mono_defaults.methodhandle_class)
>     context_used = mono_method_check_context_used (handle);
>    else
>     do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 9409); } while (0);
>   }
>
>   if ((cfg->opt & MONO_OPT_SHARED) &&
>     method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD &&
>     method->wrapper_type != MONO_WRAPPER_SYNCHRONIZED) {
>    MonoInst *addr, *vtvar, *iargs [3];
>    int method_context_used;
>
>    if (cfg->generic_sharing_context)
>     method_context_used = mono_method_check_context_used (method);
>    else
>     method_context_used = 0;
>
>    vtvar = mono_compile_create_var (cfg, &handle_class->byval_arg, OP_LOCAL);
>
>    do { do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->data.op[0].p = ((image)); ((iargs [0]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_IMAGE); ((iargs [0]))->type = STACK_PTR; ((iargs [0]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [0])); ((iargs [0]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [0])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [0])); } } while (0); } while (0);
>    do { do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = (OP_ICONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].const_val = ((n)); ((iargs [1]))->type = STACK_I4; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [1])); ((iargs [1]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [1])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [1])); } } while (0); } while (0);
>    if (method_context_used) {
>     iargs [2] = emit_get_rgctx_method (cfg, method_context_used,
>      method, MONO_RGCTX_INFO_METHOD);
>     ins = mono_emit_jit_icall (cfg, mono_ldtoken_wrapper_generic_shared, iargs);
>    } else {
>     do { do { do { (((iargs [2]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [2])))->data.op[0].const_val = (((iargs [2])))->data.op[1].const_val = 0; (((iargs [2])))->next = (((iargs [2])))->prev = ((void *)0); (((iargs [2])))->opcode = (OP_I8CONST); (((iargs [2])))->flags = 0; (((iargs [2])))->type = 0; (((iargs [2])))->dreg = -1; do { ((((iargs [2]))))->sreg1 = ((((iargs [2]))))->sreg2 = ((((iargs [2]))))->sreg3 = -1; } while (0); (((iargs [2])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [2]))->data.op[0].p = ((generic_context)); ((iargs [2]))->type = STACK_PTR; ((iargs [2]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((iargs [2])); ((iargs [2]))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((iargs [2])); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((iargs [2])); } } while (0); } while (0);
>     ins = mono_emit_jit_icall (cfg, mono_ldtoken_wrapper, iargs);
>    }
>    do { do { do { ((((addr)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((addr))))->data.op[0].const_val = ((((addr))))->data.op[1].const_val = 0; ((((addr))))->next = ((((addr))))->prev = ((void *)0); ((((addr))))->opcode = (OP_LDADDR); ((((addr))))->flags = 0; ((((addr))))->type = 0; ((((addr))))->dreg = -1; do { (((((addr)))))->sreg1 = (((((addr)))))->sreg2 = (((((addr)))))->sreg3 = -1; } while (0); ((((addr))))->cil_code = ((((cfg))))->ip; } while (0); (((addr)))->data.op[0].p = ((cfg)->varinfo [((vtvar->data.op[0].const_val))]); ((cfg)->varinfo [((vtvar->data.op[0].const_val))])->flags |= MONO_INST_INDIRECT; (((addr)))->type = STACK_MP; (((addr)))->klass = ((cfg)->varinfo [((vtvar->data.op[0].const_val))])->klass; (((addr)))->dreg = alloc_dreg ((((cfg))), STACK_MP); if (8 == 4 && ((((cfg)->varinfo [((vtvar->data.op[0].const_val))])->type) == STACK_I8)) { MonoInst *var1 = ((((cfg)->varinfo [((vtvar->data.op[0].const_val))])->dreg + 1) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((vtvar->data.op[0].const_val))])->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((cfg)->varinfo [((vtvar->data.op[0].const_val))])->dreg + 2) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((vtvar->data.op[0].const_val))])->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9435, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9435, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((addr)); ((addr))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((addr)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((addr)); } } while (0); } while (0);
>
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STORE_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = ins->dreg; (inst)->dreg = addr->dreg; (inst)->data.op[0].const_val = 0; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>
>    do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((vtvar->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((vtvar->data.op[0].const_val))]->data.op[1].vtype), (((ins)))); (((ins)))->klass = ((cfg))->varinfo [((vtvar->data.op[0].const_val))]->klass; (((ins)))->sreg1 = ((cfg))->varinfo [((vtvar->data.op[0].const_val))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((vtvar->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>   } else {
>    if ((ip + 5 < end) && ip_in_bb (cfg, bblock, ip + 5) &&
>     ((ip [5] == CEE_CALL) || (ip [5] == CEE_CALLVIRT)) &&
>     (cmethod = mini_get_method (cfg, method, (((guint32) ( (((guint32) (*((const guint32 *) (ip + 6)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 6)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 6)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 6)))) >> 24)) )), ((void *)0), generic_context)) &&
>     (cmethod->klass == mono_defaults.monotype_class->parent) &&
>     (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (cmethod->name) && __builtin_constant_p ("GetTypeFromHandle") && (__s1_len = __strlen_g ((cmethod->name)), __s2_len = __strlen_g (("GetTypeFromHandle")), (!((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("GetTypeFromHandle") + 1) - (size_t)(const void *)("GetTypeFromHandle") == 1) || __s2_len >= 4)) ? __builtin_strcmp (cmethod->name, "GetTypeFromHandle") : (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) && (__s1_len = __strlen_g ((cmethod->name)), __s1_len < 4) ? (__builtin_constant_p ("GetTypeFromHandle") && ((size_t)(const void *)(("GetTypeFromHandle") + 1) - (size_t)(const void *)("GetTypeFromHandle") == 1) ? __builtin_strcmp (cmethod->name, "GetTypeFromHandle") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("GetTypeFromHandle"); int __result = (((const unsigned char *) (const char *) (cmethod->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (cmethod->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (cmethod->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("GetTypeFromHandle") && ((size_t)(const void *)(("GetTypeFromHandle") + 1) - (size_t)(const void *)("GetTypeFromHandle") == 1) && (__s2_len = __strlen_g (("GetTypeFromHandle")), __s2_len < 4) ? (__builtin_constant_p (cmethod->name) && ((size_t)(const void *)((cmethod->name) + 1) - (size_t)(const void *)(cmethod->name) == 1) ? __builtin_strcmp (cmethod->name, "GetTypeFromHandle") : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (cmethod->name); int __result = (((const unsigned char *) (const char *) ("GetTypeFromHandle"))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) ("GetTypeFromHandle"))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) ("GetTypeFromHandle"))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) ("GetTypeFromHandle"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (cmethod->name, "GetTypeFromHandle")))); }) == 0)) {
>     MonoClass *tclass = mono_class_from_mono_type (handle);
>
>     mono_class_init (tclass);
>     if (context_used) {
>      ins = emit_get_rgctx_klass (cfg, context_used,
>       tclass, MONO_RGCTX_INFO_REFLECTION_TYPE);
>     } else if (cfg->compile_aot) {
>      if (method->wrapper_type) {
>       if (mono_class_get (tclass->image, tclass->type_token) == tclass && !generic_context) {
>
>        do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_AOTCONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = mono_jump_info_token_new2 (((cfg))->mempool, ((tclass->image)), ((tclass->type_token)), ((generic_context))); ((ins))->data.op[1].p = (gpointer)(MONO_PATCH_INFO_TYPE_FROM_HANDLE); ((ins))->type = (STACK_OBJ); ((ins))->klass = (mono_defaults.monotype_class); ((ins))->dreg = alloc_dreg (((cfg)), (STACK_OBJ)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>       } else {
>
>        cfg->disable_aot = 1;
>        do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((((void *)0))); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>       }
>      } else {
>       do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_AOTCONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = mono_jump_info_token_new2 (((cfg))->mempool, ((image)), ((n)), ((generic_context))); ((ins))->data.op[1].p = (gpointer)(MONO_PATCH_INFO_TYPE_FROM_HANDLE); ((ins))->type = (STACK_OBJ); ((ins))->klass = (mono_defaults.monotype_class); ((ins))->dreg = alloc_dreg (((cfg)), (STACK_OBJ)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>      }
>     } else {
>      do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((mono_type_get_object (cfg->domain, handle))); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     }
>     ins->type = STACK_OBJ;
>     ins->klass = cmethod->klass;
>     ip += 5;
>    } else {
>     MonoInst *addr, *vtvar;
>
>     vtvar = mono_compile_create_var (cfg, &handle_class->byval_arg, OP_LOCAL);
>
>     if (context_used) {
>      if (handle_class == mono_defaults.typehandle_class) {
>       ins = emit_get_rgctx_klass (cfg, context_used,
>         mono_class_from_mono_type (handle),
>         MONO_RGCTX_INFO_TYPE);
>      } else if (handle_class == mono_defaults.methodhandle_class) {
>       ins = emit_get_rgctx_method (cfg, context_used,
>         handle, MONO_RGCTX_INFO_METHOD);
>      } else if (handle_class == mono_defaults.fieldhandle_class) {
>       ins = emit_get_rgctx_field (cfg, context_used,
>         handle, MONO_RGCTX_INFO_CLASS_FIELD);
>      } else {
>       do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 9488); } while (0);
>      }
>     } else if (cfg->compile_aot) {
>      do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_AOTCONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = mono_jump_info_token_new2 (((cfg))->mempool, ((image)), ((n)), (((void *)0))); ((ins))->data.op[1].p = (gpointer)(MONO_PATCH_INFO_LDTOKEN); ((ins))->type = (STACK_PTR); ((ins))->klass = (((void *)0)); ((ins))->dreg = alloc_dreg (((cfg)), (STACK_PTR)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     } else {
>      do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((handle)); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     }
>     do { do { do { ((((addr)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((addr))))->data.op[0].const_val = ((((addr))))->data.op[1].const_val = 0; ((((addr))))->next = ((((addr))))->prev = ((void *)0); ((((addr))))->opcode = (OP_LDADDR); ((((addr))))->flags = 0; ((((addr))))->type = 0; ((((addr))))->dreg = -1; do { (((((addr)))))->sreg1 = (((((addr)))))->sreg2 = (((((addr)))))->sreg3 = -1; } while (0); ((((addr))))->cil_code = ((((cfg))))->ip; } while (0); (((addr)))->data.op[0].p = ((cfg)->varinfo [((vtvar->data.op[0].const_val))]); ((cfg)->varinfo [((vtvar->data.op[0].const_val))])->flags |= MONO_INST_INDIRECT; (((addr)))->type = STACK_MP; (((addr)))->klass = ((cfg)->varinfo [((vtvar->data.op[0].const_val))])->klass; (((addr)))->dreg = alloc_dreg ((((cfg))), STACK_MP); if (8 == 4 && ((((cfg)->varinfo [((vtvar->data.op[0].const_val))])->type) == STACK_I8)) { MonoInst *var1 = ((((cfg)->varinfo [((vtvar->data.op[0].const_val))])->dreg + 1) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((vtvar->data.op[0].const_val))])->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((cfg)->varinfo [((vtvar->data.op[0].const_val))])->dreg + 2) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((vtvar->data.op[0].const_val))])->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9495, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9495, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((addr)); ((addr))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((addr)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((addr)); } } while (0); } while (0);
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STORE_MEMBASE_REG)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); (inst)->sreg1 = ins->dreg; (inst)->dreg = addr->dreg; (inst)->data.op[0].const_val = 0; do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>     do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((vtvar->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((vtvar->data.op[0].const_val))]->data.op[1].vtype), (((ins)))); (((ins)))->klass = ((cfg))->varinfo [((vtvar->data.op[0].const_val))]->klass; (((ins)))->sreg1 = ((cfg))->varinfo [((vtvar->data.op[0].const_val))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((vtvar->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    }
>   }
>
>   *sp++ = ins;
>   ip += 5;
>   break;
>  }
>  case CEE_THROW:
>   if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_THROW); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   --sp;
>   ins->sreg1 = sp [0]->dreg;
>   ip++;
>   bblock->out_of_line = 1;
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_NOT_REACHED); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   sp = stack_start;
>
>   link_bblock (cfg, bblock, end_bblock);
>   start_new_bblock = 1;
>   break;
>  case CEE_ENDFINALLY:
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_ENDFINALLY); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   ip++;
>   start_new_bblock = 1;
>
>
>
>
>
>   while (sp != stack_start) {
>    sp--;
>   }
>   break;
>  case CEE_LEAVE:
>  case CEE_LEAVE_S: {
>   GList *handlers;
>
>   if (*ip == CEE_LEAVE) {
>    if (ip + 5 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    target = ip + 5 + (gint32)(((guint32) ( (((guint32) (*((const guint32 *) (ip + 1)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 1)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 1)))) >> 24)) ));
>   } else {
>    if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    target = ip + 2 + (signed char)(ip [1]);
>   }
>
>
>   while (sp != stack_start) {
>    sp--;
>   }
>
>
>
>
>
>
>
>   for (i = 0; i < header->num_clauses; ++i) {
>    MonoExceptionClause *clause = &header->clauses [i];
>
>
>
>
>
>
>
>    if (((clause)->handler_offset <= (ip - header->code) && (ip - header->code) < ((clause)->handler_offset + (clause)->handler_len)) && (clause->flags == MONO_EXCEPTION_CLAUSE_NONE) && (ip - header->code + ((*ip == CEE_LEAVE) ? 5 : 2)) <= (clause->handler_offset + clause->handler_len) && method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE) {
>     MonoInst *exc_ins;
>     MonoBasicBlock *dont_throw;
>
>
>
>
>
>
>
>     exc_ins = mono_emit_jit_icall (cfg, mono_thread_get_undeniable_exception, ((void *)0));
>
>     do { (dont_throw) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); (dont_throw)->block_num = cfg->num_bblocks++; } while (0);
>
>
>
>
>
>
>
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = exc_ins->dreg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>     do { MonoInst *ins; MonoBasicBlock *falsebb; do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = ((OP_LBEQ)); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); if ((OP_LBEQ) == OP_BR) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[0].target_block = (dont_throw); mono_link_bblock ((cfg), (cfg)->cbb, (dont_throw)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { ins->data.op[1].many_blocks = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); ins->data.op[1].many_blocks[0] = (dont_throw); ins->data.op[1].many_blocks[1] = ((void *)0); mono_link_bblock ((cfg), (cfg)->cbb, (dont_throw)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (ins); (ins)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (ins); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (ins); } } while (0); if (!cfg->enable_extended_bblocks) { do { (falsebb) = mono_mempool_alloc0 (((cfg))->mempool, sizeof (MonoBasicBlock)); (falsebb)->block_num = (cfg)->num_bblocks++; } while (0); ins->data.op[1].many_blocks[1] = falsebb; mono_link_bblock ((cfg), (cfg)->cbb, (falsebb)); do { do { if (((falsebb))->cil_code) { ((cfg))->cil_offset_to_bb [((falsebb))->cil_code - ((cfg))->cil_start] = ((falsebb)); } ((falsebb))->real_offset = ((cfg))->real_offset; } while (0); if ((cfg)->cbb->last_ins && ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !(cfg)->cbb->last_ins->data.op[1].many_blocks[1]) { (cfg)->cbb->last_ins->data.op[1].many_blocks[1] = (falsebb); mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); } else if (! ((cfg)->cbb->last_ins && (((cfg)->cbb->last_ins->opcode == OP_BR) || ((cfg)->cbb->last_ins->opcode == OP_BR_REG) || ((((cfg)->cbb->last_ins)->opcode >= OP_LBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_LBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_FBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_FBLT_UN) || (((cfg)->cbb->last_ins)->opcode >= OP_IBEQ && ((cfg)->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock (((cfg)), ((cfg))->cbb, (falsebb)); ((cfg))->cbb->next_bb = (falsebb); ((cfg))->cbb = (falsebb); } while (0); } else { cfg->cbb->extended = 1; } } } while (0);
>     do { MonoInst *inst; do { do { do { ((((inst)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((inst))))->data.op[0].const_val = ((((inst))))->data.op[1].const_val = 0; ((((inst))))->next = ((((inst))))->prev = ((void *)0); ((((inst))))->opcode = ((((OP_THROW)))); ((((inst))))->flags = 0; ((((inst))))->type = 0; ((((inst))))->dreg = -1; do { (((((inst)))))->sreg1 = (((((inst)))))->sreg2 = (((((inst)))))->sreg3 = -1; } while (0); ((((inst))))->cil_code = ((((cfg))))->ip; } while (0); (((inst)))->dreg = ((-1)); (((inst)))->sreg1 = ((exc_ins->dreg)); } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((inst))); (((inst)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((inst))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((inst))); } } while (0); } while (0); } while (0);
>
>     do { do { if (((dont_throw))->cil_code) { (cfg)->cil_offset_to_bb [((dont_throw))->cil_code - (cfg)->cil_start] = ((dont_throw)); } ((dont_throw))->real_offset = (cfg)->real_offset; } while (0); if (cfg->cbb->last_ins && (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN)) && !cfg->cbb->last_ins->data.op[1].many_blocks[1]) { cfg->cbb->last_ins->data.op[1].many_blocks[1] = (dont_throw); mono_link_bblock ((cfg), (cfg)->cbb, (dont_throw)); } else if (! (cfg->cbb->last_ins && ((cfg->cbb->last_ins->opcode == OP_BR) || (cfg->cbb->last_ins->opcode == OP_BR_REG) || (((cfg->cbb->last_ins)->opcode >= OP_LBEQ && (cfg->cbb->last_ins)->opcode <= OP_LBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_FBEQ && (cfg->cbb->last_ins)->opcode <= OP_FBLT_UN) || ((cfg->cbb->last_ins)->opcode >= OP_IBEQ && (cfg->cbb->last_ins)->opcode <= OP_IBLT_UN))))) mono_link_bblock ((cfg), (cfg)->cbb, (dont_throw)); (cfg)->cbb->next_bb = (dont_throw); (cfg)->cbb = (dont_throw); } while (0);
>     bblock = cfg->cbb;
>    }
>   }
>
>   if ((handlers = mono_find_final_block (cfg, ip, target, MONO_EXCEPTION_CLAUSE_FINALLY))) {
>    GList *tmp;
>    MonoExceptionClause *clause;
>
>    for (tmp = handlers; tmp; tmp = tmp->next) {
>     clause = tmp->data;
>     tblock = cfg->cil_offset_to_bb [clause->handler_offset];
>     do { if (!(tblock)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9602, "tblock"); } while (0);
>     link_bblock (cfg, bblock, tblock);
>     do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_CALL_HANDLER); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>     ins->data.op[0].target_block = tblock;
>     ins->data.op[1].exception_clause = clause;
>     do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>     bblock->has_call_handler = 1;
>     if ((0)) {
>      MonoBasicBlock *target_bb;
>
>
>
>
>
>
>      do { (target_bb) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(target_bb)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((target_bb)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((target_bb))->block_num = cfg->num_bblocks++; } while (0); (target_bb)->cil_code = (target); do { if (((target_bb))->cil_code) { cfg->cil_offset_to_bb [((target_bb))->cil_code - cfg->cil_start] = ((target_bb)); } ((target_bb))->real_offset = cfg->real_offset; } while (0); } } while (0);
>      link_bblock (cfg, tblock, target_bb);
>     }
>    }
>    monoeg_g_list_free (handlers);
>   }
>
>   do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BR); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>   do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>   do { (tblock) = cfg->cil_offset_to_bb [(target) - cfg->cil_start]; if (!(tblock)) { if ((target) >= end || (target) < header->code) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0); do { ((tblock)) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); ((tblock))->block_num = cfg->num_bblocks++; } while (0); (tblock)->cil_code = (target); do { if (((tblock))->cil_code) { cfg->cil_offset_to_bb [((tblock))->cil_code - cfg->cil_start] = ((tblock)); } ((tblock))->real_offset = cfg->real_offset; } while (0); } } while (0);
>   link_bblock (cfg, bblock, tblock);
>   ins->data.op[0].target_block = tblock;
>   start_new_bblock = 1;
>
>   if (*ip == CEE_LEAVE)
>    ip += 5;
>   else
>    ip += 2;
>
>   break;
>  }
>
>
>
>
>  case 0xf0: {
>
>   do { if (!(method->wrapper_type != MONO_WRAPPER_NONE)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9644, "method->wrapper_type != MONO_WRAPPER_NONE"); } while (0);
>
>   if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   switch (ip [1]) {
>   case CEE_MONO_ICALL: {
>    gpointer func;
>    MonoJitICallInfo *info;
>
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>    func = mono_method_get_wrapper_data (method, token);
>    info = mono_find_jit_icall_by_addr (func);
>    do { if (!(info)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9655, "info"); } while (0);
>
>    if ((sp - stack_start) < (info->sig->param_count)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    sp -= info->sig->param_count;
>
>    ins = mono_emit_jit_icall (cfg, info->func, sp);
>    if (!mono_type_is_void (info->sig->ret))
>     *sp++ = ins;
>
>    ip += 6;
>    inline_costs += 10 * num_calls++;
>
>    break;
>   }
>   case CEE_MONO_LDPTR: {
>    gpointer ptr;
>
>    if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>
>    ptr = mono_method_get_wrapper_data (method, token);
>    if (cfg->compile_aot && (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) && (strstr (method->name, "__icall_wrapper_") == method->name)) {
>     MonoJitICallInfo *callinfo;
>     const char *icall_name;
>
>     icall_name = method->name + __strlen_g (("__icall_wrapper_"));
>     do { if (!(icall_name)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9682, "icall_name"); } while (0);
>     callinfo = mono_find_jit_icall_by_name (icall_name);
>     do { if (!(callinfo)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9684, "callinfo"); } while (0);
>
>     if (ptr == callinfo->func) {
>
>      do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((ptr)); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>      *sp++ = ins;
>      ip += 6;
>      break;
>     }
>    }
>
>    if (cfg->compile_aot && ptr == mono_thread_interruption_request_flag ()) {
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((((void *)0))); ((ins))->data.op[1].src = (gpointer)((MONO_PATCH_INFO_INTERRUPTION_REQUEST_FLAG)); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>     *sp++ = ins;
>     ip += 6;
>     break;
>    }
>    do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((ptr)); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    *sp++ = ins;
>    ip += 6;
>    inline_costs += 10 * num_calls++;
>
>    cfg->disable_aot = 1;
>    break;
>   }
>   case CEE_MONO_ICALL_ADDR: {
>    MonoMethod *cmethod;
>    gpointer ptr;
>
>    if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>
>    cmethod = mono_method_get_wrapper_data (method, token);
>
>    if (cfg->compile_aot) {
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((cmethod)); ((ins))->data.op[1].src = (gpointer)((MONO_PATCH_INFO_ICALL_ADDR)); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    } else {
>     ptr = mono_lookup_internal_call (cmethod);
>     do { if (!(ptr)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9723, "ptr"); } while (0);
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((ptr)); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    }
>    *sp++ = ins;
>    ip += 6;
>    break;
>   }
>   case CEE_MONO_VTADDR: {
>    MonoInst *src_var, *src;
>
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>
>
>    src_var = ((sp [0]->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(sp [0]->dreg)] : ((void *)0));
>    do { do { do { ((((src)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((src))))->data.op[0].const_val = ((((src))))->data.op[1].const_val = 0; ((((src))))->next = ((((src))))->prev = ((void *)0); ((((src))))->opcode = (OP_LDADDR); ((((src))))->flags = 0; ((((src))))->type = 0; ((((src))))->dreg = -1; do { (((((src)))))->sreg1 = (((((src)))))->sreg2 = (((((src)))))->sreg3 = -1; } while (0); ((((src))))->cil_code = ((((cfg))))->ip; } while (0); (((src)))->data.op[0].p = ((src_var)); ((src_var))->flags |= MONO_INST_INDIRECT; (((src)))->type = STACK_MP; (((src)))->klass = ((src_var))->klass; (((src)))->dreg = alloc_dreg ((((cfg))), STACK_MP); if (8 == 4 && ((((src_var))->type) == STACK_I8)) { MonoInst *var1 = ((((src_var))->dreg + 1) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((src_var))->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((src_var))->dreg + 2) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((src_var))->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9738, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9738, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if ((((cfg))->cbb)->last_ins) { (((cfg))->cbb)->last_ins->next = (((src))); (((src)))->prev = (((cfg))->cbb)->last_ins; (((cfg))->cbb)->last_ins = (((src))); } else { (((cfg))->cbb)->code = (((cfg))->cbb)->last_ins = (((src))); } } while (0); } while (0);
>    *sp++ = src;
>    ip += 2;
>    break;
>   }
>   case CEE_MONO_NEWOBJ: {
>    MonoInst *iargs [2];
>
>    if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>    klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
>    mono_class_init (klass);
>    do { if ((cfg->opt & MONO_OPT_SHARED) || cfg->compile_aot) { MonoInst* __domain_var = mono_get_domainvar (cfg); do { do { (((iargs [0]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [0])))->data.op[0].const_val = (((iargs [0])))->data.op[1].const_val = 0; (((iargs [0])))->next = (((iargs [0])))->prev = ((void *)0); (((iargs [0])))->opcode = (OP_MOVE); (((iargs [0])))->flags = 0; (((iargs [0])))->type = 0; (((iargs [0])))->dreg = -1; do { ((((iargs [0]))))->sreg1 = ((((iargs [0]))))->sreg2 = ((((iargs [0]))))->sreg3 = -1; } while (0); (((iargs [0])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [0]))->opcode = mono_type_to_regmove (((cfg)), ((cfg)->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); type_to_eval_stack_type (((cfg)), ((cfg)->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype), ((iargs [0]))); ((iargs [0]))->klass = (cfg)->varinfo [(__domain_var->data.op[0].const_val)]->klass; ((iargs [0]))->sreg1 = (cfg)->varinfo [(__domain_var->data.op[0].const_val)]->dreg; ((iargs [0]))->dreg = alloc_dreg (((cfg)), ((iargs [0]))->type); if (((iargs [0]))->opcode == OP_VMOVE) ((iargs [0]))->klass = mono_class_from_mono_type (((cfg)->varinfo [(__domain_var->data.op[0].const_val)]->data.op[1].vtype)); } while (0); } else { do { do { ((iargs [0])) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((iargs [0]))->data.op[0].const_val = ((iargs [0]))->data.op[1].const_val = 0; ((iargs [0]))->next = ((iargs [0]))->prev = ((void *)0); ((iargs [0]))->opcode = (OP_I8CONST); ((iargs [0]))->flags = 0; ((iargs [0]))->type = 0; ((iargs [0]))->dreg = -1; do { (((iargs [0])))->sreg1 = (((iargs [0])))->sreg2 = (((iargs [0])))->sreg3 = -1; } while (0); ((iargs [0]))->cil_code = ((cfg))->ip; } while (0); (iargs [0])->data.op[0].p = ((cfg)->domain); (iargs [0])->type = STACK_PTR; (iargs [0])->dreg = alloc_dreg ((cfg), STACK_PTR); } while (0); } } while (0);
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (iargs [0]); (iargs [0])->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (iargs [0]); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (iargs [0]); } } while (0);
>    do { do { (((iargs [1]))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((iargs [1])))->data.op[0].const_val = (((iargs [1])))->data.op[1].const_val = 0; (((iargs [1])))->next = (((iargs [1])))->prev = ((void *)0); (((iargs [1])))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((iargs [1])))->flags = 0; (((iargs [1])))->type = 0; (((iargs [1])))->dreg = -1; do { ((((iargs [1]))))->sreg1 = ((((iargs [1]))))->sreg2 = ((((iargs [1]))))->sreg3 = -1; } while (0); (((iargs [1])))->cil_code = (((cfg)))->ip; } while (0); ((iargs [1]))->data.op[0].p = ((klass)); ((iargs [1]))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_CLASS); ((iargs [1]))->type = STACK_PTR; ((iargs [1]))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0);
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (iargs [1]); (iargs [1])->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (iargs [1]); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (iargs [1]); } } while (0);
>    *sp++ = mono_emit_jit_icall (cfg, mono_object_new, iargs);
>    ip += 6;
>    inline_costs += 10 * num_calls++;
>    break;
>   }
>   case CEE_MONO_OBJADDR:
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_MOVE); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->dreg = alloc_ireg_mp (cfg);
>    ins->sreg1 = sp [0]->dreg;
>    ins->type = STACK_MP;
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>    *sp++ = ins;
>    ip += 2;
>    break;
>   case CEE_MONO_LDNATIVEOBJ:
>
>
>
>
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>    klass = mono_method_get_wrapper_data (method, token);
>    do { if (!(klass->valuetype)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9781, "klass->valuetype"); } while (0);
>    mono_class_init (klass);
>
>    {
>     MonoInst *src, *dest, *temp;
>
>     src = sp [0];
>     temp = mono_compile_create_var (cfg, &klass->byval_arg, OP_LOCAL);
>     temp->backend.is_pinvoke = 1;
>     do { do { do { ((((dest)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((dest))))->data.op[0].const_val = ((((dest))))->data.op[1].const_val = 0; ((((dest))))->next = ((((dest))))->prev = ((void *)0); ((((dest))))->opcode = (OP_LDADDR); ((((dest))))->flags = 0; ((((dest))))->type = 0; ((((dest))))->dreg = -1; do { (((((dest)))))->sreg1 = (((((dest)))))->sreg2 = (((((dest)))))->sreg3 = -1; } while (0); ((((dest))))->cil_code = ((((cfg))))->ip; } while (0); (((dest)))->data.op[0].p = ((cfg)->varinfo [((temp->data.op[0].const_val))]); ((cfg)->varinfo [((temp->data.op[0].const_val))])->flags |= MONO_INST_INDIRECT; (((dest)))->type = STACK_MP; (((dest)))->klass = ((cfg)->varinfo [((temp->data.op[0].const_val))])->klass; (((dest)))->dreg = alloc_dreg ((((cfg))), STACK_MP); if (8 == 4 && ((((cfg)->varinfo [((temp->data.op[0].const_val))])->type) == STACK_I8)) { MonoInst *var1 = ((((cfg)->varinfo [((temp->data.op[0].const_val))])->dreg + 1) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((temp->data.op[0].const_val))])->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((cfg)->varinfo [((temp->data.op[0].const_val))])->dreg + 2) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((temp->data.op[0].const_val))])->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9790, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9790, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((dest)); ((dest))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((dest)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((dest)); } } while (0); } while (0);
>     mini_emit_stobj (cfg, dest, src, klass, 1);
>
>     do { do { do { ((((dest)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((dest))))->data.op[0].const_val = ((((dest))))->data.op[1].const_val = 0; ((((dest))))->next = ((((dest))))->prev = ((void *)0); ((((dest))))->opcode = (OP_MOVE); ((((dest))))->flags = 0; ((((dest))))->type = 0; ((((dest))))->dreg = -1; do { (((((dest)))))->sreg1 = (((((dest)))))->sreg2 = (((((dest)))))->sreg3 = -1; } while (0); ((((dest))))->cil_code = ((((cfg))))->ip; } while (0); (((dest)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((temp->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((temp->data.op[0].const_val))]->data.op[1].vtype), (((dest)))); (((dest)))->klass = ((cfg))->varinfo [((temp->data.op[0].const_val))]->klass; (((dest)))->sreg1 = ((cfg))->varinfo [((temp->data.op[0].const_val))]->dreg; (((dest)))->dreg = alloc_dreg ((((cfg))), (((dest)))->type); if ((((dest)))->opcode == OP_VMOVE) (((dest)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((temp->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((dest)); ((dest))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((dest)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((dest)); } } while (0); } while (0);
>     dest->type = STACK_VTYPE;
>     dest->klass = klass;
>
>     *sp ++ = dest;
>     ip += 6;
>    }
>    break;
>   case CEE_MONO_RETOBJ: {
>
>
>
>
>    do { if (!(cfg->ret)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9806, "cfg->ret"); } while (0);
>    do { if (!(mono_method_signature (method)->pinvoke)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9807, "mono_method_signature (method)->pinvoke"); } while (0);
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>    klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
>
>    if (!cfg->vret_addr) {
>     do { if (!(cfg->ret_var_is_local)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9816, "cfg->ret_var_is_local"); } while (0);
>
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_LDADDR); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((cfg->ret)); ((cfg->ret))->flags |= MONO_INST_INDIRECT; ((ins))->type = STACK_MP; ((ins))->klass = ((cfg->ret))->klass; ((ins))->dreg = alloc_dreg (((cfg)), STACK_MP); if (8 == 4 && ((((cfg->ret))->type) == STACK_I8)) { MonoInst *var1 = ((((cfg->ret))->dreg + 1) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [(((cfg->ret))->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((cfg->ret))->dreg + 2) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [(((cfg->ret))->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9818, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9818, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    } else {
>     do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_MOVE); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->type = STACK_MP; ((ins))->klass = (cfg)->ret->klass; ((ins))->sreg1 = (cfg)->vret_addr->dreg; ((ins))->dreg = alloc_dreg (((cfg)), ((ins))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    }
>    mini_emit_stobj (cfg, ins, sp [0], klass, 1);
>
>    if (sp != stack_start)
>     do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_BR); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->data.op[0].target_block = end_bblock;
>    do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>    link_bblock (cfg, bblock, end_bblock);
>    start_new_bblock = 1;
>    ip += 6;
>    break;
>   }
>   case CEE_MONO_CISINST:
>   case CEE_MONO_CCASTCLASS: {
>    int token;
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>    klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
>    if (ip [1] == CEE_MONO_CISINST)
>     ins = handle_cisinst (cfg, klass, sp [0]);
>    else
>     ins = handle_ccastclass (cfg, klass, sp [0]);
>    bblock = cfg->cbb;
>    *sp++ = ins;
>    ip += 6;
>    break;
>   }
>   case CEE_MONO_SAVE_LMF:
>   case CEE_MONO_RESTORE_LMF:
>
>
>
>
>
>    ip += 2;
>    break;
>   case CEE_MONO_CLASSCONST:
>    if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>    do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = ((cfg)->compile_aot ? OP_AOTCONST : OP_I8CONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = ((mono_method_get_wrapper_data (method, token))); ((ins))->data.op[1].src = (gpointer)(MONO_PATCH_INFO_CLASS); ((ins))->type = STACK_PTR; ((ins))->dreg = alloc_dreg (((cfg)), STACK_PTR); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    *sp++ = ins;
>    ip += 6;
>    inline_costs += 10 * num_calls++;
>    break;
>   case CEE_MONO_NOT_TAKEN:
>    bblock->out_of_line = 1;
>    ip += 2;
>    break;
>   case CEE_MONO_TLS:
>    if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_TLS_GET); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->dreg = alloc_preg (cfg);
>    ins->data.op[0].const_val = (gint32)(((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>    ins->type = STACK_PTR;
>    do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>    *sp++ = ins;
>    ip += 6;
>    break;
>   case CEE_MONO_DYN_CALL: {
>    MonoCallInst *call;
>
>
>
>
>
>
>    if (!cfg->dyn_call_var) {
>     cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
>
>     cfg->dyn_call_var->flags |= MONO_INST_INDIRECT;
>    }
>
>
>    do { (call) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoCallInst)); (call)->inst.opcode = (OP_DYN_CALL); (call)->inst.dreg = -1; do { (&(call)->inst)->sreg1 = (&(call)->inst)->sreg2 = (&(call)->inst)->sreg3 = -1; } while (0); (call)->inst.cil_code = (cfg)->ip; } while (0);
>    ins = (MonoInst*)call;
>    sp -= 2;
>    ins->sreg1 = sp [0]->dreg;
>    ins->sreg2 = sp [1]->dreg;
>    do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>
>
>
>
>
>    ip += 2;
>    inline_costs += 10 * num_calls++;
>
>    break;
>   }
>   default:
>    do { monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "opcode 0x%02x 0x%02x not handled", 0xf0, ip [1]); for (;;); } while (0);
>    break;
>   }
>   break;
>  }
>
>  case CEE_PREFIX1: {
>   if (ip + 2 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   switch (ip [1]) {
>   case CEE_ARGLIST: {
>
>    MonoInst *addr, *vtvar;
>    if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
>
>    do { do { do { ((((addr)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((addr))))->data.op[0].const_val = ((((addr))))->data.op[1].const_val = 0; ((((addr))))->next = ((((addr))))->prev = ((void *)0); ((((addr))))->opcode = (OP_LDADDR); ((((addr))))->flags = 0; ((((addr))))->type = 0; ((((addr))))->dreg = -1; do { (((((addr)))))->sreg1 = (((((addr)))))->sreg2 = (((((addr)))))->sreg3 = -1; } while (0); ((((addr))))->cil_code = ((((cfg))))->ip; } while (0); (((addr)))->data.op[0].p = ((cfg)->varinfo [((vtvar->data.op[0].const_val))]); ((cfg)->varinfo [((vtvar->data.op[0].const_val))])->flags |= MONO_INST_INDIRECT; (((addr)))->type = STACK_MP; (((addr)))->klass = ((cfg)->varinfo [((vtvar->data.op[0].const_val))])->klass; (((addr)))->dreg = alloc_dreg ((((cfg))), STACK_MP); if (8 == 4 && ((((cfg)->varinfo [((vtvar->data.op[0].const_val))])->type) == STACK_I8)) { MonoInst *var1 = ((((cfg)->varinfo [((vtvar->data.op[0].const_val))])->dreg + 1) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((vtvar->data.op[0].const_val))])->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((cfg)->varinfo [((vtvar->data.op[0].const_val))])->dreg + 2) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [(((cfg)->varinfo [((vtvar->data.op[0].const_val))])->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9932, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 9932, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((addr)); ((addr))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((addr)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((addr)); } } while (0); } while (0);
>    do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (((OP_ARGLIST))); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->dreg = (-1); ((ins))->sreg1 = (addr->dreg); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>
>    do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((vtvar->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((vtvar->data.op[0].const_val))]->data.op[1].vtype), (((ins)))); (((ins)))->klass = ((cfg))->varinfo [((vtvar->data.op[0].const_val))]->klass; (((ins)))->sreg1 = ((cfg))->varinfo [((vtvar->data.op[0].const_val))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((vtvar->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    ins->type = STACK_VTYPE;
>    ins->klass = mono_defaults.argumenthandle_class;
>    *sp++ = ins;
>    ip += 2;
>    break;
>   }
>   case CEE_CEQ:
>   case CEE_CGT:
>   case CEE_CGT_UN:
>   case CEE_CLT:
>   case CEE_CLT_UN: {
>    MonoInst *cmp;
>    if ((sp - stack_start) < (2)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
># 9957 "method-to-ir.c"
>    do { (cmp) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (cmp)->data.op[0].const_val = (cmp)->data.op[1].const_val = 0; (cmp)->next = (cmp)->prev = ((void *)0); (cmp)->opcode = ((OP_CEQ - CEE_CEQ) + ip [1]); (cmp)->flags = 0; (cmp)->type = 0; (cmp)->dreg = -1; do { ((cmp))->sreg1 = ((cmp))->sreg2 = ((cmp))->sreg3 = -1; } while (0); (cmp)->cil_code = (cfg)->ip; } while (0);
>
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (cmp->opcode); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    sp -= 2;
>    cmp->sreg1 = sp [0]->dreg;
>    cmp->sreg2 = sp [1]->dreg;
>    type_from_op (cmp, sp [0], sp [1]);
>    if (!(cmp)->type) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if ((sp [0]->type == STACK_I8) || ((8 == 8) && ((sp [0]->type == STACK_PTR) || (sp [0]->type == STACK_OBJ) || (sp [0]->type == STACK_MP))))
>     cmp->opcode = OP_LCOMPARE;
>    else if (sp [0]->type == STACK_R8)
>     cmp->opcode = OP_FCOMPARE;
>    else
>     cmp->opcode = OP_ICOMPARE;
>    do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (cmp); (cmp)->prev = (bblock)->last_ins; (bblock)->last_ins = (cmp); } else { (bblock)->code = (bblock)->last_ins = (cmp); } } while (0);
>    ins->type = STACK_I4;
>    ins->dreg = alloc_dreg (cfg, ins->type);
>    type_from_op (ins, sp [0], sp [1]);
>
>    if (cmp->opcode == OP_FCOMPARE) {
>
>
>
>
>     cmp->opcode = OP_NOP;
>     ins->sreg1 = cmp->sreg1;
>     ins->sreg2 = cmp->sreg2;
>    }
>    do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>    *sp++ = ins;
>    ip += 2;
>    break;
>   }
>   case CEE_LDFTN: {
>    MonoInst *argconst;
>    MonoMethod *cil_method;
>    gboolean needs_static_rgctx_invoke;
>
>    if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    n = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>    cmethod = mini_get_method (cfg, method, n, ((void *)0), generic_context);
>    if (!cmethod || mono_loader_get_last_error ())
>     do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>    mono_class_init (cmethod->klass);
>
>    mono_save_token_info (cfg, image, n, cmethod);
>
>    if (cfg->generic_sharing_context)
>     context_used = mono_method_check_context_used (cmethod);
>
>    needs_static_rgctx_invoke = mono_method_needs_static_rgctx_invoke (cmethod, 1);
>
>    cil_method = cmethod;
>    if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_method (method, cmethod))
>     do { char *method_fname = mono_method_full_name (method, 1); char *cil_method_fname = mono_method_full_name (cil_method, 1); mono_cfg_set_exception (cfg, MONO_EXCEPTION_METHOD_ACCESS); cfg->exception_message = monoeg_g_strdup_printf ("Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname); monoeg_g_free (method_fname); monoeg_g_free (cil_method_fname); goto exception_exit; } while (0);
>
>    if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS) {
>     if (check_linkdemand (cfg, method, cmethod))
>      do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>     do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>    } else if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) {
>     ensure_method_is_allowed_to_call_method (cfg, method, cmethod, bblock, ip);
>     }
>
>
>
>
>    if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, bblock, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
>     MonoMethod *ctor_method = mini_get_method (cfg, method, (((guint32) ( (((guint32) (*((const guint32 *) (ip + 7)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 7)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 7)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 7)))) >> 24)) )), ((void *)0), generic_context);
>     if (ctor_method && (ctor_method->klass->parent == mono_defaults.multicastdelegate_class)) {
>      MonoInst *target_ins;
>      MonoMethod *invoke;
>      int invoke_context_used = 0;
>
>      invoke = mono_get_delegate_invoke (ctor_method->klass);
>      if (!invoke || !mono_method_signature (invoke))
>       do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>
>      if (cfg->generic_sharing_context)
>       invoke_context_used = mono_method_check_context_used (invoke);
>
>      target_ins = sp [-1];
>
>      if (!(cmethod->flags & 0x0010)) {
>
>       if (mono_method_signature (invoke)->param_count == mono_method_signature (cmethod)->param_count) {
>        do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COMPARE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = -1; inst->sreg1 = target_ins->dreg; inst->data.op[1].const_val = (mgreg_t)(0); do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (inst); (inst)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (inst); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (inst); } } while (0); } while (0);
>        do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_COND_EXC_EQ)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->data.op[1].p = (char*)"ArgumentException"; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>       }
>      }
>
>
>
>      if (invoke_context_used == 0) {
>       ip += 6;
>       if (cfg->verbose_level > 3)
>        monoeg_g_print ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (((void *)0), method, ip, ((void *)0)));
>       sp --;
>       *sp = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used);
>       do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>       ip += 5;
>       sp ++;
>       break;
>      }
>
>     }
>    }
>
>    argconst = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_METHOD);
>    ins = mono_emit_jit_icall (cfg, mono_ldftn, &argconst);
>    *sp++ = ins;
>
>    ip += 6;
>    inline_costs += 10 * num_calls++;
>    break;
>   }
>   case CEE_LDVIRTFTN: {
>    MonoInst *args [2];
>
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    n = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>    cmethod = mini_get_method (cfg, method, n, ((void *)0), generic_context);
>    if (!cmethod || mono_loader_get_last_error ())
>     do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);
>    mono_class_init (cmethod->klass);
>
>    if (cfg->generic_sharing_context)
>     context_used = mono_method_check_context_used (cmethod);
>
>    if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS) {
>     if (check_linkdemand (cfg, method, cmethod))
>      do { if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) goto inline_failure; } while (0);
>     do { if (cfg->exception_type != MONO_EXCEPTION_NONE) goto exception_exit; } while (0);
>    } else if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) {
>     ensure_method_is_allowed_to_call_method (cfg, method, cmethod, bblock, ip);
>    }
>
>    --sp;
>    args [0] = *sp;
>
>    args [1] = emit_get_rgctx_method (cfg, context_used,
>              cmethod, MONO_RGCTX_INFO_METHOD);
>
>    if (context_used)
>     *sp++ = mono_emit_jit_icall (cfg, mono_ldvirtfn_gshared, args);
>    else
>     *sp++ = mono_emit_jit_icall (cfg, mono_ldvirtfn, args);
>
>    ip += 6;
>    inline_costs += 10 * num_calls++;
>    break;
>   }
>   case CEE_LDARG:
>    if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 4 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    n = (((guint16) (((guint16) *((const guint16 *) (ip + 2))) >> 8) | ((((guint16)(*((const guint16 *) (ip + 2)))) & 0xff) << 8)));
>    if ((unsigned)(n) >= (unsigned)num_args) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), ((cfg)->arg_types [((n))])); type_to_eval_stack_type ((((cfg))), ((cfg)->arg_types [((n))]), (((ins)))); (((ins)))->klass = (cfg)->args [((n))]->klass; (((ins)))->sreg1 = (cfg)->args [((n))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type (((cfg)->arg_types [((n))])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    *sp++ = ins;
>    ip += 4;
>    break;
>   case CEE_LDARGA:
>    if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 4 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    n = (((guint16) (((guint16) *((const guint16 *) (ip + 2))) >> 8) | ((((guint16)(*((const guint16 *) (ip + 2)))) & 0xff) << 8)));
>    if ((unsigned)(n) >= (unsigned)num_args) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_LDADDR); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].p = (arg_array [(n)]); (arg_array [(n)])->flags |= MONO_INST_INDIRECT; ((ins))->type = STACK_MP; ((ins))->klass = (arg_array [(n)])->klass; ((ins))->dreg = alloc_dreg (((cfg)), STACK_MP); if (8 == 4 && (((arg_array [(n)])->type) == STACK_I8)) { MonoInst *var1 = (((arg_array [(n)])->dreg + 1) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [((arg_array [(n)])->dreg + 1)] : ((void *)0)); MonoInst *var2 = (((arg_array [(n)])->dreg + 2) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [((arg_array [(n)])->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 10125, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 10125, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0);
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>    *sp++ = ins;
>    ip += 4;
>    break;
>   case CEE_STARG:
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>    if (ip + 4 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    n = (((guint16) (((guint16) *((const guint16 *) (ip + 2))) >> 8) | ((((guint16)(*((const guint16 *) (ip + 2)))) & 0xff) << 8)));
>    if ((unsigned)(n) >= (unsigned)num_args) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (!dont_verify_stloc && target_type_is_incompatible (cfg, param_types [n], *sp))
>     do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), ((cfg)->arg_types [((n))])); (((ins)))->klass = ((cfg)->args [((n))])->klass; (((ins)))->sreg1 = (((*sp)))->dreg; (((ins)))->dreg = ((cfg)->args [((n))])->dreg; if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type (((cfg)->arg_types [((n))])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    ip += 4;
>    break;
>   case CEE_LDLOC:
>    if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 4 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    n = (((guint16) (((guint16) *((const guint16 *) (ip + 2))) >> 8) | ((((guint16)(*((const guint16 *) (ip + 2)))) & 0xff) << 8)));
>    if ((unsigned)(n) >= (unsigned)header->num_locals) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_MOVE); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->opcode = mono_type_to_regmove ((((cfg))), (header->locals [((n))])); type_to_eval_stack_type ((((cfg))), (header->locals [((n))]), (((ins)))); (((ins)))->klass = (cfg)->locals [((n))]->klass; (((ins)))->sreg1 = (cfg)->locals [((n))]->dreg; (((ins)))->dreg = alloc_dreg ((((cfg))), (((ins)))->type); if ((((ins)))->opcode == OP_VMOVE) (((ins)))->klass = mono_class_from_mono_type ((header->locals [((n))])); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    *sp++ = ins;
>    ip += 4;
>    break;
>   case CEE_LDLOCA: {
>    unsigned char *tmp_ip;
>    if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 4 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    n = (((guint16) (((guint16) *((const guint16 *) (ip + 2))) >> 8) | ((((guint16)(*((const guint16 *) (ip + 2)))) & 0xff) << 8)));
>    if ((unsigned)(n) >= (unsigned)header->num_locals) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>    if ((tmp_ip = emit_optimized_ldloca_ir (cfg, ip, end, 2))) {
>     ip = tmp_ip;
>     inline_costs += 1;
>     break;
>    }
>
>    do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = (OP_LDADDR); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->data.op[0].p = (((cfg))->locals [((n))]); (((cfg))->locals [((n))])->flags |= MONO_INST_INDIRECT; (((ins)))->type = STACK_MP; (((ins)))->klass = (((cfg))->locals [((n))])->klass; (((ins)))->dreg = alloc_dreg ((((cfg))), STACK_MP); if (8 == 4 && (((((cfg))->locals [((n))])->type) == STACK_I8)) { MonoInst *var1 = (((((cfg))->locals [((n))])->dreg + 1) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [((((cfg))->locals [((n))])->dreg + 1)] : ((void *)0)); MonoInst *var2 = (((((cfg))->locals [((n))])->dreg + 2) < (((cfg)))->vreg_to_inst_len ? (((cfg)))->vreg_to_inst [((((cfg))->locals [((n))])->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 10163, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 10163, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    *sp++ = ins;
>    ip += 4;
>    break;
>   }
>   case CEE_STLOC:
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>    if (ip + 4 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    n = (((guint16) (((guint16) *((const guint16 *) (ip + 2))) >> 8) | ((((guint16)(*((const guint16 *) (ip + 2)))) & 0xff) << 8)));
>    if ((unsigned)(n) >= (unsigned)header->num_locals) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (!dont_verify_stloc && target_type_is_incompatible (cfg, header->locals [n], *sp))
>     do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    emit_stloc_ir (cfg, sp, header, n);
>    ip += 4;
>    inline_costs += 1;
>    break;
>   case CEE_LOCALLOC:
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>    if (sp != stack_start)
>     do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (cfg->method != method)
>
>
>
>
>
>     goto inline_failure;
>
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_LOCALLOC); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->dreg = alloc_preg (cfg);
>    ins->sreg1 = sp [0]->dreg;
>    ins->type = STACK_PTR;
>    do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (ins); (ins)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (ins); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (ins); } } while (0);
>
>    cfg->flags |= MONO_CFG_HAS_ALLOCA;
>    if (init_locals)
>     ins->flags |= MONO_INST_INIT;
>
>    *sp++ = ins;
>    ip += 2;
>    break;
>   case CEE_ENDFILTER: {
>    MonoExceptionClause *clause, *nearest;
>    int cc, nearest_num;
>
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>    if ((sp != stack_start) || (sp [0]->type != STACK_I4))
>     do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_ENDFILTER); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->sreg1 = (*sp)->dreg;
>    do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>    start_new_bblock = 1;
>    ip += 2;
>
>    nearest = ((void *)0);
>    nearest_num = 0;
>    for (cc = 0; cc < header->num_clauses; ++cc) {
>     clause = &header->clauses [cc];
>     if ((clause->flags & MONO_EXCEPTION_CLAUSE_FILTER) &&
>      ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
>         (!nearest || (clause->data.filter_offset < nearest->data.filter_offset))) {
>      nearest = clause;
>      nearest_num = cc;
>     }
>    }
>    do { if (!(nearest)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 10231, "nearest"); } while (0);
>    if ((ip - header->code) != nearest->handler_offset)
>     do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>    break;
>   }
>   case CEE_UNALIGNED_:
>    ins_flag |= MONO_INST_UNALIGNED;
>
>    if (ip + 3 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    ip += 3;
>    break;
>   case CEE_VOLATILE_:
>    ins_flag |= MONO_INST_VOLATILE;
>    ip += 2;
>    break;
>   case CEE_TAIL_:
>    ins_flag |= MONO_INST_TAILCALL;
>    cfg->flags |= MONO_CFG_HAS_TAIL;
>
>    inline_costs += 100000;
>    ip += 2;
>    break;
>   case CEE_INITOBJ:
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>    klass = mini_get_class (method, token, generic_context);
>    if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>    if (generic_class_is_reference_type (cfg, klass))
>     do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((OP_STORE_MEMBASE_IMM)); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = sp [0]->dreg; inst->data.op[0].const_val = 0; inst->data.op[1].const_val = (mgreg_t)(0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>    else
>     mini_emit_initobj (cfg, *sp, ((void *)0), klass);
>    ip += 6;
>    inline_costs += 1;
>    break;
>   case CEE_CONSTRAINED_:
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>    if (method->wrapper_type != MONO_WRAPPER_NONE)
>     constrained_call = (MonoClass *)mono_method_get_wrapper_data (method, token);
>    else
>     constrained_call = mono_class_get_full (image, token, generic_context);
>    if (!(constrained_call) || (constrained_call)->exception_type) {cfg->exception_ptr = constrained_call; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>    ip += 6;
>    break;
>   case CEE_CPBLK:
>   case CEE_INITBLK: {
>    MonoInst *iargs [3];
>    if ((sp - stack_start) < (3)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    sp -= 3;
>
>    if ((ip [1] == CEE_CPBLK) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->data.op[0].const_val) <= sizeof (gpointer) * 5)) {
>     mini_emit_memcpy (cfg, sp [0]->dreg, 0, sp [1]->dreg, 0, sp [2]->data.op[0].const_val, 0);
>    } else if ((ip [1] == CEE_INITBLK) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->data.op[0].const_val) <= sizeof (gpointer) * 5) && (sp [1]->opcode == OP_ICONST) && (sp [1]->data.op[0].const_val == 0)) {
>
>     mini_emit_memset (cfg, sp [0]->dreg, 0, sp [2]->data.op[0].const_val, sp [1]->data.op[0].const_val, 0);
>    } else {
>     iargs [0] = sp [0];
>     iargs [1] = sp [1];
>     iargs [2] = sp [2];
>     if (ip [1] == CEE_CPBLK) {
>      MonoMethod *memcpy_method = get_memcpy_method ();
>      mono_emit_method_call (cfg, memcpy_method, iargs, ((void *)0));
>     } else {
>      MonoMethod *memset_method = get_memset_method ();
>      mono_emit_method_call (cfg, memset_method, iargs, ((void *)0));
>     }
>    }
>    ip += 2;
>    inline_costs += 1;
>    break;
>   }
>   case CEE_NO_:
>    if (ip + 3 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip [2] & 0x1)
>     ins_flag |= MONO_INST_NOTYPECHECK;
>    if (ip [2] & 0x2)
>     ins_flag |= MONO_INST_NORANGECHECK;
>
>
>
>    ip += 3;
>    break;
>   case CEE_RETHROW: {
>    MonoInst *load;
>    int handler_offset = -1;
>
>    for (i = 0; i < header->num_clauses; ++i) {
>     MonoExceptionClause *clause = &header->clauses [i];
>     if (((clause)->handler_offset <= (ip - header->code) && (ip - header->code) < ((clause)->handler_offset + (clause)->handler_len)) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
>      handler_offset = clause->handler_offset;
>      break;
>     }
>    }
>
>    bblock->flags |= BB_EXCEPTION_UNSAFE;
>
>    do { if (!(handler_offset != -1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 10330, "handler_offset != -1"); } while (0);
>
>    do { do { do { ((((load)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((load))))->data.op[0].const_val = ((((load))))->data.op[1].const_val = 0; ((((load))))->next = ((((load))))->prev = ((void *)0); ((((load))))->opcode = (OP_MOVE); ((((load))))->flags = 0; ((((load))))->type = 0; ((((load))))->dreg = -1; do { (((((load)))))->sreg1 = (((((load)))))->sreg2 = (((((load)))))->sreg3 = -1; } while (0); ((((load))))->cil_code = ((((cfg))))->ip; } while (0); (((load)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->varinfo [((mono_find_exvar_for_offset (cfg, handler_offset)->data.op[0].const_val))]->data.op[1].vtype)); type_to_eval_stack_type ((((cfg))), (((cfg))->varinfo [((mono_find_exvar_for_offset (cfg, handler_offset)->data.op[0].const_val))]->data.op[1].vtype), (((load)))); (((load)))->klass = ((cfg))->varinfo [((mono_find_exvar_for_offset (cfg, handler_offset)->data.op[0].const_val))]->klass; (((load)))->sreg1 = ((cfg))->varinfo [((mono_find_exvar_for_offset (cfg, handler_offset)->data.op[0].const_val))]->dreg; (((load)))->dreg = alloc_dreg ((((cfg))), (((load)))->type); if ((((load)))->opcode == OP_VMOVE) (((load)))->klass = mono_class_from_mono_type ((((cfg))->varinfo [((mono_find_exvar_for_offset (cfg, handler_offset)->data.op[0].const_val))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((load)); ((load))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((load)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((load)); } } while (0); } while (0);
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_RETHROW); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->sreg1 = load->dreg;
>    do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_NOT_REACHED); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    do { if ((bblock)->last_ins) { (bblock)->last_ins->next = (ins); (ins)->prev = (bblock)->last_ins; (bblock)->last_ins = (ins); } else { (bblock)->code = (bblock)->last_ins = (ins); } } while (0);
>
>    sp = stack_start;
>    link_bblock (cfg, bblock, end_bblock);
>    start_new_bblock = 1;
>    ip += 2;
>    break;
>   }
>   case CEE_SIZEOF: {
>    guint32 align;
>    int ialign;
>
>    if (((sp - stack_start) + (1)) > header->max_stack) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    if (ip + 6 > end) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    token = (((guint32) ( (((guint32) (*((const guint32 *) (ip + 2)))) << 24)| ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff0000) >> 8) | ((((guint32) (*((const guint32 *) (ip + 2)))) & 0xff00) << 8) | (((guint32) (*((const guint32 *) (ip + 2)))) >> 24)) ));
>    if (((token) >> 24) == MONO_TABLE_TYPESPEC && !method->klass->image->dynamic && !generic_context) {
>     MonoType *type = mono_type_create_from_typespec (image, token);
>     token = mono_type_size (type, &ialign);
>    } else {
>     MonoClass *klass = mono_class_get_full (image, token, generic_context);
>     if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto load_error; } while (0);};
>     mono_class_init (klass);
>     token = mono_class_value_size (klass, &align);
>    }
>    do { do { do { (((ins))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((ins)))->data.op[0].const_val = (((ins)))->data.op[1].const_val = 0; (((ins)))->next = (((ins)))->prev = ((void *)0); (((ins)))->opcode = (OP_ICONST); (((ins)))->flags = 0; (((ins)))->type = 0; (((ins)))->dreg = -1; do { ((((ins))))->sreg1 = ((((ins))))->sreg2 = ((((ins))))->sreg3 = -1; } while (0); (((ins)))->cil_code = (((cfg)))->ip; } while (0); ((ins))->data.op[0].const_val = ((token)); ((ins))->type = STACK_I4; ((ins))->dreg = alloc_dreg (((cfg)), STACK_I4); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    *sp++= ins;
>    ip += 6;
>    break;
>   }
>   case CEE_REFANYTYPE: {
>    MonoInst *src_var, *src;
>
>    if ((sp - stack_start) < (1)) do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>    --sp;
>
>
>    src_var = ((sp [0]->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(sp [0]->dreg)] : ((void *)0));
>    if (!src_var)
>     src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
>    do { do { do { (((src))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((src)))->data.op[0].const_val = (((src)))->data.op[1].const_val = 0; (((src)))->next = (((src)))->prev = ((void *)0); (((src)))->opcode = (OP_LDADDR); (((src)))->flags = 0; (((src)))->type = 0; (((src)))->dreg = -1; do { ((((src))))->sreg1 = ((((src))))->sreg2 = ((((src))))->sreg3 = -1; } while (0); (((src)))->cil_code = (((cfg)))->ip; } while (0); ((src))->data.op[0].p = ((src_var)); ((src_var))->flags |= MONO_INST_INDIRECT; ((src))->type = STACK_MP; ((src))->klass = ((src_var))->klass; ((src))->dreg = alloc_dreg (((cfg)), STACK_MP); if (8 == 4 && ((((src_var))->type) == STACK_I8)) { MonoInst *var1 = ((((src_var))->dreg + 1) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [(((src_var))->dreg + 1)] : ((void *)0)); MonoInst *var2 = ((((src_var))->dreg + 2) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [(((src_var))->dreg + 2)] : ((void *)0)); do { if (!(var1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 10377, "var1"); } while (0); do { if (!(var2)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 10377, "var2"); } while (0); var1->flags |= MONO_INST_INDIRECT; var2->flags |= MONO_INST_INDIRECT; } } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((src)); ((src))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((src)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((src)); } } while (0); } while (0);
>    do { do { do { do { ((((ins)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((ins))))->data.op[0].const_val = ((((ins))))->data.op[1].const_val = 0; ((((ins))))->next = ((((ins))))->prev = ((void *)0); ((((ins))))->opcode = ((mono_type_to_load_membase (((cfg)), ((&mono_defaults.typehandle_class->byval_arg))))); ((((ins))))->flags = 0; ((((ins))))->type = 0; ((((ins))))->dreg = -1; do { (((((ins)))))->sreg1 = (((((ins)))))->sreg2 = (((((ins)))))->sreg3 = -1; } while (0); ((((ins))))->cil_code = ((((cfg))))->ip; } while (0); (((ins)))->dreg = (0); (((ins)))->sreg1 = (((src->dreg))); (((ins)))->data.op[0].const_val = (((__builtin_offsetof (MonoTypedRef, type)))); (((ins)))->type = STACK_I4; } while (0); type_to_eval_stack_type (((cfg)), ((&mono_defaults.typehandle_class->byval_arg)), ((ins))); ((ins))->dreg = alloc_dreg (((cfg)), ((ins))->type); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((ins)); ((ins))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((ins)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((ins)); } } while (0); } while (0);
>    *sp++ = ins;
>    ip += 2;
>    break;
>   }
>   case CEE_READONLY_:
>    readonly = 1;
>    ip += 2;
>    break;
>
>   case CEE_UNUSED56:
>   case CEE_UNUSED57:
>   case CEE_UNUSED70:
>   case CEE_UNUSED:
>   case CEE_UNUSED99:
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>   default:
>    monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_WARNING, "opcode 0xfe 0x%02x not handled", ip [1]);
>    do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>   }
>   break;
>  }
>  case CEE_UNUSED58:
>  case CEE_UNUSED1:
>   do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
>  default:
>   monoeg_g_log (((gchar*) 0), G_LOG_LEVEL_WARNING, "opcode 0x%02x not handled", *ip);
>   do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>  }
> }
> if (start_new_bblock != 1)
>  do { if (mini_get_debug_options ()->break_on_unverified) do { raise (5); } while (0); else goto unverified; } while (0);
>
> bblock->cil_length = ip - bblock->cil_code;
> if (bblock->next_bb) {
>
>  MonoBasicBlock *bb = bblock;
>
>  while (bb->next_bb)
>   bb = bb->next_bb;
>  bb->next_bb = end_bblock;
> } else {
>  bblock->next_bb = end_bblock;
> }
>
> if (cfg->method == method && cfg->domainvar) {
>  MonoInst *store;
>  MonoInst *get_domain;
>
>  cfg->cbb = init_localsbb;
>
>  if (! (get_domain = mono_arch_get_domain_intrinsic (cfg))) {
>   get_domain = mono_emit_jit_icall (cfg, mono_domain_get, ((void *)0));
>  }
>  else {
>   get_domain->dreg = alloc_preg (cfg);
>   do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (get_domain); (get_domain)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (get_domain); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (get_domain); } } while (0);
>  }
>  do { do { (((store))) = mono_mempool_alloc ((((cfg)))->mempool, sizeof (MonoInst)); (((store)))->data.op[0].const_val = (((store)))->data.op[1].const_val = 0; (((store)))->next = (((store)))->prev = ((void *)0); (((store)))->opcode = (OP_MOVE); (((store)))->flags = 0; (((store)))->type = 0; (((store)))->dreg = -1; do { ((((store))))->sreg1 = ((((store))))->sreg2 = ((((store))))->sreg3 = -1; } while (0); (((store)))->cil_code = (((cfg)))->ip; } while (0); ((store))->opcode = mono_type_to_regmove (((cfg)), ((cfg)->varinfo [(cfg->domainvar->data.op[0].const_val)]->data.op[1].vtype)); ((store))->klass = ((cfg)->varinfo [(cfg->domainvar->data.op[0].const_val)])->klass; ((store))->sreg1 = ((get_domain))->dreg; ((store))->dreg = ((cfg)->varinfo [(cfg->domainvar->data.op[0].const_val)])->dreg; if (((store))->opcode == OP_VMOVE) ((store))->klass = mono_class_from_mono_type (((cfg)->varinfo [(cfg->domainvar->data.op[0].const_val)]->data.op[1].vtype)); } while (0);
>  do { if ((cfg->cbb)->last_ins) { (cfg->cbb)->last_ins->next = (store); (store)->prev = (cfg->cbb)->last_ins; (cfg->cbb)->last_ins = (store); } else { (cfg->cbb)->code = (cfg->cbb)->last_ins = (store); } } while (0);
> }
>
>
>
>
>
>
>
> if (cfg->method == method && cfg->got_var)
>  mono_emit_load_got_addr (cfg);
>
> if (init_locals) {
>  MonoInst *store;
>
>  cfg->cbb = init_localsbb;
>  cfg->ip = ((void *)0);
>  for (i = 0; i < header->num_locals; ++i) {
>   MonoType *ptype = header->locals [i];
>   int t = ptype->type;
>   dreg = cfg->locals [i]->dreg;
>
>   if (t == MONO_TYPE_VALUETYPE && ptype->data.klass->enumtype)
>    t = mono_class_enum_basetype (ptype->data.klass)->type;
>   if (ptype->byref) {
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_I8CONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = dreg; (inst)->data.op[0].p = (((void *)0)); (inst)->type = STACK_PTR; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   } else if (t >= MONO_TYPE_BOOLEAN && t <= MONO_TYPE_U4) {
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_ICONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = cfg->locals [i]->dreg; inst->data.op[0].const_val = 0; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   } else if (t == MONO_TYPE_I8 || t == MONO_TYPE_U8) {
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_I8CONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = cfg->locals [i]->dreg; inst->data.i8const = 0; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   } else if (t == MONO_TYPE_R4 || t == MONO_TYPE_R8) {
>    do { (ins) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (ins)->data.op[0].const_val = (ins)->data.op[1].const_val = 0; (ins)->next = (ins)->prev = ((void *)0); (ins)->opcode = (OP_R8CONST); (ins)->flags = 0; (ins)->type = 0; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); (ins)->cil_code = (cfg)->ip; } while (0);
>    ins->type = STACK_R8;
>    ins->data.op[0].p = (void*)&r8_0;
>    ins->dreg = alloc_dreg (cfg, STACK_R8);
>    do { if ((init_localsbb)->last_ins) { (init_localsbb)->last_ins->next = (ins); (ins)->prev = (init_localsbb)->last_ins; (init_localsbb)->last_ins = (ins); } else { (init_localsbb)->code = (init_localsbb)->last_ins = (ins); } } while (0);
>    do { do { do { ((((store)))) = mono_mempool_alloc (((((cfg))))->mempool, sizeof (MonoInst)); ((((store))))->data.op[0].const_val = ((((store))))->data.op[1].const_val = 0; ((((store))))->next = ((((store))))->prev = ((void *)0); ((((store))))->opcode = (OP_MOVE); ((((store))))->flags = 0; ((((store))))->type = 0; ((((store))))->dreg = -1; do { (((((store)))))->sreg1 = (((((store)))))->sreg2 = (((((store)))))->sreg3 = -1; } while (0); ((((store))))->cil_code = ((((cfg))))->ip; } while (0); (((store)))->opcode = mono_type_to_regmove ((((cfg))), (((cfg))->locals [((i))]->data.op[1].vtype)); (((store)))->klass = (((cfg))->locals [((i))])->klass; (((store)))->sreg1 = (((ins)))->dreg; (((store)))->dreg = (((cfg))->locals [((i))])->dreg; if ((((store)))->opcode == OP_VMOVE) (((store)))->klass = mono_class_from_mono_type ((((cfg))->locals [((i))]->data.op[1].vtype)); } while (0); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = ((store)); ((store))->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = ((store)); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = ((store)); } } while (0); } while (0);
>   } else if ((t == MONO_TYPE_VALUETYPE) || (t == MONO_TYPE_TYPEDBYREF) ||
>       ((t == MONO_TYPE_GENERICINST) && mono_type_generic_inst_is_valuetype (ptype))) {
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = ((0) ? OP_XZERO : OP_VZERO); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = dreg; (inst)->type = STACK_VTYPE; (inst)->klass = (mono_class_from_mono_type (ptype)); do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   } else {
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_I8CONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = dreg; (inst)->data.op[0].p = (((void *)0)); (inst)->type = STACK_PTR; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>   }
>  }
> }
>
> if (cfg->init_ref_vars && cfg->method == method) {
>
>
>  for (i = 0; i < cfg->num_varinfo; ++i) {
>   MonoInst *ins = cfg->varinfo [i];
>
>   if (ins->opcode == OP_LOCAL && ins->type == STACK_OBJ)
>    do { MonoInst *inst; do { ((inst)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((inst))->data.op[0].const_val = ((inst))->data.op[1].const_val = 0; ((inst))->next = ((inst))->prev = ((void *)0); ((inst))->opcode = (OP_I8CONST); ((inst))->flags = 0; ((inst))->type = 0; ((inst))->dreg = -1; do { (((inst)))->sreg1 = (((inst)))->sreg2 = (((inst)))->sreg3 = -1; } while (0); ((inst))->cil_code = ((cfg))->ip; } while (0); inst->dreg = ins->dreg; (inst)->data.op[0].p = (((void *)0)); (inst)->type = STACK_PTR; do { if (((cfg)->cbb)->last_ins) { ((cfg)->cbb)->last_ins->next = (inst); (inst)->prev = ((cfg)->cbb)->last_ins; ((cfg)->cbb)->last_ins = (inst); } else { ((cfg)->cbb)->code = ((cfg)->cbb)->last_ins = (inst); } } while (0); } while (0);
>  }
> }
>
>
> if (seq_points) {
>  do { do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = (OP_SEQ_POINT); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); (ins)->data.op[1].const_val = (-1); (ins)->flags = 0 ? MONO_INST_SINGLE_STEP_LOC : 0; } while (0);
>  do { if ((init_localsbb)->last_ins) { (init_localsbb)->last_ins->next = (ins); (ins)->prev = (init_localsbb)->last_ins; (init_localsbb)->last_ins = (ins); } else { (init_localsbb)->code = (init_localsbb)->last_ins = (ins); } } while (0);
>  do { do { ((ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((ins))->data.op[0].const_val = ((ins))->data.op[1].const_val = 0; ((ins))->next = ((ins))->prev = ((void *)0); ((ins))->opcode = (OP_SEQ_POINT); ((ins))->flags = 0; ((ins))->type = 0; ((ins))->dreg = -1; do { (((ins)))->sreg1 = (((ins)))->sreg2 = (((ins)))->sreg3 = -1; } while (0); ((ins))->cil_code = ((cfg))->ip; } while (0); (ins)->data.op[1].const_val = (0xffffff); (ins)->flags = 0 ? MONO_INST_SINGLE_STEP_LOC : 0; } while (0);
>  do { if ((cfg->bb_exit)->last_ins) { (cfg->bb_exit)->last_ins->next = (ins); (ins)->prev = (cfg->bb_exit)->last_ins; (cfg->bb_exit)->last_ins = (ins); } else { (cfg->bb_exit)->code = (cfg->bb_exit)->last_ins = (ins); } } while (0);
> }
>
> cfg->ip = ((void *)0);
>
> if (cfg->method == method) {
>  MonoBasicBlock *bb;
>  for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
>   bb->region = mono_find_block_region (cfg, bb->real_offset);
>   if (cfg->spvars)
>    mono_create_spvar_for_region (cfg, bb->region);
>   if (cfg->verbose_level > 2)
>    printf ("REGION BB%d IL_%04x ID_%08X\n", bb->block_num, bb->real_offset, bb->region);
>  }
> }
>
> monoeg_g_slist_free (class_inits);
> dont_inline = monoeg_g_list_remove (dont_inline, method);
>
> if (inline_costs < 0) {
>  char *mname;
>
>
>  mname = mono_method_full_name (method, 1);
>  mono_cfg_set_exception (cfg, MONO_EXCEPTION_INVALID_PROGRAM);
>  cfg->exception_message = monoeg_g_strdup_printf ("Method %s is too complex.", mname);
>  monoeg_g_free (mname);
>  cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, header);
>  mono_basic_block_free (original_bb);
>  return -1;
> }
>
> if ((cfg->verbose_level > 2) && (cfg->method == method))
>  mono_print_code (cfg, "AFTER METHOD-TO-IR");
>
> cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, header);
> mono_basic_block_free (original_bb);
> return inline_costs;
>
> exception_exit:
> do { if (!(cfg->exception_type != MONO_EXCEPTION_NONE)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 10541, "cfg->exception_type != MONO_EXCEPTION_NONE"); } while (0);
> goto cleanup;
>
> inline_failure:
> goto cleanup;
>
> load_error:
> mono_cfg_set_exception (cfg, MONO_EXCEPTION_TYPE_LOAD);
> goto cleanup;
>
> unverified:
> set_exception_type_from_invalid_il (cfg, method, ip);
> goto cleanup;
>
> cleanup:
> monoeg_g_slist_free (class_inits);
> mono_basic_block_free (original_bb);
> dont_inline = monoeg_g_list_remove (dont_inline, method);
> cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, header);
> return -1;
>}
>
>static int
>store_membase_reg_to_store_membase_imm (int opcode)
>{
> switch (opcode) {
> case OP_STORE_MEMBASE_REG:
>  return OP_STORE_MEMBASE_IMM;
> case OP_STOREI1_MEMBASE_REG:
>  return OP_STOREI1_MEMBASE_IMM;
> case OP_STOREI2_MEMBASE_REG:
>  return OP_STOREI2_MEMBASE_IMM;
> case OP_STOREI4_MEMBASE_REG:
>  return OP_STOREI4_MEMBASE_IMM;
> case OP_STOREI8_MEMBASE_REG:
>  return OP_STOREI8_MEMBASE_IMM;
> default:
>  do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 10578); } while (0);
> }
>
> return -1;
>}
>
>
>
>int
>mono_op_to_op_imm (int opcode)
>{
> switch (opcode) {
> case OP_IADD:
>  return OP_IADD_IMM;
> case OP_ISUB:
>  return OP_ISUB_IMM;
> case OP_IDIV:
>  return OP_IDIV_IMM;
> case OP_IDIV_UN:
>  return OP_IDIV_UN_IMM;
> case OP_IREM:
>  return OP_IREM_IMM;
> case OP_IREM_UN:
>  return OP_IREM_UN_IMM;
> case OP_IMUL:
>  return OP_IMUL_IMM;
> case OP_IAND:
>  return OP_IAND_IMM;
> case OP_IOR:
>  return OP_IOR_IMM;
> case OP_IXOR:
>  return OP_IXOR_IMM;
> case OP_ISHL:
>  return OP_ISHL_IMM;
> case OP_ISHR:
>  return OP_ISHR_IMM;
> case OP_ISHR_UN:
>  return OP_ISHR_UN_IMM;
>
> case OP_LADD:
>  return OP_LADD_IMM;
> case OP_LSUB:
>  return OP_LSUB_IMM;
> case OP_LAND:
>  return OP_LAND_IMM;
> case OP_LOR:
>  return OP_LOR_IMM;
> case OP_LXOR:
>  return OP_LXOR_IMM;
> case OP_LSHL:
>  return OP_LSHL_IMM;
> case OP_LSHR:
>  return OP_LSHR_IMM;
> case OP_LSHR_UN:
>  return OP_LSHR_UN_IMM;
>
> case OP_COMPARE:
>  return OP_COMPARE_IMM;
> case OP_ICOMPARE:
>  return OP_ICOMPARE_IMM;
> case OP_LCOMPARE:
>  return OP_LCOMPARE_IMM;
>
> case OP_STORE_MEMBASE_REG:
>  return OP_STORE_MEMBASE_IMM;
> case OP_STOREI1_MEMBASE_REG:
>  return OP_STOREI1_MEMBASE_IMM;
> case OP_STOREI2_MEMBASE_REG:
>  return OP_STOREI2_MEMBASE_IMM;
> case OP_STOREI4_MEMBASE_REG:
>  return OP_STOREI4_MEMBASE_IMM;
># 10660 "method-to-ir.c"
> case OP_VOIDCALL_REG:
>  return OP_VOIDCALL;
> case OP_CALL_REG:
>  return OP_CALL;
> case OP_LCALL_REG:
>  return OP_LCALL;
> case OP_FCALL_REG:
>  return OP_FCALL;
> case OP_LOCALLOC:
>  return OP_LOCALLOC_IMM;
> }
>
> return -1;
>}
>
>static int
>ldind_to_load_membase (int opcode)
>{
> switch (opcode) {
> case CEE_LDIND_I1:
>  return OP_LOADI1_MEMBASE;
> case CEE_LDIND_U1:
>  return OP_LOADU1_MEMBASE;
> case CEE_LDIND_I2:
>  return OP_LOADI2_MEMBASE;
> case CEE_LDIND_U2:
>  return OP_LOADU2_MEMBASE;
> case CEE_LDIND_I4:
>  return OP_LOADI4_MEMBASE;
> case CEE_LDIND_U4:
>  return OP_LOADU4_MEMBASE;
> case CEE_LDIND_I:
>  return OP_LOAD_MEMBASE;
> case CEE_LDIND_REF:
>  return OP_LOAD_MEMBASE;
> case CEE_LDIND_I8:
>  return OP_LOADI8_MEMBASE;
> case CEE_LDIND_R4:
>  return OP_LOADR4_MEMBASE;
> case CEE_LDIND_R8:
>  return OP_LOADR8_MEMBASE;
> default:
>  do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 10702); } while (0);
> }
>
> return -1;
>}
>
>static int
>stind_to_store_membase (int opcode)
>{
> switch (opcode) {
> case CEE_STIND_I1:
>  return OP_STOREI1_MEMBASE_REG;
> case CEE_STIND_I2:
>  return OP_STOREI2_MEMBASE_REG;
> case CEE_STIND_I4:
>  return OP_STOREI4_MEMBASE_REG;
> case CEE_STIND_I:
> case CEE_STIND_REF:
>  return OP_STORE_MEMBASE_REG;
> case CEE_STIND_I8:
>  return OP_STOREI8_MEMBASE_REG;
> case CEE_STIND_R4:
>  return OP_STORER4_MEMBASE_REG;
> case CEE_STIND_R8:
>  return OP_STORER8_MEMBASE_REG;
> default:
>  do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 10728); } while (0);
> }
>
> return -1;
>}
>
>int
>mono_load_membase_to_load_mem (int opcode)
>{
># 10757 "method-to-ir.c"
> return -1;
>}
>
>static inline int
>op_to_op_dest_membase (int store_opcode, int opcode)
>{
># 10853 "method-to-ir.c"
> return -1;
>}
>
>static inline int
>op_to_op_store_membase (int store_opcode, int opcode)
>{
># 10870 "method-to-ir.c"
> return -1;
>}
>
>static inline int
>op_to_op_src1_membase (int load_opcode, int opcode)
>{
># 10942 "method-to-ir.c"
> return -1;
>}
>
>static inline int
>op_to_op_src2_membase (int load_opcode, int opcode)
>{
># 11012 "method-to-ir.c"
> return -1;
>}
>
>int
>mono_op_to_op_imm_noemul (int opcode)
>{
> switch (opcode) {
># 11032 "method-to-ir.c"
> default:
>  return mono_op_to_op_imm (opcode);
> }
>}
># 11045 "method-to-ir.c"
>void
>mono_handle_global_vregs (MonoCompile *cfg)
>{
> gint32 *vreg_to_bb;
> MonoBasicBlock *bb;
> int i, pos;
>
> vreg_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (gint32*) * cfg->next_vreg + 1);
>
>
>
>
>
>
>
> for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
>  MonoInst *ins = bb->code;
>  int block_num = bb->block_num;
>
>  if (cfg->verbose_level > 2)
>   printf ("\nHANDLE-GLOBAL-VREGS BLOCK %d:\n", bb->block_num);
>
>  cfg->cbb = bb;
>  for (; ins; ins = ins->next) {
>   const char *spec = (&ins_info [((ins->opcode) - OP_START - 1) * 4]);
>   int regtype = 0, regindex;
>   gint32 prev_bb;
>
>   if ((__builtin_expect ((cfg->verbose_level > 2) != 0, 0)))
>    mono_print_ins (ins);
>
>   do { if (!(ins->opcode >= MONO_CEE_LAST)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11076, "ins->opcode >= MONO_CEE_LAST"); } while (0);
>
>   for (regindex = 0; regindex < 4; regindex ++) {
>    int vreg = 0;
>
>    if (regindex == 0) {
>     regtype = spec [MONO_INST_DEST];
>     if (regtype == ' ')
>      continue;
>     vreg = ins->dreg;
>    } else if (regindex == 1) {
>     regtype = spec [MONO_INST_SRC1];
>     if (regtype == ' ')
>      continue;
>     vreg = ins->sreg1;
>    } else if (regindex == 2) {
>     regtype = spec [MONO_INST_SRC2];
>     if (regtype == ' ')
>      continue;
>     vreg = ins->sreg2;
>    } else if (regindex == 3) {
>     regtype = spec [MONO_INST_SRC3];
>     if (regtype == ' ')
>      continue;
>     vreg = ins->sreg3;
>    }
># 11127 "method-to-ir.c"
>    do { if (!(vreg != -1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11127, "vreg != -1"); } while (0);
>
>    prev_bb = vreg_to_bb [vreg];
>    if (prev_bb == 0) {
>
>     vreg_to_bb [vreg] = block_num + 1;
>    } else if ((prev_bb != block_num + 1) && (prev_bb != -1)) {
>     if (((regtype == 'i' && (vreg < 16))) || (regtype == 'f' && (vreg < 16)))
>      continue;
>
>     if (!((vreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(vreg)] : ((void *)0))) {
>      if ((__builtin_expect ((cfg->verbose_level > 2) != 0, 0)))
>       printf ("VREG R%d used in BB%d and BB%d made global.\n", vreg, vreg_to_bb [vreg], block_num);
>
>      switch (regtype) {
>      case 'i':
>       if (0)
>        mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, vreg);
>       else
>        mono_compile_create_var_for_vreg (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL, vreg);
>       break;
>      case 'l':
>       mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
>       break;
>      case 'f':
>       mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
>       break;
>      case 'v':
>       mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, vreg);
>       break;
>      default:
>       do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 11158); } while (0);
>      }
>     }
>
>
>     vreg_to_bb [vreg] = -1;
>    }
>   }
>  }
> }
>
>
> for (i = 0; i < cfg->num_varinfo; i++) {
>  MonoInst *var = cfg->varinfo [i];
>  MonoMethodVar *vmv = (&(cfg)->vars [i]);
>
>  switch (var->type) {
>  case STACK_I4:
>  case STACK_OBJ:
>  case STACK_PTR:
>  case STACK_MP:
>  case STACK_VTYPE:
>
>  case STACK_I8:
>
>
>
>  case STACK_R8:
>
>
>
>   if ((var->opcode != OP_ARG) && (var != cfg->ret) && !(var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) && (vreg_to_bb [var->dreg] != -1) && (var->klass->byval_arg.type != MONO_TYPE_R4) && !cfg->disable_vreg_to_lvreg) {
># 11230 "method-to-ir.c"
>    if ((__builtin_expect ((cfg->verbose_level > 2) != 0, 0)))
>     printf ("CONVERTED R%d(%d) TO VREG.\n", var->dreg, vmv->idx);
>    var->flags |= MONO_INST_IS_DEAD;
>    cfg->vreg_to_inst [var->dreg] = ((void *)0);
>   }
>   break;
>  }
> }
>
>
>
>
>
> pos = 0;
> for (i = 0; i < cfg->num_varinfo; ++i) {
>  MonoInst *var = cfg->varinfo [i];
>  if (pos < i && cfg->locals_start == i)
>   cfg->locals_start = pos;
>  if (!(var->flags & MONO_INST_IS_DEAD)) {
>   if (pos < i) {
>    cfg->varinfo [pos] = cfg->varinfo [i];
>    cfg->varinfo [pos]->data.op[0].const_val = pos;
>    memcpy (&cfg->vars [pos], &cfg->vars [i], sizeof (MonoMethodVar));
>    cfg->vars [pos].idx = pos;
># 11265 "method-to-ir.c"
>   }
>   pos ++;
>  }
> }
> cfg->num_varinfo = pos;
> if (cfg->locals_start > cfg->num_varinfo)
>  cfg->locals_start = cfg->num_varinfo;
>}
># 11281 "method-to-ir.c"
>void
>mono_spill_global_vars (MonoCompile *cfg, gboolean *need_local_opts)
>{
> MonoBasicBlock *bb;
> char spec2 [16];
> int orig_next_vreg;
> guint32 *vreg_to_lvreg;
> guint32 *lvregs;
> guint32 i, lvregs_len;
> gboolean dest_has_lvreg = 0;
> guint32 stacktypes [128];
> MonoInst **live_range_start, **live_range_end;
> MonoBasicBlock **live_range_start_bb, **live_range_end_bb;
>
> *need_local_opts = 0;
>
> memset (spec2, 0, sizeof (spec2));
>
>
> stacktypes ['i'] = STACK_PTR;
> stacktypes ['l'] = STACK_I8;
> stacktypes ['f'] = STACK_R8;
># 11343 "method-to-ir.c"
> if (cfg->compute_gc_maps) {
>
>  for (i = 0; i < cfg->num_varinfo; i++) {
>   MonoInst *ins = cfg->varinfo [i];
>
>   if (ins->opcode == OP_REGVAR)
>    ins->flags |= MONO_INST_GC_TRACK;
>  }
> }
># 11360 "method-to-ir.c"
> orig_next_vreg = cfg->next_vreg;
> vreg_to_lvreg = mono_mempool_alloc0 (cfg->mempool, sizeof (guint32) * cfg->next_vreg);
> lvregs = mono_mempool_alloc (cfg->mempool, sizeof (guint32) * 1024);
> lvregs_len = 0;
># 11378 "method-to-ir.c"
> live_range_start = ((MonoInst* *) monoeg_malloc0 (sizeof (MonoInst*)* (cfg->next_vreg)));
> live_range_end = ((MonoInst* *) monoeg_malloc0 (sizeof (MonoInst*)* (cfg->next_vreg)));
> live_range_start_bb = ((MonoBasicBlock* *) monoeg_malloc (sizeof (MonoBasicBlock*) * (cfg->next_vreg)));
> live_range_end_bb = ((MonoBasicBlock* *) monoeg_malloc (sizeof (MonoBasicBlock*) * (cfg->next_vreg)));
>
>
> for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
>  MonoInst *ins;
>
>  if (cfg->verbose_level > 2)
>   printf ("\nSPILL BLOCK %d:\n", bb->block_num);
>
>
>  for (i = 0; i < lvregs_len; i++)
>   vreg_to_lvreg [lvregs [i]] = 0;
>  lvregs_len = 0;
>
>  cfg->cbb = bb;
>  for ((ins) = (bb)->code; (ins); (ins) = (ins)->next) {
>   const char *spec = (&ins_info [((ins->opcode) - OP_START - 1) * 4]);
>   int regtype, srcindex, sreg, tmp_reg, prev_dreg, num_sregs;
>   gboolean store, no_lvreg;
>   int sregs [3];
>
>   if ((__builtin_expect ((cfg->verbose_level > 2) != 0, 0)))
>    mono_print_ins (ins);
>
>   if (ins->opcode == OP_NOP)
>    continue;
>
>
>
>
>
>   if (ins->opcode == OP_LDADDR) {
>    MonoInst *var = ins->data.op[0].p;
>
>    if (var->opcode == OP_VTARG_ADDR) {
>
>     MonoInst *vtaddr = var->data.op[0].src;
>     if (vtaddr->opcode == OP_REGVAR) {
>      ins->opcode = OP_MOVE;
>      ins->sreg1 = vtaddr->dreg;
>     }
>     else if (var->data.op[0].src->opcode == OP_REGOFFSET) {
>      ins->opcode = OP_LOAD_MEMBASE;
>      ins->sreg1 = vtaddr->sreg1;
>      ins->data.op[0].const_val = vtaddr->data.op[0].const_val;
>     } else
>      do { do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 11427); } while (0); } while (0);
>    } else {
>     do { if (!(var->opcode == OP_REGOFFSET)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11429, "var->opcode == OP_REGOFFSET"); } while (0);
>
>     ins->opcode = OP_ADD_IMM;
>     ins->sreg1 = var->sreg1;
>     ins->data.op[1].const_val = var->data.op[0].const_val;
>    }
>
>    *need_local_opts = 1;
>    spec = (&ins_info [((ins->opcode) - OP_START - 1) * 4]);
>   }
>
>   if (ins->opcode < MONO_CEE_LAST) {
>    mono_print_ins (ins);
>    do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 11442); } while (0);
>   }
>
>
>
>
>
>
>   if ((((ins)->opcode >= OP_STORE_MEMBASE_REG) && ((ins)->opcode <= OP_STOREV_MEMBASE))) {
>    tmp_reg = ins->dreg;
>    ins->dreg = ins->sreg2;
>    ins->sreg2 = tmp_reg;
>    store = 1;
>
>    spec2 [MONO_INST_DEST] = ' ';
>    spec2 [MONO_INST_SRC1] = spec [MONO_INST_SRC1];
>    spec2 [MONO_INST_SRC2] = spec [MONO_INST_DEST];
>    spec2 [MONO_INST_SRC3] = ' ';
>    spec = spec2;
>   } else if ((((ins)->opcode >= OP_STORE_MEMINDEX) && ((ins)->opcode <= OP_STORER8_MEMINDEX)))
>    do { monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 11462); } while (0);
>   else
>    store = 0;
>   no_lvreg = 0;
>
>   if ((__builtin_expect ((cfg->verbose_level > 2) != 0, 0))) {
>    printf ("\t %.3s %d", spec, ins->dreg);
>    num_sregs = (((sregs) [0] = (ins)->sreg1), ((sregs) [1] = (ins)->sreg2), ((sregs) [2] = (ins)->sreg3), (ins_sreg_counts [((ins))->opcode - OP_START - 1]));
>    for (srcindex = 0; srcindex < 3; ++srcindex)
>     printf (" %d", sregs [srcindex]);
>    printf ("\n");
>   }
>
>
>
>
>   regtype = spec [MONO_INST_DEST];
>   do { if (!(((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')))) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11479, "((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' '))"); } while (0);
>   prev_dreg = -1;
>
>   if ((ins->dreg != -1) && ((ins->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(ins->dreg)] : ((void *)0))) {
>    MonoInst *var = ((ins->dreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(ins->dreg)] : ((void *)0));
>    MonoInst *store_ins;
>    int store_opcode;
>    MonoInst *def_ins = ins;
>    int dreg = ins->dreg;
>
>    store_opcode = mono_type_to_store_membase (cfg, var->data.op[1].vtype);
>
>    if (var->opcode == OP_REGVAR) {
>     ins->dreg = var->dreg;
>    } else if ((ins->dreg == ins->sreg1) && (spec [MONO_INST_DEST] == 'i') && (spec [MONO_INST_SRC1] == 'i') && !vreg_to_lvreg [ins->dreg] && (op_to_op_dest_membase (store_opcode, ins->opcode) != -1)) {
>
>
>
>     do { if (!(var->opcode == OP_REGOFFSET)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11497, "var->opcode == OP_REGOFFSET"); } while (0);
>     if (ins->opcode == OP_MOVE) {
>      do { (ins)->opcode = OP_NOP; (ins)->dreg = -1; do { ((ins))->sreg1 = ((ins))->sreg2 = ((ins))->sreg3 = -1; } while (0); } while (0);
>      def_ins = ((void *)0);
>     } else {
>      ins->opcode = op_to_op_dest_membase (store_opcode, ins->opcode);
>      ins->sreg1 = var->sreg1;
>      ins->data.op[0].const_val = var->data.op[0].const_val;
>      ins->dreg = -1;
>     }
>     spec = (&ins_info [((ins->opcode) - OP_START - 1) * 4]);
>    } else {
>     guint32 lvreg;
>
>     do { if (!(var->opcode == OP_REGOFFSET)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11511, "var->opcode == OP_REGOFFSET"); } while (0);
>
>     prev_dreg = ins->dreg;
>
>
>     vreg_to_lvreg [ins->dreg] = 0;
>
>     lvreg = 0;
>
>     if (0 && store_opcode == OP_STORER8_MEMBASE_REG) {
>      regtype = 'l';
>      store_opcode = OP_STOREI8_MEMBASE_REG;
>     }
>
>     ins->dreg = alloc_dreg (cfg, stacktypes [regtype]);
>
>     if (regtype == 'l') {
>      do { do { ((store_ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((store_ins))->data.op[0].const_val = ((store_ins))->data.op[1].const_val = 0; ((store_ins))->next = ((store_ins))->prev = ((void *)0); ((store_ins))->opcode = ((OP_STOREI4_MEMBASE_REG)); ((store_ins))->flags = 0; ((store_ins))->type = 0; ((store_ins))->dreg = -1; do { (((store_ins)))->sreg1 = (((store_ins)))->sreg2 = (((store_ins)))->sreg3 = -1; } while (0); ((store_ins))->cil_code = ((cfg))->ip; } while (0); (store_ins)->sreg1 = ins->dreg + 1; (store_ins)->dreg = var->sreg1; (store_ins)->data.op[0].const_val = var->data.op[0].const_val + (1 * 4); } while (0);
>      mono_bblock_insert_after_ins (bb, ins, store_ins);
>      do { do { ((store_ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((store_ins))->data.op[0].const_val = ((store_ins))->data.op[1].const_val = 0; ((store_ins))->next = ((store_ins))->prev = ((void *)0); ((store_ins))->opcode = ((OP_STOREI4_MEMBASE_REG)); ((store_ins))->flags = 0; ((store_ins))->type = 0; ((store_ins))->dreg = -1; do { (((store_ins)))->sreg1 = (((store_ins)))->sreg2 = (((store_ins)))->sreg3 = -1; } while (0); ((store_ins))->cil_code = ((cfg))->ip; } while (0); (store_ins)->sreg1 = ins->dreg + 2; (store_ins)->dreg = var->sreg1; (store_ins)->data.op[0].const_val = var->data.op[0].const_val + (0 * 4); } while (0);
>      mono_bblock_insert_after_ins (bb, ins, store_ins);
>      def_ins = store_ins;
>     }
>     else {
>      do { if (!(store_opcode != OP_STOREV_MEMBASE)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11535, "store_opcode != OP_STOREV_MEMBASE"); } while (0);
>
>
>
>      if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->data.op[0].const_val == 0)))) {
>       ins->opcode = store_membase_reg_to_store_membase_imm (store_opcode);
>       ins->data.op[1].const_val = ins->data.op[0].const_val;
>       ins->dreg = var->sreg1;
>       ins->data.op[0].const_val = var->data.op[0].const_val;
>       spec = (&ins_info [((ins->opcode) - OP_START - 1) * 4]);
>      } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE))) {
>       ins->opcode = store_opcode;
>       ins->dreg = var->sreg1;
>       ins->data.op[0].const_val = var->data.op[0].const_val;
>
>       no_lvreg = 1;
>
>       tmp_reg = ins->dreg;
>       ins->dreg = ins->sreg2;
>       ins->sreg2 = tmp_reg;
>       store = 1;
>
>       spec2 [MONO_INST_DEST] = ' ';
>       spec2 [MONO_INST_SRC1] = spec [MONO_INST_SRC1];
>       spec2 [MONO_INST_SRC2] = spec [MONO_INST_DEST];
>       spec2 [MONO_INST_SRC3] = ' ';
>       spec = spec2;
>      } else if (!lvreg && (op_to_op_store_membase (store_opcode, ins->opcode) != -1)) {
>
>       ins->opcode = op_to_op_store_membase (store_opcode, ins->opcode);
>       ins->dreg = -1;
>       ins->sreg1 = var->sreg1;
>       ins->data.op[0].const_val = var->data.op[0].const_val;
>       spec = (&ins_info [((ins->opcode) - OP_START - 1) * 4]);
>      } else {
>
>
>       do { do { ((store_ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((store_ins))->data.op[0].const_val = ((store_ins))->data.op[1].const_val = 0; ((store_ins))->next = ((store_ins))->prev = ((void *)0); ((store_ins))->opcode = ((store_opcode)); ((store_ins))->flags = 0; ((store_ins))->type = 0; ((store_ins))->dreg = -1; do { (((store_ins)))->sreg1 = (((store_ins)))->sreg2 = (((store_ins)))->sreg3 = -1; } while (0); ((store_ins))->cil_code = ((cfg))->ip; } while (0); (store_ins)->sreg1 = ins->dreg; (store_ins)->dreg = var->sreg1; (store_ins)->data.op[0].const_val = var->data.op[0].const_val; } while (0);
>
>
>       mono_bblock_insert_after_ins (bb, ins, store_ins);
>
>       def_ins = store_ins;
>
>
>
>
>
>
>       if ((!0 || ((store_opcode != OP_STORER8_MEMBASE_REG) && (store_opcode != OP_STORER4_MEMBASE_REG))) && !((var)->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)))
>        dest_has_lvreg = 1;
>      }
>     }
>    }
>
>    if (def_ins && !live_range_start [dreg]) {
>     live_range_start [dreg] = def_ins;
>     live_range_start_bb [dreg] = bb;
>    }
>
>    if (cfg->compute_gc_maps && def_ins && (var->flags & MONO_INST_GC_TRACK)) {
>     MonoInst *tmp;
>
>     do { (tmp) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (tmp)->data.op[0].const_val = (tmp)->data.op[1].const_val = 0; (tmp)->next = (tmp)->prev = ((void *)0); (tmp)->opcode = (OP_GC_LIVENESS_DEF); (tmp)->flags = 0; (tmp)->type = 0; (tmp)->dreg = -1; do { ((tmp))->sreg1 = ((tmp))->sreg2 = ((tmp))->sreg3 = -1; } while (0); (tmp)->cil_code = (cfg)->ip; } while (0);
>     tmp->data.op[1].const_val = dreg;
>     mono_bblock_insert_after_ins (bb, def_ins, tmp);
>    }
>   }
>
>
>
>
>   num_sregs = (((sregs) [0] = (ins)->sreg1), ((sregs) [1] = (ins)->sreg2), ((sregs) [2] = (ins)->sreg3), (ins_sreg_counts [((ins))->opcode - OP_START - 1]));
>   for (srcindex = 0; srcindex < 3; ++srcindex) {
>    regtype = spec [MONO_INST_SRC1 + srcindex];
>    sreg = sregs [srcindex];
>
>    do { if (!(((sreg == -1) && (regtype == ' ')) || ((sreg != -1) && (regtype != ' ')))) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11612, "((sreg == -1) && (regtype == ' ')) || ((sreg != -1) && (regtype != ' '))"); } while (0);
>    if ((sreg != -1) && ((sreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(sreg)] : ((void *)0))) {
>     MonoInst *var = ((sreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(sreg)] : ((void *)0));
>     MonoInst *use_ins = ins;
>     MonoInst *load_ins;
>     guint32 load_opcode;
>
>     if (var->opcode == OP_REGVAR) {
>      sregs [srcindex] = var->dreg;
>
>      live_range_end [sreg] = use_ins;
>      live_range_end_bb [sreg] = bb;
>
>      if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
>       MonoInst *tmp;
>
>       do { (tmp) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (tmp)->data.op[0].const_val = (tmp)->data.op[1].const_val = 0; (tmp)->next = (tmp)->prev = ((void *)0); (tmp)->opcode = (OP_GC_LIVENESS_USE); (tmp)->flags = 0; (tmp)->type = 0; (tmp)->dreg = -1; do { ((tmp))->sreg1 = ((tmp))->sreg2 = ((tmp))->sreg3 = -1; } while (0); (tmp)->cil_code = (cfg)->ip; } while (0);
>
>       tmp->data.op[1].const_val = sreg;
>       mono_bblock_insert_after_ins (bb, ins, tmp);
>      }
>
>      continue;
>     }
>
>     do { if (!(var->opcode == OP_REGOFFSET)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11637, "var->opcode == OP_REGOFFSET"); } while (0);
>
>     load_opcode = mono_type_to_load_membase (cfg, var->data.op[1].vtype);
>
>     do { if (!(load_opcode != OP_LOADV_MEMBASE)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11641, "load_opcode != OP_LOADV_MEMBASE"); } while (0);
>
>     if (vreg_to_lvreg [sreg]) {
>      do { if (!(vreg_to_lvreg [sreg] != -1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11644, "vreg_to_lvreg [sreg] != -1"); } while (0);
>
>
>      if ((__builtin_expect ((cfg->verbose_level > 2) != 0, 0)))
>       printf ("\t\tUse lvreg R%d for R%d.\n", vreg_to_lvreg [sreg], sreg);
>      sregs [srcindex] = vreg_to_lvreg [sreg];
>
>      continue;
>     }
>
>
>     if ((srcindex == 0) && (op_to_op_src1_membase (load_opcode, ins->opcode) != -1)) {
>      ins->opcode = op_to_op_src1_membase (load_opcode, ins->opcode);
>      sregs [0] = var->sreg1;
>
>      ins->data.op[0].const_val = var->data.op[0].const_val;
>     } else if ((srcindex == 1) && (op_to_op_src2_membase (load_opcode, ins->opcode) != -1)) {
>      ins->opcode = op_to_op_src2_membase (load_opcode, ins->opcode);
>      sregs [1] = var->sreg1;
>
>      ins->data.op[0].const_val = var->data.op[0].const_val;
>     } else {
>      if ((((ins)->opcode == OP_MOVE) || ((ins)->opcode == OP_FMOVE))) {
>       ins->opcode = OP_NOP;
>       sreg = ins->dreg;
>      } else {
>
>
>       sreg = alloc_dreg (cfg, stacktypes [regtype]);
>
>       if ((!0 || ((load_opcode != OP_LOADR8_MEMBASE) && (load_opcode != OP_LOADR4_MEMBASE))) && !((var)->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) && !no_lvreg) {
>        if (var->dreg == prev_dreg) {
>
>
>
>
>
>         sreg = ins->dreg;
>        }
>        do { if (!(sreg != -1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11683, "sreg != -1"); } while (0);
>        vreg_to_lvreg [var->dreg] = sreg;
>        do { if (!(lvregs_len < 1024)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11685, "lvregs_len < 1024"); } while (0);
>        lvregs [lvregs_len ++] = var->dreg;
>       }
>      }
>
>      sregs [srcindex] = sreg;
>
>
>      if (regtype == 'l') {
>       do { do { ((load_ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((load_ins))->data.op[0].const_val = ((load_ins))->data.op[1].const_val = 0; ((load_ins))->next = ((load_ins))->prev = ((void *)0); ((load_ins))->opcode = ((OP_LOADI4_MEMBASE)); ((load_ins))->flags = 0; ((load_ins))->type = 0; ((load_ins))->dreg = -1; do { (((load_ins)))->sreg1 = (((load_ins)))->sreg2 = (((load_ins)))->sreg3 = -1; } while (0); ((load_ins))->cil_code = ((cfg))->ip; } while (0); (load_ins)->dreg = (sreg + 2); (load_ins)->sreg1 = (var->sreg1); (load_ins)->data.op[0].const_val = (var->data.op[0].const_val + (0 * 4)); (load_ins)->type = STACK_I4; } while (0);
>       mono_bblock_insert_before_ins (bb, ins, load_ins);
>       do { do { ((load_ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((load_ins))->data.op[0].const_val = ((load_ins))->data.op[1].const_val = 0; ((load_ins))->next = ((load_ins))->prev = ((void *)0); ((load_ins))->opcode = ((OP_LOADI4_MEMBASE)); ((load_ins))->flags = 0; ((load_ins))->type = 0; ((load_ins))->dreg = -1; do { (((load_ins)))->sreg1 = (((load_ins)))->sreg2 = (((load_ins)))->sreg3 = -1; } while (0); ((load_ins))->cil_code = ((cfg))->ip; } while (0); (load_ins)->dreg = (sreg + 1); (load_ins)->sreg1 = (var->sreg1); (load_ins)->data.op[0].const_val = (var->data.op[0].const_val + (1 * 4)); (load_ins)->type = STACK_I4; } while (0);
>       mono_bblock_insert_before_ins (bb, ins, load_ins);
>       use_ins = load_ins;
>      }
>      else {
>
>
>
>       do { do { ((load_ins)) = mono_mempool_alloc (((cfg))->mempool, sizeof (MonoInst)); ((load_ins))->data.op[0].const_val = ((load_ins))->data.op[1].const_val = 0; ((load_ins))->next = ((load_ins))->prev = ((void *)0); ((load_ins))->opcode = ((load_opcode)); ((load_ins))->flags = 0; ((load_ins))->type = 0; ((load_ins))->dreg = -1; do { (((load_ins)))->sreg1 = (((load_ins)))->sreg2 = (((load_ins)))->sreg3 = -1; } while (0); ((load_ins))->cil_code = ((cfg))->ip; } while (0); (load_ins)->dreg = (sreg); (load_ins)->sreg1 = (var->sreg1); (load_ins)->data.op[0].const_val = (var->data.op[0].const_val); (load_ins)->type = STACK_I4; } while (0);
>       mono_bblock_insert_before_ins (bb, ins, load_ins);
>       use_ins = load_ins;
>      }
>     }
>
>     if (var->dreg < orig_next_vreg) {
>      live_range_end [var->dreg] = use_ins;
>      live_range_end_bb [var->dreg] = bb;
>     }
>
>     if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
>      MonoInst *tmp;
>
>      do { (tmp) = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoInst)); (tmp)->data.op[0].const_val = (tmp)->data.op[1].const_val = 0; (tmp)->next = (tmp)->prev = ((void *)0); (tmp)->opcode = (OP_GC_LIVENESS_USE); (tmp)->flags = 0; (tmp)->type = 0; (tmp)->dreg = -1; do { ((tmp))->sreg1 = ((tmp))->sreg2 = ((tmp))->sreg3 = -1; } while (0); (tmp)->cil_code = (cfg)->ip; } while (0);
>      tmp->data.op[1].const_val = var->dreg;
>      mono_bblock_insert_after_ins (bb, ins, tmp);
>     }
>    }
>   }
>   mono_inst_set_src_registers (ins, sregs);
>
>   if (dest_has_lvreg) {
>    do { if (!(ins->dreg != -1)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11727, "ins->dreg != -1"); } while (0);
>    vreg_to_lvreg [prev_dreg] = ins->dreg;
>    do { if (!(lvregs_len < 1024)) monoeg_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", "method-to-ir.c", 11729, "lvregs_len < 1024"); } while (0);
>    lvregs [lvregs_len ++] = prev_dreg;
>    dest_has_lvreg = 0;
>   }
>
>   if (store) {
>    tmp_reg = ins->dreg;
>    ins->dreg = ins->sreg2;
>    ins->sreg2 = tmp_reg;
>   }
>
>   if ((((ins->opcode >= OP_VOIDCALL) && (ins->opcode <= OP_VOIDCALL_MEMBASE)) || ((ins->opcode >= OP_FCALL) && (ins->opcode <= OP_FCALL_MEMBASE)) || ((ins->opcode >= OP_LCALL) && (ins->opcode <= OP_LCALL_MEMBASE)) || ((ins->opcode >= OP_VCALL) && (ins->opcode <= OP_VCALL_MEMBASE)) || ((ins->opcode >= OP_CALL) && (ins->opcode <= OP_CALL_MEMBASE)) || ((ins->opcode >= OP_VCALL2) && (ins->opcode <= OP_VCALL2_MEMBASE)) || (ins->opcode == OP_TAILCALL))) {
>
>    for (i = 0; i < lvregs_len; i++)
>     vreg_to_lvreg [lvregs [i]] = 0;
>    lvregs_len = 0;
>   } else if (ins->opcode == OP_NOP) {
>    ins->dreg = -1;
>    do { (ins)->sreg1 = (ins)->sreg2 = (ins)->sreg3 = -1; } while (0);
>   }
>
>   if (cfg->verbose_level > 2)
>    mono_print_ins_index (1, ins);
>  }
>
>
>  if (cfg->compute_precise_live_ranges && bb->live_out_set && bb->code) {
>   for (i = 0; i < cfg->num_varinfo; i ++) {
>    MonoMethodVar *vi = (&(cfg)->vars [i]);
>
>    if (((__builtin_expect (((((vi->vreg)) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [((vi->vreg))] : ((void *)0)) && ((((vi->vreg)) < ((cfg))->vreg_to_inst_len ? ((cfg))->vreg_to_inst [((vi->vreg))] : ((void *)0))->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT))) != 0, 0))))
>
>     continue;
>
>    if (((bb->live_in_set)->data [(i)/(8 * sizeof (gsize))] & ((gsize)1 << ((i) % (8 * sizeof (gsize))))) && !live_range_start [vi->vreg]) {
>
>     live_range_start [vi->vreg] = bb->code;
>     live_range_start_bb [vi->vreg] = bb;
>    }
>
>    if (((bb->live_out_set)->data [(i)/(8 * sizeof (gsize))] & ((gsize)1 << ((i) % (8 * sizeof (gsize)))))) {
>
>     live_range_end [vi->vreg] = bb->last_ins;
>     live_range_end_bb [vi->vreg] = bb;
>    }
>   }
>  }
> }
># 11807 "method-to-ir.c"
> monoeg_g_free (live_range_start);
> monoeg_g_free (live_range_end);
> monoeg_g_free (live_range_start_bb);
> monoeg_g_free (live_range_end_bb);
>}

Actions: View

Attachments on bug 1136939: 934142