From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([140.186.70.92]:45290) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1QO6g7-0007PJ-JC for qemu-devel@nongnu.org; Sun, 22 May 2011 07:18:38 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1QO6g4-0005Ih-Cu for qemu-devel@nongnu.org; Sun, 22 May 2011 07:18:35 -0400 Received: from mail-qw0-f45.google.com ([209.85.216.45]:49317) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1QO6g4-0005HB-8q for qemu-devel@nongnu.org; Sun, 22 May 2011 07:18:32 -0400 Received: by mail-qw0-f45.google.com with SMTP id 8so2888117qwj.4 for ; Sun, 22 May 2011 04:18:32 -0700 (PDT) MIME-Version: 1.0 From: Blue Swirl Date: Sun, 22 May 2011 14:18:12 +0300 Message-ID: Content-Type: multipart/mixed; boundary=0016367b6392da4d6904a3db832e Subject: [Qemu-devel] [PATCH 8/9] Move cpu_has_work and cpu_pc_from_tb to cpu.h List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel --0016367b6392da4d6904a3db832e Content-Type: text/plain; charset=UTF-8 Move functions cpu_has_work() and cpu_pc_from_tb() from exec.h to cpu.h. This is needed by later patches. Signed-off-by: Blue Swirl --- exec-all.h | 1 + target-alpha/cpu.h | 12 +++++++++++ target-alpha/exec.h | 10 --------- target-arm/cpu.h | 13 ++++++++++++ target-arm/exec.h | 12 ----------- target-cris/cpu.h | 11 ++++++++++ target-cris/exec.h | 11 ---------- target-i386/cpu.h | 47 ++++++++++++++++++++++++++++++++++++++++++++++ target-i386/exec.h | 46 --------------------------------------------- target-lm32/cpu.h | 13 ++++++++++++ target-lm32/exec.h | 11 ---------- target-m68k/cpu.h | 12 +++++++++++ target-m68k/exec.h | 11 ---------- target-microblaze/cpu.h | 13 ++++++++++++ target-microblaze/exec.h | 11 ---------- target-mips/cpu.h | 24 +++++++++++++++++++++++ target-mips/exec.h | 22 --------------------- target-ppc/cpu.h | 12 +++++++++++ target-ppc/exec.h | 11 ---------- target-sh4/cpu.h | 13 ++++++++++++ target-sh4/exec.h | 11 ---------- target-sparc/cpu.h | 14 +++++++++++++ target-sparc/exec.h | 14 ------------- target-unicore32/cpu.h | 6 +++++ target-unicore32/exec.h | 6 ----- xen-mapcache-stub.c | 1 + 26 files changed, 192 insertions(+), 176 deletions(-) diff --git a/exec-all.h b/exec-all.h index 1862428..e9533f3 100644 --- a/exec-all.h +++ b/exec-all.h @@ -40,6 +40,7 @@ typedef ram_addr_t tb_page_addr_t; #define DISAS_UPDATE 2 /* cpu state was modified dynamically */ #define DISAS_TB_JUMP 3 /* only pc was modified statically */ +struct TranslationBlock; typedef struct TranslationBlock TranslationBlock; /* XXX: make safe guess about sizes */ diff --git a/target-alpha/cpu.h b/target-alpha/cpu.h index 686fb4a..359b2b6 100644 --- a/target-alpha/cpu.h +++ b/target-alpha/cpu.h @@ -535,4 +535,16 @@ static inline void cpu_set_tls(CPUState *env, target_ulong newtls) } #endif +static inline int cpu_has_work(CPUState *env) +{ + return env->interrupt_request & CPU_INTERRUPT_HARD; +} + +#include "exec-all.h" + +static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) +{ + env->pc = tb->pc; +} + #endif /* !defined (__CPU_ALPHA_H__) */ diff --git a/target-alpha/exec.h b/target-alpha/exec.h index 26c3a3a..f508996 100644 --- a/target-alpha/exec.h +++ b/target-alpha/exec.h @@ -37,14 +37,4 @@ register struct CPUAlphaState *env asm(AREG0); #include "softmmu_exec.h" #endif /* !defined(CONFIG_USER_ONLY) */ -static inline int cpu_has_work(CPUState *env) -{ - return env->interrupt_request & CPU_INTERRUPT_HARD; -} - -static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) -{ - env->pc = tb->pc; -} - #endif /* !defined (__ALPHA_EXEC_H__) */ diff --git a/target-arm/cpu.h b/target-arm/cpu.h index 01f5b57..bb54363 100644 --- a/target-arm/cpu.h +++ b/target-arm/cpu.h @@ -512,4 +512,17 @@ static inline void cpu_get_tb_cpu_state(CPUState *env, target_ulong *pc, } } +static inline int cpu_has_work(CPUState *env) +{ + return env->interrupt_request & + (CPU_INTERRUPT_FIQ | CPU_INTERRUPT_HARD | CPU_INTERRUPT_EXITTB); +} + +#include "exec-all.h" + +static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) +{ + env->regs[15] = tb->pc; +} + #endif diff --git a/target-arm/exec.h b/target-arm/exec.h index ef497d8..68d6fb9 100644 --- a/target-arm/exec.h +++ b/target-arm/exec.h @@ -26,20 +26,8 @@ register struct CPUARMState *env asm(AREG0); #include "cpu.h" #include "exec-all.h" -static inline int cpu_has_work(CPUState *env) -{ - return env->interrupt_request & - (CPU_INTERRUPT_FIQ | CPU_INTERRUPT_HARD | CPU_INTERRUPT_EXITTB); -} - #if !defined(CONFIG_USER_ONLY) #include "softmmu_exec.h" #endif void raise_exception(int); - -static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) -{ - env->regs[15] = tb->pc; -} - diff --git a/target-cris/cpu.h b/target-cris/cpu.h index 2bc35e4..adbc38b 100644 --- a/target-cris/cpu.h +++ b/target-cris/cpu.h @@ -268,4 +268,15 @@ static inline void cpu_get_tb_cpu_state(CPUState *env, target_ulong *pc, #define cpu_list cris_cpu_list void cris_cpu_list(FILE *f, fprintf_function cpu_fprintf); +static inline int cpu_has_work(CPUState *env) +{ + return env->interrupt_request & (CPU_INTERRUPT_HARD | CPU_INTERRUPT_NMI); +} + +#include "exec-all.h" + +static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) +{ + env->pc = tb->pc; +} #endif diff --git a/target-cris/exec.h b/target-cris/exec.h index 491f17c..9838159 100644 --- a/target-cris/exec.h +++ b/target-cris/exec.h @@ -27,14 +27,3 @@ register struct CPUCRISState *env asm(AREG0); #if !defined(CONFIG_USER_ONLY) #include "softmmu_exec.h" #endif - -static inline int cpu_has_work(CPUState *env) -{ - return env->interrupt_request & (CPU_INTERRUPT_HARD | CPU_INTERRUPT_NMI); -} - -static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) -{ - env->pc = tb->pc; -} - diff --git a/target-i386/cpu.h b/target-i386/cpu.h index 714f049..092827f 100644 --- a/target-i386/cpu.h +++ b/target-i386/cpu.h @@ -960,6 +960,36 @@ static inline int cpu_mmu_index (CPUState *env) return (env->hflags & HF_CPL_MASK) == 3 ? 1 : 0; } +#undef EAX +#define EAX (env->regs[R_EAX]) +#undef ECX +#define ECX (env->regs[R_ECX]) +#undef EDX +#define EDX (env->regs[R_EDX]) +#undef EBX +#define EBX (env->regs[R_EBX]) +#undef ESP +#define ESP (env->regs[R_ESP]) +#undef EBP +#define EBP (env->regs[R_EBP]) +#undef ESI +#define ESI (env->regs[R_ESI]) +#undef EDI +#define EDI (env->regs[R_EDI]) +#undef EIP +#define EIP (env->eip) +#define DF (env->df) + +#define CC_SRC (env->cc_src) +#define CC_DST (env->cc_dst) +#define CC_OP (env->cc_op) + +/* float macros */ +#define FT0 (env->ft0) +#define ST0 (env->fpregs[env->fpstt].d) +#define ST(n) (env->fpregs[(env->fpstt + (n)) & 7].d) +#define ST1 ST(1) + /* translate.c */ void optimize_flags_init(void); @@ -984,6 +1014,23 @@ static inline void cpu_clone_regs(CPUState *env, target_ulong newsp) #include "hw/apic.h" #endif +static inline int cpu_has_work(CPUState *env) +{ + return ((env->interrupt_request & CPU_INTERRUPT_HARD) && + (env->eflags & IF_MASK)) || + (env->interrupt_request & (CPU_INTERRUPT_NMI | + CPU_INTERRUPT_INIT | + CPU_INTERRUPT_SIPI | + CPU_INTERRUPT_MCE)); +} + +#include "exec-all.h" + +static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) +{ + env->eip = tb->pc - tb->cs_base; +} + static inline void cpu_get_tb_cpu_state(CPUState *env, target_ulong *pc, target_ulong *cs_base, int *flags) { diff --git a/target-i386/exec.h b/target-i386/exec.h index 3d243d8..068e150 100644 --- a/target-i386/exec.h +++ b/target-i386/exec.h @@ -33,36 +33,6 @@ register struct CPUX86State *env asm(AREG0); #include "qemu-common.h" #include "qemu-log.h" -#undef EAX -#define EAX (env->regs[R_EAX]) -#undef ECX -#define ECX (env->regs[R_ECX]) -#undef EDX -#define EDX (env->regs[R_EDX]) -#undef EBX -#define EBX (env->regs[R_EBX]) -#undef ESP -#define ESP (env->regs[R_ESP]) -#undef EBP -#define EBP (env->regs[R_EBP]) -#undef ESI -#define ESI (env->regs[R_ESI]) -#undef EDI -#define EDI (env->regs[R_EDI]) -#undef EIP -#define EIP (env->eip) -#define DF (env->df) - -#define CC_SRC (env->cc_src) -#define CC_DST (env->cc_dst) -#define CC_OP (env->cc_op) - -/* float macros */ -#define FT0 (env->ft0) -#define ST0 (env->fpregs[env->fpstt].d) -#define ST(n) (env->fpregs[(env->fpstt + (n)) & 7].d) -#define ST1 ST(1) - #include "cpu.h" #include "exec-all.h" @@ -284,16 +254,6 @@ static inline void load_eflags(int eflags, int update_mask) (eflags & update_mask) | 0x2; } -static inline int cpu_has_work(CPUState *env) -{ - return ((env->interrupt_request & CPU_INTERRUPT_HARD) && - (env->eflags & IF_MASK)) || - (env->interrupt_request & (CPU_INTERRUPT_NMI | - CPU_INTERRUPT_INIT | - CPU_INTERRUPT_SIPI | - CPU_INTERRUPT_MCE)); -} - /* load efer and update the corresponding hflags. XXX: do consistency checks with cpuid bits ? */ static inline void cpu_load_efer(CPUState *env, uint64_t val) @@ -305,9 +265,3 @@ static inline void cpu_load_efer(CPUState *env, uint64_t val) if (env->efer & MSR_EFER_SVME) env->hflags |= HF_SVME_MASK; } - -static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) -{ - env->eip = tb->pc - tb->cs_base; -} - diff --git a/target-lm32/cpu.h b/target-lm32/cpu.h index 8e2d26b..0a6af70 100644 --- a/target-lm32/cpu.h +++ b/target-lm32/cpu.h @@ -241,4 +241,17 @@ static inline void cpu_get_tb_cpu_state(CPUState *env, target_ulong *pc, *cs_base = 0; *flags = 0; } + +static inline int cpu_has_work(CPUState *env) +{ + return env->interrupt_request & CPU_INTERRUPT_HARD; +} + +#include "exec-all.h" + +static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) +{ + env->pc = tb->pc; +} + #endif diff --git a/target-lm32/exec.h b/target-lm32/exec.h index 348b723..61eb914 100644 --- a/target-lm32/exec.h +++ b/target-lm32/exec.h @@ -24,11 +24,6 @@ register struct CPULM32State *env asm(AREG0); #include "cpu.h" #include "exec-all.h" -static inline int cpu_has_work(CPUState *env) -{ - return env->interrupt_request & CPU_INTERRUPT_HARD; -} - static inline int cpu_halted(CPUState *env) { if (!env->halted) { @@ -42,9 +37,3 @@ static inline int cpu_halted(CPUState *env) } return EXCP_HALTED; } - -static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) -{ - env->pc = tb->pc; -} - diff --git a/target-m68k/cpu.h b/target-m68k/cpu.h index 4d8ba28..38f38d1 100644 --- a/target-m68k/cpu.h +++ b/target-m68k/cpu.h @@ -255,4 +255,16 @@ static inline void cpu_get_tb_cpu_state(CPUState *env, target_ulong *pc, | ((env->macsr >> 4) & 0xf); /* Bits 0-3 */ } +static inline int cpu_has_work(CPUState *env) +{ + return env->interrupt_request & (CPU_INTERRUPT_HARD); +} + +#include "exec-all.h" + +static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) +{ + env->pc = tb->pc; +} + #endif diff --git a/target-m68k/exec.h b/target-m68k/exec.h index f63e849..568260c 100644 --- a/target-m68k/exec.h +++ b/target-m68k/exec.h @@ -27,14 +27,3 @@ register struct CPUM68KState *env asm(AREG0); #if !defined(CONFIG_USER_ONLY) #include "softmmu_exec.h" #endif - -static inline int cpu_has_work(CPUState *env) -{ - return env->interrupt_request & (CPU_INTERRUPT_HARD); -} - -static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) -{ - env->pc = tb->pc; -} - diff --git a/target-microblaze/cpu.h b/target-microblaze/cpu.h index 78fe14f..21c68c0 100644 --- a/target-microblaze/cpu.h +++ b/target-microblaze/cpu.h @@ -350,4 +350,17 @@ static inline void cpu_get_tb_cpu_state(CPUState *env, target_ulong *pc, void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec, int is_asi, int size); #endif + +static inline int cpu_has_work(CPUState *env) +{ + return env->interrupt_request & (CPU_INTERRUPT_HARD | CPU_INTERRUPT_NMI); +} + +#include "exec-all.h" + +static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) +{ + env->sregs[SR_PC] = tb->pc; +} + #endif diff --git a/target-microblaze/exec.h b/target-microblaze/exec.h index af102d6..b7f85cf 100644 --- a/target-microblaze/exec.h +++ b/target-microblaze/exec.h @@ -26,14 +26,3 @@ register struct CPUMBState *env asm(AREG0); #if !defined(CONFIG_USER_ONLY) #include "softmmu_exec.h" #endif - -static inline int cpu_has_work(CPUState *env) -{ - return env->interrupt_request & (CPU_INTERRUPT_HARD | CPU_INTERRUPT_NMI); -} - -static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) -{ - env->sregs[SR_PC] = tb->pc; -} - diff --git a/target-mips/cpu.h b/target-mips/cpu.h index 0b98d10..b0ac4da 100644 --- a/target-mips/cpu.h +++ b/target-mips/cpu.h @@ -656,4 +656,28 @@ static inline void cpu_set_tls(CPUState *env, target_ulong newtls) env->tls_value = newtls; } +static inline int cpu_has_work(CPUState *env) +{ + int has_work = 0; + + /* It is implementation dependent if non-enabled interrupts + wake-up the CPU, however most of the implementations only + check for interrupts that can be taken. */ + if ((env->interrupt_request & CPU_INTERRUPT_HARD) && + cpu_mips_hw_interrupts_pending(env)) { + has_work = 1; + } + + return has_work; +} + +#include "exec-all.h" + +static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) +{ + env->active_tc.PC = tb->pc; + env->hflags &= ~MIPS_HFLAG_BMASK; + env->hflags |= tb->flags & MIPS_HFLAG_BMASK; +} + #endif /* !defined (__MIPS_CPU_H__) */ diff --git a/target-mips/exec.h b/target-mips/exec.h index 607edf1..a3a7262 100644 --- a/target-mips/exec.h +++ b/target-mips/exec.h @@ -17,21 +17,6 @@ register struct CPUMIPSState *env asm(AREG0); #include "softmmu_exec.h" #endif /* !defined(CONFIG_USER_ONLY) */ -static inline int cpu_has_work(CPUState *env) -{ - int has_work = 0; - - /* It is implementation dependent if non-enabled interrupts - wake-up the CPU, however most of the implementations only - check for interrupts that can be taken. */ - if ((env->interrupt_request & CPU_INTERRUPT_HARD) && - cpu_mips_hw_interrupts_pending(env)) { - has_work = 1; - } - - return has_work; -} - static inline void compute_hflags(CPUState *env) { env->hflags &= ~(MIPS_HFLAG_COP1X | MIPS_HFLAG_64 | MIPS_HFLAG_CP0 | @@ -73,11 +58,4 @@ static inline void compute_hflags(CPUState *env) } } -static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) -{ - env->active_tc.PC = tb->pc; - env->hflags &= ~MIPS_HFLAG_BMASK; - env->hflags |= tb->flags & MIPS_HFLAG_BMASK; -} - #endif /* !defined(__QEMU_MIPS_EXEC_H__) */ diff --git a/target-ppc/cpu.h b/target-ppc/cpu.h index 7a6a7df..2abc82c 100644 --- a/target-ppc/cpu.h +++ b/target-ppc/cpu.h @@ -1999,4 +1999,16 @@ static inline ppcemb_tlb_t *booke206_get_tlbe(CPUState *env, const int tlbn, extern void (*cpu_ppc_hypercall)(CPUState *); +static inline int cpu_has_work(CPUState *env) +{ + return msr_ee && (env->interrupt_request & CPU_INTERRUPT_HARD); +} + +#include "exec-all.h" + +static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) +{ + env->nip = tb->pc; +} + #endif /* !defined (__CPU_PPC_H__) */ diff --git a/target-ppc/exec.h b/target-ppc/exec.h index fbc0a06..1e144be 100644 --- a/target-ppc/exec.h +++ b/target-ppc/exec.h @@ -32,15 +32,4 @@ register struct CPUPPCState *env asm(AREG0); #include "softmmu_exec.h" #endif /* !defined(CONFIG_USER_ONLY) */ -static inline int cpu_has_work(CPUState *env) -{ - return msr_ee && (env->interrupt_request & CPU_INTERRUPT_HARD); -} - - -static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) -{ - env->nip = tb->pc; -} - #endif /* !defined (__PPC_H__) */ diff --git a/target-sh4/cpu.h b/target-sh4/cpu.h index 74ff97a..e61eabc 100644 --- a/target-sh4/cpu.h +++ b/target-sh4/cpu.h @@ -361,4 +361,17 @@ static inline void cpu_get_tb_cpu_state(CPUState *env, target_ulong *pc, | (env->movcal_backup ? TB_FLAG_PENDING_MOVCA : 0); /* Bit 4 */ } +static inline int cpu_has_work(CPUState *env) +{ + return env->interrupt_request & CPU_INTERRUPT_HARD; +} + +#include "exec-all.h" + +static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) +{ + env->pc = tb->pc; + env->flags = tb->flags; +} + #endif /* _CPU_SH4_H */ diff --git a/target-sh4/exec.h b/target-sh4/exec.h index e52838c..a537672 100644 --- a/target-sh4/exec.h +++ b/target-sh4/exec.h @@ -27,19 +27,8 @@ register struct CPUSH4State *env asm(AREG0); #include "cpu.h" #include "exec-all.h" -static inline int cpu_has_work(CPUState *env) -{ - return env->interrupt_request & CPU_INTERRUPT_HARD; -} - #ifndef CONFIG_USER_ONLY #include "softmmu_exec.h" #endif -static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) -{ - env->pc = tb->pc; - env->flags = tb->flags; -} - #endif /* _EXEC_SH4_H */ diff --git a/target-sparc/cpu.h b/target-sparc/cpu.h index eff006c..3287faf 100644 --- a/target-sparc/cpu.h +++ b/target-sparc/cpu.h @@ -660,4 +660,18 @@ static inline void cpu_get_tb_cpu_state(CPUState *env, target_ulong *pc, /* helper.c */ void do_interrupt(CPUState *env); +static inline int cpu_has_work(CPUState *env1) +{ + return (env1->interrupt_request & CPU_INTERRUPT_HARD) && + cpu_interrupts_enabled(env1); +} + +#include "exec-all.h" + +static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) +{ + env->pc = tb->pc; + env->npc = tb->cs_base; +} + #endif diff --git a/target-sparc/exec.h b/target-sparc/exec.h index becdaf5..2395b00 100644 --- a/target-sparc/exec.h +++ b/target-sparc/exec.h @@ -12,18 +12,4 @@ register struct CPUSPARCState *env asm(AREG0); #include "softmmu_exec.h" #endif /* !defined(CONFIG_USER_ONLY) */ -/* op_helper.c */ -static inline int cpu_has_work(CPUState *env1) -{ - return (env1->interrupt_request & CPU_INTERRUPT_HARD) && - cpu_interrupts_enabled(env1); -} - - -static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb) -{ - env->pc = tb->pc; - env->npc = tb->cs_base; -} - #endif diff --git a/target-unicore32/cpu.h b/target-unicore32/cpu.h index 1e10049..bd622c7 100644 --- a/target-unicore32/cpu.h +++ b/target-unicore32/cpu.h @@ -179,4 +179,10 @@ void uc32_translate_init(void); void do_interrupt(CPUState *); void switch_mode(CPUState_UniCore32 *, int); +static inline int cpu_has_work(CPUState *env) +{ + return env->interrupt_request & + (CPU_INTERRUPT_HARD | CPU_INTERRUPT_EXITTB); +} + #endif /* __CPU_UC32_H__ */ diff --git a/target-unicore32/exec.h b/target-unicore32/exec.h index 4ab55f4..6b9b499 100644 --- a/target-unicore32/exec.h +++ b/target-unicore32/exec.h @@ -26,12 +26,6 @@ static inline void regs_to_env(void) { } -static inline int cpu_has_work(CPUState *env) -{ - return env->interrupt_request & - (CPU_INTERRUPT_HARD | CPU_INTERRUPT_EXITTB); -} - static inline int cpu_halted(CPUState *env) { if (!env->halted) { diff --git a/xen-mapcache-stub.c b/xen-mapcache-stub.c index 7c14b3d..0760688 100644 --- a/xen-mapcache-stub.c +++ b/xen-mapcache-stub.c @@ -8,6 +8,7 @@ #include "config.h" +#include "cpu.h" #include "exec-all.h" #include "qemu-common.h" #include "cpu-common.h" -- 1.6.2.4 --0016367b6392da4d6904a3db832e Content-Type: text/x-diff; charset=US-ASCII; name="0008-Move-cpu_has_work-and-cpu_pc_from_tb-to-cpu.h.patch" Content-Disposition: attachment; filename="0008-Move-cpu_has_work-and-cpu_pc_from_tb-to-cpu.h.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_gnzw3ecl0 RnJvbSBmM2Q0NmE1MGEwY2QyYWJjZGE0YTcxZjMwZTJhNzYwMjkzN2RkMTUwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpNZXNzYWdlLUlkOiA8ZjNkNDZhNTBhMGNkMmFiY2RhNGE3MWYzMGUyYTc2 MDI5MzdkZDE1MC4xMzA2MDYyMzc2LmdpdC5ibGF1d2lyYmVsQGdtYWlsLmNvbT4KSW4tUmVwbHkt VG86IDxjODg3Y2M4NjFhOGE1MzFiNjM2YzBhY2FlMWUwNTRhMzg2MWFkMTVhLjEzMDYwNjIzNzYu Z2l0LmJsYXV3aXJiZWxAZ21haWwuY29tPgpSZWZlcmVuY2VzOiA8Yzg4N2NjODYxYThhNTMxYjYz NmMwYWNhZTFlMDU0YTM4NjFhZDE1YS4xMzA2MDYyMzc2LmdpdC5ibGF1d2lyYmVsQGdtYWlsLmNv bT4KRnJvbTogQmx1ZSBTd2lybCA8YmxhdXdpcmJlbEBnbWFpbC5jb20+CkRhdGU6IFNhdCwgMjEg TWF5IDIwMTEgMDc6MTA6MjMgKzAwMDAKU3ViamVjdDogW1BBVENIIDgvOV0gTW92ZSBjcHVfaGFz X3dvcmsgYW5kIGNwdV9wY19mcm9tX3RiIHRvIGNwdS5oCgpNb3ZlIGZ1bmN0aW9ucyBjcHVfaGFz X3dvcmsoKSBhbmQgY3B1X3BjX2Zyb21fdGIoKSBmcm9tIGV4ZWMuaCB0byBjcHUuaC4gVGhpcyBp cwpuZWVkZWQgYnkgbGF0ZXIgcGF0Y2hlcy4KClNpZ25lZC1vZmYtYnk6IEJsdWUgU3dpcmwgPGJs YXV3aXJiZWxAZ21haWwuY29tPgotLS0KIGV4ZWMtYWxsLmggICAgICAgICAgICAgICB8ICAgIDEg KwogdGFyZ2V0LWFscGhhL2NwdS5oICAgICAgIHwgICAxMiArKysrKysrKysrKwogdGFyZ2V0LWFs cGhhL2V4ZWMuaCAgICAgIHwgICAxMCAtLS0tLS0tLS0KIHRhcmdldC1hcm0vY3B1LmggICAgICAg ICB8ICAgMTMgKysrKysrKysrKysrCiB0YXJnZXQtYXJtL2V4ZWMuaCAgICAgICAgfCAgIDEyIC0t LS0tLS0tLS0tCiB0YXJnZXQtY3Jpcy9jcHUuaCAgICAgICAgfCAgIDExICsrKysrKysrKysKIHRh cmdldC1jcmlzL2V4ZWMuaCAgICAgICB8ICAgMTEgLS0tLS0tLS0tLQogdGFyZ2V0LWkzODYvY3B1 LmggICAgICAgIHwgICA0NyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrCiB0YXJnZXQtaTM4Ni9leGVjLmggICAgICAgfCAgIDQ2IC0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogdGFyZ2V0LWxtMzIvY3B1LmggICAgICAgIHwg ICAxMyArKysrKysrKysrKysKIHRhcmdldC1sbTMyL2V4ZWMuaCAgICAgICB8ICAgMTEgLS0tLS0t LS0tLQogdGFyZ2V0LW02OGsvY3B1LmggICAgICAgIHwgICAxMiArKysrKysrKysrKwogdGFyZ2V0 LW02OGsvZXhlYy5oICAgICAgIHwgICAxMSAtLS0tLS0tLS0tCiB0YXJnZXQtbWljcm9ibGF6ZS9j cHUuaCAgfCAgIDEzICsrKysrKysrKysrKwogdGFyZ2V0LW1pY3JvYmxhemUvZXhlYy5oIHwgICAx MSAtLS0tLS0tLS0tCiB0YXJnZXQtbWlwcy9jcHUuaCAgICAgICAgfCAgIDI0ICsrKysrKysrKysr KysrKysrKysrKysrCiB0YXJnZXQtbWlwcy9leGVjLmggICAgICAgfCAgIDIyIC0tLS0tLS0tLS0t LS0tLS0tLS0tLQogdGFyZ2V0LXBwYy9jcHUuaCAgICAgICAgIHwgICAxMiArKysrKysrKysrKwog dGFyZ2V0LXBwYy9leGVjLmggICAgICAgIHwgICAxMSAtLS0tLS0tLS0tCiB0YXJnZXQtc2g0L2Nw dS5oICAgICAgICAgfCAgIDEzICsrKysrKysrKysrKwogdGFyZ2V0LXNoNC9leGVjLmggICAgICAg IHwgICAxMSAtLS0tLS0tLS0tCiB0YXJnZXQtc3BhcmMvY3B1LmggICAgICAgfCAgIDE0ICsrKysr KysrKysrKysKIHRhcmdldC1zcGFyYy9leGVjLmggICAgICB8ICAgMTQgLS0tLS0tLS0tLS0tLQog dGFyZ2V0LXVuaWNvcmUzMi9jcHUuaCAgIHwgICAgNiArKysrKwogdGFyZ2V0LXVuaWNvcmUzMi9l eGVjLmggIHwgICAgNiAtLS0tLQogeGVuLW1hcGNhY2hlLXN0dWIuYyAgICAgIHwgICAgMSArCiAy NiBmaWxlcyBjaGFuZ2VkLCAxOTIgaW5zZXJ0aW9ucygrKSwgMTc2IGRlbGV0aW9ucygtKQoKZGlm ZiAtLWdpdCBhL2V4ZWMtYWxsLmggYi9leGVjLWFsbC5oCmluZGV4IDE4NjI0MjguLmU5NTMzZjMg MTAwNjQ0Ci0tLSBhL2V4ZWMtYWxsLmgKKysrIGIvZXhlYy1hbGwuaApAQCAtNDAsNiArNDAsNyBA QCB0eXBlZGVmIHJhbV9hZGRyX3QgdGJfcGFnZV9hZGRyX3Q7CiAjZGVmaW5lIERJU0FTX1VQREFU RSAgMiAvKiBjcHUgc3RhdGUgd2FzIG1vZGlmaWVkIGR5bmFtaWNhbGx5ICovCiAjZGVmaW5lIERJ U0FTX1RCX0pVTVAgMyAvKiBvbmx5IHBjIHdhcyBtb2RpZmllZCBzdGF0aWNhbGx5ICovCiAKK3N0 cnVjdCBUcmFuc2xhdGlvbkJsb2NrOwogdHlwZWRlZiBzdHJ1Y3QgVHJhbnNsYXRpb25CbG9jayBU cmFuc2xhdGlvbkJsb2NrOwogCiAvKiBYWFg6IG1ha2Ugc2FmZSBndWVzcyBhYm91dCBzaXplcyAq LwpkaWZmIC0tZ2l0IGEvdGFyZ2V0LWFscGhhL2NwdS5oIGIvdGFyZ2V0LWFscGhhL2NwdS5oCmlu ZGV4IDY4NmZiNGEuLjM1OWIyYjYgMTAwNjQ0Ci0tLSBhL3RhcmdldC1hbHBoYS9jcHUuaAorKysg Yi90YXJnZXQtYWxwaGEvY3B1LmgKQEAgLTUzNSw0ICs1MzUsMTYgQEAgc3RhdGljIGlubGluZSB2 b2lkIGNwdV9zZXRfdGxzKENQVVN0YXRlICplbnYsIHRhcmdldF91bG9uZyBuZXd0bHMpCiB9CiAj ZW5kaWYKIAorc3RhdGljIGlubGluZSBpbnQgY3B1X2hhc193b3JrKENQVVN0YXRlICplbnYpCit7 CisgICAgcmV0dXJuIGVudi0+aW50ZXJydXB0X3JlcXVlc3QgJiBDUFVfSU5URVJSVVBUX0hBUkQ7 Cit9CisKKyNpbmNsdWRlICJleGVjLWFsbC5oIgorCitzdGF0aWMgaW5saW5lIHZvaWQgY3B1X3Bj X2Zyb21fdGIoQ1BVU3RhdGUgKmVudiwgVHJhbnNsYXRpb25CbG9jayAqdGIpCit7CisgICAgZW52 LT5wYyA9IHRiLT5wYzsKK30KKwogI2VuZGlmIC8qICFkZWZpbmVkIChfX0NQVV9BTFBIQV9IX18p ICovCmRpZmYgLS1naXQgYS90YXJnZXQtYWxwaGEvZXhlYy5oIGIvdGFyZ2V0LWFscGhhL2V4ZWMu aAppbmRleCAyNmMzYTNhLi5mNTA4OTk2IDEwMDY0NAotLS0gYS90YXJnZXQtYWxwaGEvZXhlYy5o CisrKyBiL3RhcmdldC1hbHBoYS9leGVjLmgKQEAgLTM3LDE0ICszNyw0IEBAIHJlZ2lzdGVyIHN0 cnVjdCBDUFVBbHBoYVN0YXRlICplbnYgYXNtKEFSRUcwKTsKICNpbmNsdWRlICJzb2Z0bW11X2V4 ZWMuaCIKICNlbmRpZiAvKiAhZGVmaW5lZChDT05GSUdfVVNFUl9PTkxZKSAqLwogCi1zdGF0aWMg aW5saW5lIGludCBjcHVfaGFzX3dvcmsoQ1BVU3RhdGUgKmVudikKLXsKLSAgICByZXR1cm4gZW52 LT5pbnRlcnJ1cHRfcmVxdWVzdCAmIENQVV9JTlRFUlJVUFRfSEFSRDsKLX0KLQotc3RhdGljIGlu bGluZSB2b2lkIGNwdV9wY19mcm9tX3RiKENQVVN0YXRlICplbnYsIFRyYW5zbGF0aW9uQmxvY2sg KnRiKQotewotICAgIGVudi0+cGMgPSB0Yi0+cGM7Ci19Ci0KICNlbmRpZiAvKiAhZGVmaW5lZCAo X19BTFBIQV9FWEVDX0hfXykgKi8KZGlmZiAtLWdpdCBhL3RhcmdldC1hcm0vY3B1LmggYi90YXJn ZXQtYXJtL2NwdS5oCmluZGV4IDAxZjViNTcuLmJiNTQzNjMgMTAwNjQ0Ci0tLSBhL3RhcmdldC1h cm0vY3B1LmgKKysrIGIvdGFyZ2V0LWFybS9jcHUuaApAQCAtNTEyLDQgKzUxMiwxNyBAQCBzdGF0 aWMgaW5saW5lIHZvaWQgY3B1X2dldF90Yl9jcHVfc3RhdGUoQ1BVU3RhdGUgKmVudiwgdGFyZ2V0 X3Vsb25nICpwYywKICAgICB9CiB9CiAKK3N0YXRpYyBpbmxpbmUgaW50IGNwdV9oYXNfd29yayhD UFVTdGF0ZSAqZW52KQoreworICAgIHJldHVybiBlbnYtPmludGVycnVwdF9yZXF1ZXN0ICYKKyAg ICAgICAgKENQVV9JTlRFUlJVUFRfRklRIHwgQ1BVX0lOVEVSUlVQVF9IQVJEIHwgQ1BVX0lOVEVS UlVQVF9FWElUVEIpOworfQorCisjaW5jbHVkZSAiZXhlYy1hbGwuaCIKKworc3RhdGljIGlubGlu ZSB2b2lkIGNwdV9wY19mcm9tX3RiKENQVVN0YXRlICplbnYsIFRyYW5zbGF0aW9uQmxvY2sgKnRi KQoreworICAgIGVudi0+cmVnc1sxNV0gPSB0Yi0+cGM7Cit9CisKICNlbmRpZgpkaWZmIC0tZ2l0 IGEvdGFyZ2V0LWFybS9leGVjLmggYi90YXJnZXQtYXJtL2V4ZWMuaAppbmRleCBlZjQ5N2Q4Li42 OGQ2ZmI5IDEwMDY0NAotLS0gYS90YXJnZXQtYXJtL2V4ZWMuaAorKysgYi90YXJnZXQtYXJtL2V4 ZWMuaApAQCAtMjYsMjAgKzI2LDggQEAgcmVnaXN0ZXIgc3RydWN0IENQVUFSTVN0YXRlICplbnYg YXNtKEFSRUcwKTsKICNpbmNsdWRlICJjcHUuaCIKICNpbmNsdWRlICJleGVjLWFsbC5oIgogCi1z dGF0aWMgaW5saW5lIGludCBjcHVfaGFzX3dvcmsoQ1BVU3RhdGUgKmVudikKLXsKLSAgICByZXR1 cm4gZW52LT5pbnRlcnJ1cHRfcmVxdWVzdCAmCi0gICAgICAgIChDUFVfSU5URVJSVVBUX0ZJUSB8 IENQVV9JTlRFUlJVUFRfSEFSRCB8IENQVV9JTlRFUlJVUFRfRVhJVFRCKTsKLX0KLQogI2lmICFk ZWZpbmVkKENPTkZJR19VU0VSX09OTFkpCiAjaW5jbHVkZSAic29mdG1tdV9leGVjLmgiCiAjZW5k aWYKIAogdm9pZCByYWlzZV9leGNlcHRpb24oaW50KTsKLQotc3RhdGljIGlubGluZSB2b2lkIGNw dV9wY19mcm9tX3RiKENQVVN0YXRlICplbnYsIFRyYW5zbGF0aW9uQmxvY2sgKnRiKQotewotICAg IGVudi0+cmVnc1sxNV0gPSB0Yi0+cGM7Ci19Ci0KZGlmZiAtLWdpdCBhL3RhcmdldC1jcmlzL2Nw dS5oIGIvdGFyZ2V0LWNyaXMvY3B1LmgKaW5kZXggMmJjMzVlNC4uYWRiYzM4YiAxMDA2NDQKLS0t IGEvdGFyZ2V0LWNyaXMvY3B1LmgKKysrIGIvdGFyZ2V0LWNyaXMvY3B1LmgKQEAgLTI2OCw0ICsy NjgsMTUgQEAgc3RhdGljIGlubGluZSB2b2lkIGNwdV9nZXRfdGJfY3B1X3N0YXRlKENQVVN0YXRl ICplbnYsIHRhcmdldF91bG9uZyAqcGMsCiAjZGVmaW5lIGNwdV9saXN0IGNyaXNfY3B1X2xpc3QK IHZvaWQgY3Jpc19jcHVfbGlzdChGSUxFICpmLCBmcHJpbnRmX2Z1bmN0aW9uIGNwdV9mcHJpbnRm KTsKIAorc3RhdGljIGlubGluZSBpbnQgY3B1X2hhc193b3JrKENQVVN0YXRlICplbnYpCit7Cisg ICAgcmV0dXJuIGVudi0+aW50ZXJydXB0X3JlcXVlc3QgJiAoQ1BVX0lOVEVSUlVQVF9IQVJEIHwg Q1BVX0lOVEVSUlVQVF9OTUkpOworfQorCisjaW5jbHVkZSAiZXhlYy1hbGwuaCIKKworc3RhdGlj IGlubGluZSB2b2lkIGNwdV9wY19mcm9tX3RiKENQVVN0YXRlICplbnYsIFRyYW5zbGF0aW9uQmxv Y2sgKnRiKQoreworICAgIGVudi0+cGMgPSB0Yi0+cGM7Cit9CiAjZW5kaWYKZGlmZiAtLWdpdCBh L3RhcmdldC1jcmlzL2V4ZWMuaCBiL3RhcmdldC1jcmlzL2V4ZWMuaAppbmRleCA0OTFmMTdjLi45 ODM4MTU5IDEwMDY0NAotLS0gYS90YXJnZXQtY3Jpcy9leGVjLmgKKysrIGIvdGFyZ2V0LWNyaXMv ZXhlYy5oCkBAIC0yNywxNCArMjcsMyBAQCByZWdpc3RlciBzdHJ1Y3QgQ1BVQ1JJU1N0YXRlICpl bnYgYXNtKEFSRUcwKTsKICNpZiAhZGVmaW5lZChDT05GSUdfVVNFUl9PTkxZKQogI2luY2x1ZGUg InNvZnRtbXVfZXhlYy5oIgogI2VuZGlmCi0KLXN0YXRpYyBpbmxpbmUgaW50IGNwdV9oYXNfd29y ayhDUFVTdGF0ZSAqZW52KQotewotICAgIHJldHVybiBlbnYtPmludGVycnVwdF9yZXF1ZXN0ICYg KENQVV9JTlRFUlJVUFRfSEFSRCB8IENQVV9JTlRFUlJVUFRfTk1JKTsKLX0KLQotc3RhdGljIGlu bGluZSB2b2lkIGNwdV9wY19mcm9tX3RiKENQVVN0YXRlICplbnYsIFRyYW5zbGF0aW9uQmxvY2sg KnRiKQotewotICAgIGVudi0+cGMgPSB0Yi0+cGM7Ci19Ci0KZGlmZiAtLWdpdCBhL3RhcmdldC1p Mzg2L2NwdS5oIGIvdGFyZ2V0LWkzODYvY3B1LmgKaW5kZXggNzE0ZjA0OS4uMDkyODI3ZiAxMDA2 NDQKLS0tIGEvdGFyZ2V0LWkzODYvY3B1LmgKKysrIGIvdGFyZ2V0LWkzODYvY3B1LmgKQEAgLTk2 MCw2ICs5NjAsMzYgQEAgc3RhdGljIGlubGluZSBpbnQgY3B1X21tdV9pbmRleCAoQ1BVU3RhdGUg KmVudikKICAgICByZXR1cm4gKGVudi0+aGZsYWdzICYgSEZfQ1BMX01BU0spID09IDMgPyAxIDog MDsKIH0KIAorI3VuZGVmIEVBWAorI2RlZmluZSBFQVggKGVudi0+cmVnc1tSX0VBWF0pCisjdW5k ZWYgRUNYCisjZGVmaW5lIEVDWCAoZW52LT5yZWdzW1JfRUNYXSkKKyN1bmRlZiBFRFgKKyNkZWZp bmUgRURYIChlbnYtPnJlZ3NbUl9FRFhdKQorI3VuZGVmIEVCWAorI2RlZmluZSBFQlggKGVudi0+ cmVnc1tSX0VCWF0pCisjdW5kZWYgRVNQCisjZGVmaW5lIEVTUCAoZW52LT5yZWdzW1JfRVNQXSkK KyN1bmRlZiBFQlAKKyNkZWZpbmUgRUJQIChlbnYtPnJlZ3NbUl9FQlBdKQorI3VuZGVmIEVTSQor I2RlZmluZSBFU0kgKGVudi0+cmVnc1tSX0VTSV0pCisjdW5kZWYgRURJCisjZGVmaW5lIEVESSAo ZW52LT5yZWdzW1JfRURJXSkKKyN1bmRlZiBFSVAKKyNkZWZpbmUgRUlQIChlbnYtPmVpcCkKKyNk ZWZpbmUgREYgIChlbnYtPmRmKQorCisjZGVmaW5lIENDX1NSQyAoZW52LT5jY19zcmMpCisjZGVm aW5lIENDX0RTVCAoZW52LT5jY19kc3QpCisjZGVmaW5lIENDX09QICAoZW52LT5jY19vcCkKKwor LyogZmxvYXQgbWFjcm9zICovCisjZGVmaW5lIEZUMCAgICAoZW52LT5mdDApCisjZGVmaW5lIFNU MCAgICAoZW52LT5mcHJlZ3NbZW52LT5mcHN0dF0uZCkKKyNkZWZpbmUgU1QobikgIChlbnYtPmZw cmVnc1soZW52LT5mcHN0dCArIChuKSkgJiA3XS5kKQorI2RlZmluZSBTVDEgICAgU1QoMSkKKwog LyogdHJhbnNsYXRlLmMgKi8KIHZvaWQgb3B0aW1pemVfZmxhZ3NfaW5pdCh2b2lkKTsKIApAQCAt OTg0LDYgKzEwMTQsMjMgQEAgc3RhdGljIGlubGluZSB2b2lkIGNwdV9jbG9uZV9yZWdzKENQVVN0 YXRlICplbnYsIHRhcmdldF91bG9uZyBuZXdzcCkKICNpbmNsdWRlICJody9hcGljLmgiCiAjZW5k aWYKIAorc3RhdGljIGlubGluZSBpbnQgY3B1X2hhc193b3JrKENQVVN0YXRlICplbnYpCit7Cisg ICAgcmV0dXJuICgoZW52LT5pbnRlcnJ1cHRfcmVxdWVzdCAmIENQVV9JTlRFUlJVUFRfSEFSRCkg JiYKKyAgICAgICAgICAgIChlbnYtPmVmbGFncyAmIElGX01BU0spKSB8fAorICAgICAgICAgICAo ZW52LT5pbnRlcnJ1cHRfcmVxdWVzdCAmIChDUFVfSU5URVJSVVBUX05NSSB8CisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIENQVV9JTlRFUlJVUFRfSU5JVCB8CisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENQVV9JTlRFUlJVUFRfU0lQSSB8CisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENQVV9JTlRFUlJVUFRfTUNFKSk7Cit9 CisKKyNpbmNsdWRlICJleGVjLWFsbC5oIgorCitzdGF0aWMgaW5saW5lIHZvaWQgY3B1X3BjX2Zy b21fdGIoQ1BVU3RhdGUgKmVudiwgVHJhbnNsYXRpb25CbG9jayAqdGIpCit7CisgICAgZW52LT5l aXAgPSB0Yi0+cGMgLSB0Yi0+Y3NfYmFzZTsKK30KKwogc3RhdGljIGlubGluZSB2b2lkIGNwdV9n ZXRfdGJfY3B1X3N0YXRlKENQVVN0YXRlICplbnYsIHRhcmdldF91bG9uZyAqcGMsCiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGFyZ2V0X3Vsb25nICpjc19iYXNlLCBp bnQgKmZsYWdzKQogewpkaWZmIC0tZ2l0IGEvdGFyZ2V0LWkzODYvZXhlYy5oIGIvdGFyZ2V0LWkz ODYvZXhlYy5oCmluZGV4IDNkMjQzZDguLjA2OGUxNTAgMTAwNjQ0Ci0tLSBhL3RhcmdldC1pMzg2 L2V4ZWMuaAorKysgYi90YXJnZXQtaTM4Ni9leGVjLmgKQEAgLTMzLDM2ICszMyw2IEBAIHJlZ2lz dGVyIHN0cnVjdCBDUFVYODZTdGF0ZSAqZW52IGFzbShBUkVHMCk7CiAjaW5jbHVkZSAicWVtdS1j b21tb24uaCIKICNpbmNsdWRlICJxZW11LWxvZy5oIgogCi0jdW5kZWYgRUFYCi0jZGVmaW5lIEVB WCAoZW52LT5yZWdzW1JfRUFYXSkKLSN1bmRlZiBFQ1gKLSNkZWZpbmUgRUNYIChlbnYtPnJlZ3Nb Ul9FQ1hdKQotI3VuZGVmIEVEWAotI2RlZmluZSBFRFggKGVudi0+cmVnc1tSX0VEWF0pCi0jdW5k ZWYgRUJYCi0jZGVmaW5lIEVCWCAoZW52LT5yZWdzW1JfRUJYXSkKLSN1bmRlZiBFU1AKLSNkZWZp bmUgRVNQIChlbnYtPnJlZ3NbUl9FU1BdKQotI3VuZGVmIEVCUAotI2RlZmluZSBFQlAgKGVudi0+ cmVnc1tSX0VCUF0pCi0jdW5kZWYgRVNJCi0jZGVmaW5lIEVTSSAoZW52LT5yZWdzW1JfRVNJXSkK LSN1bmRlZiBFREkKLSNkZWZpbmUgRURJIChlbnYtPnJlZ3NbUl9FREldKQotI3VuZGVmIEVJUAot I2RlZmluZSBFSVAgKGVudi0+ZWlwKQotI2RlZmluZSBERiAgKGVudi0+ZGYpCi0KLSNkZWZpbmUg Q0NfU1JDIChlbnYtPmNjX3NyYykKLSNkZWZpbmUgQ0NfRFNUIChlbnYtPmNjX2RzdCkKLSNkZWZp bmUgQ0NfT1AgIChlbnYtPmNjX29wKQotCi0vKiBmbG9hdCBtYWNyb3MgKi8KLSNkZWZpbmUgRlQw ICAgIChlbnYtPmZ0MCkKLSNkZWZpbmUgU1QwICAgIChlbnYtPmZwcmVnc1tlbnYtPmZwc3R0XS5k KQotI2RlZmluZSBTVChuKSAgKGVudi0+ZnByZWdzWyhlbnYtPmZwc3R0ICsgKG4pKSAmIDddLmQp Ci0jZGVmaW5lIFNUMSAgICBTVCgxKQotCiAjaW5jbHVkZSAiY3B1LmgiCiAjaW5jbHVkZSAiZXhl Yy1hbGwuaCIKIApAQCAtMjg0LDE2ICsyNTQsNiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgbG9hZF9l ZmxhZ3MoaW50IGVmbGFncywgaW50IHVwZGF0ZV9tYXNrKQogICAgICAgICAoZWZsYWdzICYgdXBk YXRlX21hc2spIHwgMHgyOwogfQogCi1zdGF0aWMgaW5saW5lIGludCBjcHVfaGFzX3dvcmsoQ1BV U3RhdGUgKmVudikKLXsKLSAgICByZXR1cm4gKChlbnYtPmludGVycnVwdF9yZXF1ZXN0ICYgQ1BV X0lOVEVSUlVQVF9IQVJEKSAmJgotICAgICAgICAgICAgKGVudi0+ZWZsYWdzICYgSUZfTUFTSykp IHx8Ci0gICAgICAgICAgIChlbnYtPmludGVycnVwdF9yZXF1ZXN0ICYgKENQVV9JTlRFUlJVUFRf Tk1JIHwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ1BVX0lOVEVSUlVQ VF9JTklUIHwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ1BVX0lOVEVS UlVQVF9TSVBJIHwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ1BVX0lO VEVSUlVQVF9NQ0UpKTsKLX0KLQogLyogbG9hZCBlZmVyIGFuZCB1cGRhdGUgdGhlIGNvcnJlc3Bv bmRpbmcgaGZsYWdzLiBYWFg6IGRvIGNvbnNpc3RlbmN5CiAgICBjaGVja3Mgd2l0aCBjcHVpZCBi aXRzID8gKi8KIHN0YXRpYyBpbmxpbmUgdm9pZCBjcHVfbG9hZF9lZmVyKENQVVN0YXRlICplbnYs IHVpbnQ2NF90IHZhbCkKQEAgLTMwNSw5ICsyNjUsMyBAQCBzdGF0aWMgaW5saW5lIHZvaWQgY3B1 X2xvYWRfZWZlcihDUFVTdGF0ZSAqZW52LCB1aW50NjRfdCB2YWwpCiAgICAgaWYgKGVudi0+ZWZl ciAmIE1TUl9FRkVSX1NWTUUpCiAgICAgICAgIGVudi0+aGZsYWdzIHw9IEhGX1NWTUVfTUFTSzsK IH0KLQotc3RhdGljIGlubGluZSB2b2lkIGNwdV9wY19mcm9tX3RiKENQVVN0YXRlICplbnYsIFRy YW5zbGF0aW9uQmxvY2sgKnRiKQotewotICAgIGVudi0+ZWlwID0gdGItPnBjIC0gdGItPmNzX2Jh c2U7Ci19Ci0KZGlmZiAtLWdpdCBhL3RhcmdldC1sbTMyL2NwdS5oIGIvdGFyZ2V0LWxtMzIvY3B1 LmgKaW5kZXggOGUyZDI2Yi4uMGE2YWY3MCAxMDA2NDQKLS0tIGEvdGFyZ2V0LWxtMzIvY3B1LmgK KysrIGIvdGFyZ2V0LWxtMzIvY3B1LmgKQEAgLTI0MSw0ICsyNDEsMTcgQEAgc3RhdGljIGlubGlu ZSB2b2lkIGNwdV9nZXRfdGJfY3B1X3N0YXRlKENQVVN0YXRlICplbnYsIHRhcmdldF91bG9uZyAq cGMsCiAgICAgKmNzX2Jhc2UgPSAwOwogICAgICpmbGFncyA9IDA7CiB9CisKK3N0YXRpYyBpbmxp bmUgaW50IGNwdV9oYXNfd29yayhDUFVTdGF0ZSAqZW52KQoreworICAgIHJldHVybiBlbnYtPmlu dGVycnVwdF9yZXF1ZXN0ICYgQ1BVX0lOVEVSUlVQVF9IQVJEOworfQorCisjaW5jbHVkZSAiZXhl Yy1hbGwuaCIKKworc3RhdGljIGlubGluZSB2b2lkIGNwdV9wY19mcm9tX3RiKENQVVN0YXRlICpl bnYsIFRyYW5zbGF0aW9uQmxvY2sgKnRiKQoreworICAgIGVudi0+cGMgPSB0Yi0+cGM7Cit9CisK ICNlbmRpZgpkaWZmIC0tZ2l0IGEvdGFyZ2V0LWxtMzIvZXhlYy5oIGIvdGFyZ2V0LWxtMzIvZXhl Yy5oCmluZGV4IDM0OGI3MjMuLjYxZWI5MTQgMTAwNjQ0Ci0tLSBhL3RhcmdldC1sbTMyL2V4ZWMu aAorKysgYi90YXJnZXQtbG0zMi9leGVjLmgKQEAgLTI0LDExICsyNCw2IEBAIHJlZ2lzdGVyIHN0 cnVjdCBDUFVMTTMyU3RhdGUgKmVudiBhc20oQVJFRzApOwogI2luY2x1ZGUgImNwdS5oIgogI2lu Y2x1ZGUgImV4ZWMtYWxsLmgiCiAKLXN0YXRpYyBpbmxpbmUgaW50IGNwdV9oYXNfd29yayhDUFVT dGF0ZSAqZW52KQotewotICAgIHJldHVybiBlbnYtPmludGVycnVwdF9yZXF1ZXN0ICYgQ1BVX0lO VEVSUlVQVF9IQVJEOwotfQotCiBzdGF0aWMgaW5saW5lIGludCBjcHVfaGFsdGVkKENQVVN0YXRl ICplbnYpCiB7CiAgICAgaWYgKCFlbnYtPmhhbHRlZCkgewpAQCAtNDIsOSArMzcsMyBAQCBzdGF0 aWMgaW5saW5lIGludCBjcHVfaGFsdGVkKENQVVN0YXRlICplbnYpCiAgICAgfQogICAgIHJldHVy biBFWENQX0hBTFRFRDsKIH0KLQotc3RhdGljIGlubGluZSB2b2lkIGNwdV9wY19mcm9tX3RiKENQ VVN0YXRlICplbnYsIFRyYW5zbGF0aW9uQmxvY2sgKnRiKQotewotICAgIGVudi0+cGMgPSB0Yi0+ cGM7Ci19Ci0KZGlmZiAtLWdpdCBhL3RhcmdldC1tNjhrL2NwdS5oIGIvdGFyZ2V0LW02OGsvY3B1 LmgKaW5kZXggNGQ4YmEyOC4uMzhmMzhkMSAxMDA2NDQKLS0tIGEvdGFyZ2V0LW02OGsvY3B1LmgK KysrIGIvdGFyZ2V0LW02OGsvY3B1LmgKQEAgLTI1NSw0ICsyNTUsMTYgQEAgc3RhdGljIGlubGlu ZSB2b2lkIGNwdV9nZXRfdGJfY3B1X3N0YXRlKENQVVN0YXRlICplbnYsIHRhcmdldF91bG9uZyAq cGMsCiAgICAgICAgICAgICB8ICgoZW52LT5tYWNzciA+PiA0KSAmIDB4Zik7ICAgICAgICAvKiBC aXRzIDAtMyAqLwogfQogCitzdGF0aWMgaW5saW5lIGludCBjcHVfaGFzX3dvcmsoQ1BVU3RhdGUg KmVudikKK3sKKyAgICByZXR1cm4gZW52LT5pbnRlcnJ1cHRfcmVxdWVzdCAmIChDUFVfSU5URVJS VVBUX0hBUkQpOworfQorCisjaW5jbHVkZSAiZXhlYy1hbGwuaCIKKworc3RhdGljIGlubGluZSB2 b2lkIGNwdV9wY19mcm9tX3RiKENQVVN0YXRlICplbnYsIFRyYW5zbGF0aW9uQmxvY2sgKnRiKQor eworICAgIGVudi0+cGMgPSB0Yi0+cGM7Cit9CisKICNlbmRpZgpkaWZmIC0tZ2l0IGEvdGFyZ2V0 LW02OGsvZXhlYy5oIGIvdGFyZ2V0LW02OGsvZXhlYy5oCmluZGV4IGY2M2U4NDkuLjU2ODI2MGMg MTAwNjQ0Ci0tLSBhL3RhcmdldC1tNjhrL2V4ZWMuaAorKysgYi90YXJnZXQtbTY4ay9leGVjLmgK QEAgLTI3LDE0ICsyNywzIEBAIHJlZ2lzdGVyIHN0cnVjdCBDUFVNNjhLU3RhdGUgKmVudiBhc20o QVJFRzApOwogI2lmICFkZWZpbmVkKENPTkZJR19VU0VSX09OTFkpCiAjaW5jbHVkZSAic29mdG1t dV9leGVjLmgiCiAjZW5kaWYKLQotc3RhdGljIGlubGluZSBpbnQgY3B1X2hhc193b3JrKENQVVN0 YXRlICplbnYpCi17Ci0gICAgcmV0dXJuIGVudi0+aW50ZXJydXB0X3JlcXVlc3QgJiAoQ1BVX0lO VEVSUlVQVF9IQVJEKTsKLX0KLQotc3RhdGljIGlubGluZSB2b2lkIGNwdV9wY19mcm9tX3RiKENQ VVN0YXRlICplbnYsIFRyYW5zbGF0aW9uQmxvY2sgKnRiKQotewotICAgIGVudi0+cGMgPSB0Yi0+ cGM7Ci19Ci0KZGlmZiAtLWdpdCBhL3RhcmdldC1taWNyb2JsYXplL2NwdS5oIGIvdGFyZ2V0LW1p Y3JvYmxhemUvY3B1LmgKaW5kZXggNzhmZTE0ZmYuLjIxYzY4YzAgMTAwNjQ0Ci0tLSBhL3Rhcmdl dC1taWNyb2JsYXplL2NwdS5oCisrKyBiL3RhcmdldC1taWNyb2JsYXplL2NwdS5oCkBAIC0zNTAs NCArMzUwLDE3IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBjcHVfZ2V0X3RiX2NwdV9zdGF0ZShDUFVT dGF0ZSAqZW52LCB0YXJnZXRfdWxvbmcgKnBjLAogdm9pZCBkb191bmFzc2lnbmVkX2FjY2Vzcyh0 YXJnZXRfcGh5c19hZGRyX3QgYWRkciwgaW50IGlzX3dyaXRlLCBpbnQgaXNfZXhlYywKICAgICAg ICAgICAgICAgICAgICAgICAgICAgaW50IGlzX2FzaSwgaW50IHNpemUpOwogI2VuZGlmCisKK3N0 YXRpYyBpbmxpbmUgaW50IGNwdV9oYXNfd29yayhDUFVTdGF0ZSAqZW52KQoreworICAgIHJldHVy biBlbnYtPmludGVycnVwdF9yZXF1ZXN0ICYgKENQVV9JTlRFUlJVUFRfSEFSRCB8IENQVV9JTlRF UlJVUFRfTk1JKTsKK30KKworI2luY2x1ZGUgImV4ZWMtYWxsLmgiCisKK3N0YXRpYyBpbmxpbmUg dm9pZCBjcHVfcGNfZnJvbV90YihDUFVTdGF0ZSAqZW52LCBUcmFuc2xhdGlvbkJsb2NrICp0YikK K3sKKyAgICBlbnYtPnNyZWdzW1NSX1BDXSA9IHRiLT5wYzsKK30KKwogI2VuZGlmCmRpZmYgLS1n aXQgYS90YXJnZXQtbWljcm9ibGF6ZS9leGVjLmggYi90YXJnZXQtbWljcm9ibGF6ZS9leGVjLmgK aW5kZXggYWYxMDJkNi4uYjdmODVjZiAxMDA2NDQKLS0tIGEvdGFyZ2V0LW1pY3JvYmxhemUvZXhl Yy5oCisrKyBiL3RhcmdldC1taWNyb2JsYXplL2V4ZWMuaApAQCAtMjYsMTQgKzI2LDMgQEAgcmVn aXN0ZXIgc3RydWN0IENQVU1CU3RhdGUgKmVudiBhc20oQVJFRzApOwogI2lmICFkZWZpbmVkKENP TkZJR19VU0VSX09OTFkpCiAjaW5jbHVkZSAic29mdG1tdV9leGVjLmgiCiAjZW5kaWYKLQotc3Rh dGljIGlubGluZSBpbnQgY3B1X2hhc193b3JrKENQVVN0YXRlICplbnYpCi17Ci0gICAgcmV0dXJu IGVudi0+aW50ZXJydXB0X3JlcXVlc3QgJiAoQ1BVX0lOVEVSUlVQVF9IQVJEIHwgQ1BVX0lOVEVS UlVQVF9OTUkpOwotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgY3B1X3BjX2Zyb21fdGIoQ1BVU3Rh dGUgKmVudiwgVHJhbnNsYXRpb25CbG9jayAqdGIpCi17Ci0gICAgZW52LT5zcmVnc1tTUl9QQ10g PSB0Yi0+cGM7Ci19Ci0KZGlmZiAtLWdpdCBhL3RhcmdldC1taXBzL2NwdS5oIGIvdGFyZ2V0LW1p cHMvY3B1LmgKaW5kZXggMGI5OGQxMC4uYjBhYzRkYSAxMDA2NDQKLS0tIGEvdGFyZ2V0LW1pcHMv Y3B1LmgKKysrIGIvdGFyZ2V0LW1pcHMvY3B1LmgKQEAgLTY1Niw0ICs2NTYsMjggQEAgc3RhdGlj IGlubGluZSB2b2lkIGNwdV9zZXRfdGxzKENQVVN0YXRlICplbnYsIHRhcmdldF91bG9uZyBuZXd0 bHMpCiAgICAgZW52LT50bHNfdmFsdWUgPSBuZXd0bHM7CiB9CiAKK3N0YXRpYyBpbmxpbmUgaW50 IGNwdV9oYXNfd29yayhDUFVTdGF0ZSAqZW52KQoreworICAgIGludCBoYXNfd29yayA9IDA7CisK KyAgICAvKiBJdCBpcyBpbXBsZW1lbnRhdGlvbiBkZXBlbmRlbnQgaWYgbm9uLWVuYWJsZWQgaW50 ZXJydXB0cworICAgICAgIHdha2UtdXAgdGhlIENQVSwgaG93ZXZlciBtb3N0IG9mIHRoZSBpbXBs ZW1lbnRhdGlvbnMgb25seQorICAgICAgIGNoZWNrIGZvciBpbnRlcnJ1cHRzIHRoYXQgY2FuIGJl IHRha2VuLiAqLworICAgIGlmICgoZW52LT5pbnRlcnJ1cHRfcmVxdWVzdCAmIENQVV9JTlRFUlJV UFRfSEFSRCkgJiYKKyAgICAgICAgY3B1X21pcHNfaHdfaW50ZXJydXB0c19wZW5kaW5nKGVudikp IHsKKyAgICAgICAgaGFzX3dvcmsgPSAxOworICAgIH0KKworICAgIHJldHVybiBoYXNfd29yazsK K30KKworI2luY2x1ZGUgImV4ZWMtYWxsLmgiCisKK3N0YXRpYyBpbmxpbmUgdm9pZCBjcHVfcGNf ZnJvbV90YihDUFVTdGF0ZSAqZW52LCBUcmFuc2xhdGlvbkJsb2NrICp0YikKK3sKKyAgICBlbnYt PmFjdGl2ZV90Yy5QQyA9IHRiLT5wYzsKKyAgICBlbnYtPmhmbGFncyAmPSB+TUlQU19IRkxBR19C TUFTSzsKKyAgICBlbnYtPmhmbGFncyB8PSB0Yi0+ZmxhZ3MgJiBNSVBTX0hGTEFHX0JNQVNLOwor fQorCiAjZW5kaWYgLyogIWRlZmluZWQgKF9fTUlQU19DUFVfSF9fKSAqLwpkaWZmIC0tZ2l0IGEv dGFyZ2V0LW1pcHMvZXhlYy5oIGIvdGFyZ2V0LW1pcHMvZXhlYy5oCmluZGV4IDYwN2VkZjEuLmEz YTcyNjIgMTAwNjQ0Ci0tLSBhL3RhcmdldC1taXBzL2V4ZWMuaAorKysgYi90YXJnZXQtbWlwcy9l eGVjLmgKQEAgLTE3LDIxICsxNyw2IEBAIHJlZ2lzdGVyIHN0cnVjdCBDUFVNSVBTU3RhdGUgKmVu diBhc20oQVJFRzApOwogI2luY2x1ZGUgInNvZnRtbXVfZXhlYy5oIgogI2VuZGlmIC8qICFkZWZp bmVkKENPTkZJR19VU0VSX09OTFkpICovCiAKLXN0YXRpYyBpbmxpbmUgaW50IGNwdV9oYXNfd29y ayhDUFVTdGF0ZSAqZW52KQotewotICAgIGludCBoYXNfd29yayA9IDA7Ci0KLSAgICAvKiBJdCBp cyBpbXBsZW1lbnRhdGlvbiBkZXBlbmRlbnQgaWYgbm9uLWVuYWJsZWQgaW50ZXJydXB0cwotICAg ICAgIHdha2UtdXAgdGhlIENQVSwgaG93ZXZlciBtb3N0IG9mIHRoZSBpbXBsZW1lbnRhdGlvbnMg b25seQotICAgICAgIGNoZWNrIGZvciBpbnRlcnJ1cHRzIHRoYXQgY2FuIGJlIHRha2VuLiAqLwot ICAgIGlmICgoZW52LT5pbnRlcnJ1cHRfcmVxdWVzdCAmIENQVV9JTlRFUlJVUFRfSEFSRCkgJiYK LSAgICAgICAgY3B1X21pcHNfaHdfaW50ZXJydXB0c19wZW5kaW5nKGVudikpIHsKLSAgICAgICAg aGFzX3dvcmsgPSAxOwotICAgIH0KLQotICAgIHJldHVybiBoYXNfd29yazsKLX0KLQogc3RhdGlj IGlubGluZSB2b2lkIGNvbXB1dGVfaGZsYWdzKENQVVN0YXRlICplbnYpCiB7CiAgICAgZW52LT5o ZmxhZ3MgJj0gfihNSVBTX0hGTEFHX0NPUDFYIHwgTUlQU19IRkxBR182NCB8IE1JUFNfSEZMQUdf Q1AwIHwKQEAgLTczLDExICs1OCw0IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBjb21wdXRlX2hmbGFn cyhDUFVTdGF0ZSAqZW52KQogICAgIH0KIH0KIAotc3RhdGljIGlubGluZSB2b2lkIGNwdV9wY19m cm9tX3RiKENQVVN0YXRlICplbnYsIFRyYW5zbGF0aW9uQmxvY2sgKnRiKQotewotICAgIGVudi0+ YWN0aXZlX3RjLlBDID0gdGItPnBjOwotICAgIGVudi0+aGZsYWdzICY9IH5NSVBTX0hGTEFHX0JN QVNLOwotICAgIGVudi0+aGZsYWdzIHw9IHRiLT5mbGFncyAmIE1JUFNfSEZMQUdfQk1BU0s7Ci19 Ci0KICNlbmRpZiAvKiAhZGVmaW5lZChfX1FFTVVfTUlQU19FWEVDX0hfXykgKi8KZGlmZiAtLWdp dCBhL3RhcmdldC1wcGMvY3B1LmggYi90YXJnZXQtcHBjL2NwdS5oCmluZGV4IDdhNmE3ZGYuLjJh YmM4MmMgMTAwNjQ0Ci0tLSBhL3RhcmdldC1wcGMvY3B1LmgKKysrIGIvdGFyZ2V0LXBwYy9jcHUu aApAQCAtMTk5OSw0ICsxOTk5LDE2IEBAIHN0YXRpYyBpbmxpbmUgcHBjZW1iX3RsYl90ICpib29r ZTIwNl9nZXRfdGxiZShDUFVTdGF0ZSAqZW52LCBjb25zdCBpbnQgdGxibiwKIAogZXh0ZXJuIHZv aWQgKCpjcHVfcHBjX2h5cGVyY2FsbCkoQ1BVU3RhdGUgKik7CiAKK3N0YXRpYyBpbmxpbmUgaW50 IGNwdV9oYXNfd29yayhDUFVTdGF0ZSAqZW52KQoreworICAgIHJldHVybiBtc3JfZWUgJiYgKGVu di0+aW50ZXJydXB0X3JlcXVlc3QgJiBDUFVfSU5URVJSVVBUX0hBUkQpOworfQorCisjaW5jbHVk ZSAiZXhlYy1hbGwuaCIKKworc3RhdGljIGlubGluZSB2b2lkIGNwdV9wY19mcm9tX3RiKENQVVN0 YXRlICplbnYsIFRyYW5zbGF0aW9uQmxvY2sgKnRiKQoreworICAgIGVudi0+bmlwID0gdGItPnBj OworfQorCiAjZW5kaWYgLyogIWRlZmluZWQgKF9fQ1BVX1BQQ19IX18pICovCmRpZmYgLS1naXQg YS90YXJnZXQtcHBjL2V4ZWMuaCBiL3RhcmdldC1wcGMvZXhlYy5oCmluZGV4IGZiYzBhMDYuLjFl MTQ0YmUgMTAwNjQ0Ci0tLSBhL3RhcmdldC1wcGMvZXhlYy5oCisrKyBiL3RhcmdldC1wcGMvZXhl Yy5oCkBAIC0zMiwxNSArMzIsNCBAQCByZWdpc3RlciBzdHJ1Y3QgQ1BVUFBDU3RhdGUgKmVudiBh c20oQVJFRzApOwogI2luY2x1ZGUgInNvZnRtbXVfZXhlYy5oIgogI2VuZGlmIC8qICFkZWZpbmVk KENPTkZJR19VU0VSX09OTFkpICovCiAKLXN0YXRpYyBpbmxpbmUgaW50IGNwdV9oYXNfd29yayhD UFVTdGF0ZSAqZW52KQotewotICAgIHJldHVybiBtc3JfZWUgJiYgKGVudi0+aW50ZXJydXB0X3Jl cXVlc3QgJiBDUFVfSU5URVJSVVBUX0hBUkQpOwotfQotCi0KLXN0YXRpYyBpbmxpbmUgdm9pZCBj cHVfcGNfZnJvbV90YihDUFVTdGF0ZSAqZW52LCBUcmFuc2xhdGlvbkJsb2NrICp0YikKLXsKLSAg ICBlbnYtPm5pcCA9IHRiLT5wYzsKLX0KLQogI2VuZGlmIC8qICFkZWZpbmVkIChfX1BQQ19IX18p ICovCmRpZmYgLS1naXQgYS90YXJnZXQtc2g0L2NwdS5oIGIvdGFyZ2V0LXNoNC9jcHUuaAppbmRl eCA3NGZmOTdhLi5lNjFlYWJjIDEwMDY0NAotLS0gYS90YXJnZXQtc2g0L2NwdS5oCisrKyBiL3Rh cmdldC1zaDQvY3B1LmgKQEAgLTM2MSw0ICszNjEsMTcgQEAgc3RhdGljIGlubGluZSB2b2lkIGNw dV9nZXRfdGJfY3B1X3N0YXRlKENQVVN0YXRlICplbnYsIHRhcmdldF91bG9uZyAqcGMsCiAgICAg ICAgICAgICB8IChlbnYtPm1vdmNhbF9iYWNrdXAgPyBUQl9GTEFHX1BFTkRJTkdfTU9WQ0EgOiAw KTsgLyogQml0IDQgKi8KIH0KIAorc3RhdGljIGlubGluZSBpbnQgY3B1X2hhc193b3JrKENQVVN0 YXRlICplbnYpCit7CisgICAgcmV0dXJuIGVudi0+aW50ZXJydXB0X3JlcXVlc3QgJiBDUFVfSU5U RVJSVVBUX0hBUkQ7Cit9CisKKyNpbmNsdWRlICJleGVjLWFsbC5oIgorCitzdGF0aWMgaW5saW5l IHZvaWQgY3B1X3BjX2Zyb21fdGIoQ1BVU3RhdGUgKmVudiwgVHJhbnNsYXRpb25CbG9jayAqdGIp Cit7CisgICAgZW52LT5wYyA9IHRiLT5wYzsKKyAgICBlbnYtPmZsYWdzID0gdGItPmZsYWdzOwor fQorCiAjZW5kaWYJCQkJLyogX0NQVV9TSDRfSCAqLwpkaWZmIC0tZ2l0IGEvdGFyZ2V0LXNoNC9l eGVjLmggYi90YXJnZXQtc2g0L2V4ZWMuaAppbmRleCBlNTI4MzhjLi5hNTM3NjcyIDEwMDY0NAot LS0gYS90YXJnZXQtc2g0L2V4ZWMuaAorKysgYi90YXJnZXQtc2g0L2V4ZWMuaApAQCAtMjcsMTkg KzI3LDggQEAgcmVnaXN0ZXIgc3RydWN0IENQVVNINFN0YXRlICplbnYgYXNtKEFSRUcwKTsKICNp bmNsdWRlICJjcHUuaCIKICNpbmNsdWRlICJleGVjLWFsbC5oIgogCi1zdGF0aWMgaW5saW5lIGlu dCBjcHVfaGFzX3dvcmsoQ1BVU3RhdGUgKmVudikKLXsKLSAgICByZXR1cm4gZW52LT5pbnRlcnJ1 cHRfcmVxdWVzdCAmIENQVV9JTlRFUlJVUFRfSEFSRDsKLX0KLQogI2lmbmRlZiBDT05GSUdfVVNF Ul9PTkxZCiAjaW5jbHVkZSAic29mdG1tdV9leGVjLmgiCiAjZW5kaWYKIAotc3RhdGljIGlubGlu ZSB2b2lkIGNwdV9wY19mcm9tX3RiKENQVVN0YXRlICplbnYsIFRyYW5zbGF0aW9uQmxvY2sgKnRi KQotewotICAgIGVudi0+cGMgPSB0Yi0+cGM7Ci0gICAgZW52LT5mbGFncyA9IHRiLT5mbGFnczsK LX0KLQogI2VuZGlmCQkJCS8qIF9FWEVDX1NINF9IICovCmRpZmYgLS1naXQgYS90YXJnZXQtc3Bh cmMvY3B1LmggYi90YXJnZXQtc3BhcmMvY3B1LmgKaW5kZXggZWZmMDA2Yy4uMzI4N2ZhZiAxMDA2 NDQKLS0tIGEvdGFyZ2V0LXNwYXJjL2NwdS5oCisrKyBiL3RhcmdldC1zcGFyYy9jcHUuaApAQCAt NjYwLDQgKzY2MCwxOCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgY3B1X2dldF90Yl9jcHVfc3RhdGUo Q1BVU3RhdGUgKmVudiwgdGFyZ2V0X3Vsb25nICpwYywKIC8qIGhlbHBlci5jICovCiB2b2lkIGRv X2ludGVycnVwdChDUFVTdGF0ZSAqZW52KTsKIAorc3RhdGljIGlubGluZSBpbnQgY3B1X2hhc193 b3JrKENQVVN0YXRlICplbnYxKQoreworICAgIHJldHVybiAoZW52MS0+aW50ZXJydXB0X3JlcXVl c3QgJiBDUFVfSU5URVJSVVBUX0hBUkQpICYmCisgICAgICAgICAgIGNwdV9pbnRlcnJ1cHRzX2Vu YWJsZWQoZW52MSk7Cit9CisKKyNpbmNsdWRlICJleGVjLWFsbC5oIgorCitzdGF0aWMgaW5saW5l IHZvaWQgY3B1X3BjX2Zyb21fdGIoQ1BVU3RhdGUgKmVudiwgVHJhbnNsYXRpb25CbG9jayAqdGIp Cit7CisgICAgZW52LT5wYyA9IHRiLT5wYzsKKyAgICBlbnYtPm5wYyA9IHRiLT5jc19iYXNlOwor fQorCiAjZW5kaWYKZGlmZiAtLWdpdCBhL3RhcmdldC1zcGFyYy9leGVjLmggYi90YXJnZXQtc3Bh cmMvZXhlYy5oCmluZGV4IGJlY2RhZjUuLjIzOTViMDAgMTAwNjQ0Ci0tLSBhL3RhcmdldC1zcGFy Yy9leGVjLmgKKysrIGIvdGFyZ2V0LXNwYXJjL2V4ZWMuaApAQCAtMTIsMTggKzEyLDQgQEAgcmVn aXN0ZXIgc3RydWN0IENQVVNQQVJDU3RhdGUgKmVudiBhc20oQVJFRzApOwogI2luY2x1ZGUgInNv ZnRtbXVfZXhlYy5oIgogI2VuZGlmIC8qICFkZWZpbmVkKENPTkZJR19VU0VSX09OTFkpICovCiAK LS8qIG9wX2hlbHBlci5jICovCi1zdGF0aWMgaW5saW5lIGludCBjcHVfaGFzX3dvcmsoQ1BVU3Rh dGUgKmVudjEpCi17Ci0gICAgcmV0dXJuIChlbnYxLT5pbnRlcnJ1cHRfcmVxdWVzdCAmIENQVV9J TlRFUlJVUFRfSEFSRCkgJiYKLSAgICAgICAgICAgY3B1X2ludGVycnVwdHNfZW5hYmxlZChlbnYx KTsKLX0KLQotCi1zdGF0aWMgaW5saW5lIHZvaWQgY3B1X3BjX2Zyb21fdGIoQ1BVU3RhdGUgKmVu diwgVHJhbnNsYXRpb25CbG9jayAqdGIpCi17Ci0gICAgZW52LT5wYyA9IHRiLT5wYzsKLSAgICBl bnYtPm5wYyA9IHRiLT5jc19iYXNlOwotfQotCiAjZW5kaWYKZGlmZiAtLWdpdCBhL3RhcmdldC11 bmljb3JlMzIvY3B1LmggYi90YXJnZXQtdW5pY29yZTMyL2NwdS5oCmluZGV4IDFlMTAwNDkuLmJk NjIyYzcgMTAwNjQ0Ci0tLSBhL3RhcmdldC11bmljb3JlMzIvY3B1LmgKKysrIGIvdGFyZ2V0LXVu aWNvcmUzMi9jcHUuaApAQCAtMTc5LDQgKzE3OSwxMCBAQCB2b2lkIHVjMzJfdHJhbnNsYXRlX2lu aXQodm9pZCk7CiB2b2lkIGRvX2ludGVycnVwdChDUFVTdGF0ZSAqKTsKIHZvaWQgc3dpdGNoX21v ZGUoQ1BVU3RhdGVfVW5pQ29yZTMyICosIGludCk7CiAKK3N0YXRpYyBpbmxpbmUgaW50IGNwdV9o YXNfd29yayhDUFVTdGF0ZSAqZW52KQoreworICAgIHJldHVybiBlbnYtPmludGVycnVwdF9yZXF1 ZXN0ICYKKyAgICAgICAgKENQVV9JTlRFUlJVUFRfSEFSRCB8IENQVV9JTlRFUlJVUFRfRVhJVFRC KTsKK30KKwogI2VuZGlmIC8qIF9fQ1BVX1VDMzJfSF9fICovCmRpZmYgLS1naXQgYS90YXJnZXQt dW5pY29yZTMyL2V4ZWMuaCBiL3RhcmdldC11bmljb3JlMzIvZXhlYy5oCmluZGV4IDRhYjU1ZjQu LjZiOWI0OTkgMTAwNjQ0Ci0tLSBhL3RhcmdldC11bmljb3JlMzIvZXhlYy5oCisrKyBiL3Rhcmdl dC11bmljb3JlMzIvZXhlYy5oCkBAIC0yNiwxMiArMjYsNiBAQCBzdGF0aWMgaW5saW5lIHZvaWQg cmVnc190b19lbnYodm9pZCkKIHsKIH0KIAotc3RhdGljIGlubGluZSBpbnQgY3B1X2hhc193b3Jr KENQVVN0YXRlICplbnYpCi17Ci0gICAgcmV0dXJuIGVudi0+aW50ZXJydXB0X3JlcXVlc3QgJgot ICAgICAgICAoQ1BVX0lOVEVSUlVQVF9IQVJEIHwgQ1BVX0lOVEVSUlVQVF9FWElUVEIpOwotfQot CiBzdGF0aWMgaW5saW5lIGludCBjcHVfaGFsdGVkKENQVVN0YXRlICplbnYpCiB7CiAgICAgaWYg KCFlbnYtPmhhbHRlZCkgewpkaWZmIC0tZ2l0IGEveGVuLW1hcGNhY2hlLXN0dWIuYyBiL3hlbi1t YXBjYWNoZS1zdHViLmMKaW5kZXggN2MxNGIzZC4uMDc2MDY4OCAxMDA2NDQKLS0tIGEveGVuLW1h cGNhY2hlLXN0dWIuYworKysgYi94ZW4tbWFwY2FjaGUtc3R1Yi5jCkBAIC04LDYgKzgsNyBAQAog CiAjaW5jbHVkZSAiY29uZmlnLmgiCiAKKyNpbmNsdWRlICJjcHUuaCIKICNpbmNsdWRlICJleGVj LWFsbC5oIgogI2luY2x1ZGUgInFlbXUtY29tbW9uLmgiCiAjaW5jbHVkZSAiY3B1LWNvbW1vbi5o IgotLSAKMS43LjIuNQoK --0016367b6392da4d6904a3db832e--